Namespaces
Variants

std::regex_constants:: syntax_option_type

From cppreference.net
C++
Text processing library
Regular expressions library
Classes
(C++11)
(C++11)
(C++11)
Algorithms
(C++11)
(C++11)
(C++11)
Iterators
(C++11)
(C++11)
Exceptions
(C++11)
Traits
(C++11)
Constants
syntax_option_type
(C++11)
(C++11)
(C++11)
Regex Grammar
(C++11)
Definido en el encabezado <regex>
using syntax_option_type = /* implementation-defined */ ;
(1) (desde C++11)
constexpr syntax_option_type icase = /* unspecified */ ;

constexpr syntax_option_type nosubs = /* unspecified */ ;
constexpr syntax_option_type optimize = /* unspecified */ ;
constexpr syntax_option_type collate = /* unspecified */ ;
constexpr syntax_option_type ECMAScript = /* unspecified */ ;
constexpr syntax_option_type basic = /* unspecified */ ;
constexpr syntax_option_type extended = /* unspecified */ ;
constexpr syntax_option_type awk = /* unspecified */ ;
constexpr syntax_option_type grep = /* unspecified */ ;

constexpr syntax_option_type egrep = /* unspecified */ ;
(2) (desde C++11)
(inline desde C++17)
inline constexpr syntax_option_type multiline = /* unspecified */ ;
(3) (desde C++17)
1) El syntax_option_type es un BitmaskType que contiene opciones que gobiernan cómo se comportan las expresiones regulares.
2,3) Los valores posibles ( icase , optimize , etc.) para el tipo (1) están duplicados dentro de std::basic_regex .

Contenidos

Constantes

Opción de gramática Efecto(s)
ECMAScript Utiliza la gramática de expresiones regulares ECMAScript modificada .
basic Utiliza la gramática de expresiones regulares POSIX básica ( documentación de gramática ).
extended Utiliza la gramática de expresiones regulares POSIX extendida ( documentación de gramática ).
awk Utiliza la gramática de expresiones regulares empleada por la utilidad awk en POSIX ( documentación de gramática ).
grep Utiliza la gramática de expresiones regulares empleada por la utilidad grep en POSIX. Esto es efectivamente igual que la opción basic con la adición de nueva línea ' \n ' como separador de alternancia.
egrep Utiliza la gramática de expresiones regulares empleada por la utilidad grep , con la opción -E , en POSIX. Esto es efectivamente igual que la opción extended con la adición de nueva línea ' \n ' como separador de alternancia además de '|' .
Variación de gramática Efecto(s)
icase La coincidencia de caracteres debe realizarse sin distinguir entre mayúsculas y minúsculas.
nosubs Al realizar coincidencias, todas las subexpresiones marcadas ( expr ) se tratan como subexpresiones no marcadoras (?: expr ) . No se almacenan coincidencias en la estructura std::regex_match suministrada y mark_count() es cero.
optimize Indica al motor de expresiones regulares que acelere la coincidencia, con el costo potencial de ralentizar la construcción. Por ejemplo, esto podría significar convertir un FSA no determinista en un FSA determinista.
collate Los rangos de caracteres de la forma "[a-b]" serán sensibles a la configuración regional.
multiline (C++17) Especifica que ^ coincidirá con el inicio de una línea y $ coincidirá con el final de una línea, si se selecciona el motor ECMAScript.

Como máximo se puede elegir una opción de gramática entre ECMAScript , basic , extended , awk , grep , egrep . Si no se elige ninguna gramática, ECMAScript se asume como seleccionada. Las otras opciones sirven como variaciones, de modo que std:: regex ( "meow" , std :: regex :: icase ) es equivalente a std:: regex ( "meow" , std :: regex :: ECMAScript | std :: regex :: icase ) .

Notas

Debido a que POSIX utiliza la regla de coincidencia "más a la izquierda y más larga" (se coincide con la subsecuencia coincidente más larga, y si hay varias de estas subsecuencias, se coincide con la primera), no es adecuado, por ejemplo, para analizar lenguajes de marcado: una expresión regular POSIX como "<tag[^>]*>.*</tag>" coincidiría con todo desde el primer "<tag" hasta el último "</tag>" , incluyendo cada "</tag>" y "<tag>" intermedio. Por otro lado, ECMAScript admite coincidencias no codiciosas, y la expresión regular de ECMAScript "<tag[^>]*>.*?</tag>" coincidiría solo hasta la primera etiqueta de cierre.

Ejemplo

Ilustra la diferencia en el algoritmo de coincidencia entre las expresiones regulares ECMAScript y POSIX:

Ejecutar este código 
#include <iostream>
#include <regex>
#include <string>
int main()
{
    std::string str = "zzxayyzz";
    std::regex re1(".*(a|xayy)"); // ECMA
    std::regex re2(".*(a|xayy)", std::regex::extended); // POSIX
    std::cout << "Searching for .*(a|xayy) in zzxayyzz:\n";
    std::smatch m;
    std::regex_search(str, m, re1);
    std::cout << "  ECMA (depth first search) match: " << m[0] << '\n';
    std::regex_search(str, m, re2);
    std::cout << "  POSIX (leftmost longest)  match: " << m[0] << '\n';
}

Salida: 

Searching for .*(a|xayy) in zzxayyzz:
  ECMA (depth first search) match: zzxa
  POSIX (leftmost longest)  match: zzxayy

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2053 C++11 las constantes se declararon static se eliminó el especificador static

Véase también

(C++11)
objeto de expresión regular
(plantilla de clase)