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)
Défini dans l'en-tête <regex>
using syntax_option_type = /* implementation-defined */ ;
(1) (depuis 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) (depuis C++11)
(inline depuis C++17)
inline constexpr syntax_option_type multiline = /* unspecified */ ;
(3) (depuis C++17)
1) Le syntax_option_type est un BitmaskType qui contient des options qui régissent le comportement des expressions régulières.
2,3) Les valeurs possibles ( icase , optimize , etc.) pour le type (1) sont dupliquées dans std::basic_regex .

Table des matières

Constantes

Option de grammaire Effet(s)
ECMAScript Utilise la grammaire d'expressions régulières ECMAScript modifiée .
basic Utilise la grammaire d'expressions régulières POSIX de base ( documentation de la grammaire ).
extended Utilise la grammaire d'expressions régulières POSIX étendue ( documentation de la grammaire ).
awk Utilise la grammaire d'expressions régulières employée par l'utilitaire awk dans POSIX ( documentation de la grammaire ).
grep Utilise la grammaire d'expressions régulières employée par l'utilitaire grep dans POSIX. C'est effectivement la même que l'option basic avec l'ajout du saut de ligne ' \n ' comme séparateur d'alternative.
egrep Utilise la grammaire d'expressions régulières employée par l'utilitaire grep avec l'option -E dans POSIX. C'est effectivement la même que l'option extended avec l'ajout du saut de ligne ' \n ' comme séparateur d'alternative en plus de '|' .
Variation de grammaire Effet(s)
icase La correspondance des caractères doit être effectuée sans tenir compte de la casse.
nosubs Lors de l'exécution des correspondances, toutes les sous-expressions marquées ( expr ) sont traitées comme des sous-expressions non marquantes (?: expr ) . Aucune correspondance n'est stockée dans la structure std::regex_match fournie et mark_count() est zéro.
optimize Demande au moteur d'expressions régulières d'optimiser la vitesse de correspondance, au prix potentiel d'un temps de construction plus long. Par exemple, cela peut impliquer la conversion d'un AFN en AFD.
collate Les plages de caractères de la forme "[a-b]" seront sensibles à la locale.
multiline (C++17) Spécifie que ^ doit correspondre au début d'une ligne et $ doit correspondre à la fin d'une ligne, si le moteur ECMAScript est sélectionné.

Au plus une option de grammaire peut être choisie parmi ECMAScript , basic , extended , awk , grep , egrep . Si aucune grammaire n'est choisie, ECMAScript est supposée être sélectionnée. Les autres options servent de variantes, de sorte que std:: regex ( "meow" , std :: regex :: icase ) est équivalent à std:: regex ( "meow" , std :: regex :: ECMAScript | std :: regex :: icase ) .

Notes

Parce que POSIX utilise la règle de correspondance « la plus à gauche la plus longue » (la sous-séquence correspondante la plus longue est trouvée, et s'il y a plusieurs sous-séquences de même longueur, la première est choisie), elle n'est pas adaptée, par exemple, pour l'analyse des langages de balisage : une expression régulière POSIX telle que "<tag[^>]*>.*</tag>" correspondrait à tout depuis la première occurrence de "<tag" jusqu'à la dernière occurrence de "</tag>" , incluant toutes les occurrences intermédiaires de "</tag>" et "<tag>" . D'un autre côté, ECMAScript prend en charge les correspondances non gourmandes, et l'expression régulière ECMAScript "<tag[^>]*>.*?</tag>" ne correspondrait qu'à la première balise fermante rencontrée.

Exemple

Illustre la différence dans l'algorithme de correspondance entre les expressions régulières ECMAScript et POSIX :

Exécuter ce code 
#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';
}

Sortie : 

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement correct
LWG 2053 C++11 les constantes étaient déclarées static supprimé le spécificateur static

Voir aussi

(C++11)
objet d'expression régulière
(modèle de classe)