basic_regex, classe
Encapsule une expression régulière.
Syntaxe
template <class Elem, class RXtraits>
class basic_regex
Paramètres
Elem
Type des éléments à faire correspondre.
RXtraits
Classe Traits des éléments.
Notes
Le modèle de classe décrit un objet qui contient une expression régulière. Les objets de ce modèle de classe peuvent être passés aux fonctions de modèle regex_match, regex_search et regex_replace. Il transmet également les arguments de chaîne de texte appropriés pour rechercher du texte qui correspond à l’expression régulière. Il existe deux spécialisations de ce modèle de classe, avec les définitions de type regex pour les éléments de type charet wregex pour les éléments de type wchar_t.
L’argument de modèle RXtraits décrit différentes propriétés importantes de la syntaxe des expressions régulières prises en charge par le modèle de classe. Une classe qui spécifie ces caractéristiques d’expression régulière doit avoir la même interface externe qu’un objet de type regex_traits Class.
Certaines fonctions acceptent une séquence d’opérande qui définit une expression régulière. Vous pouvez spécifier cette séquence d'opérande de plusieurs façons :
ptr: séquence terminée par null (telle qu’une chaîne C, pour Elem de type char) commençant à ptr (qui ne doit pas être un pointeur Null), où l’élément de fin est la valeur value_type() et ne fait pas partie de la séquence d’opérande
ptr, : countséquence d’éléments count commençant à ptr (qui ne doit pas être un pointeur Null)
str: séquence spécifiée par l’objet basic_stringstr
first, last: séquence d’éléments délimités par les itérateurs first et last, dans la plage [first, last)
right: l’objet basic_regexright
Les fonctions membres ci-dessus prennent également un argument flags qui spécifie différentes options pour l’interprétation de l’expression régulière en plus des options décrites par le type RXtraits .
Membres
| Membre | Valeur par défaut |
|---|---|
| public static const flag_type icase | regex_constants ::icase |
| public static const flag_type nosubs | regex_constants ::nosubs |
| public static const flag_type optimize | regex_constants ::optimize |
| public static const flag_type collate | regex_constants ::collate |
| public static const flag_type ECMAScript | regex_constants ::ECMAScript |
| public static const flag_type basic | regex_constants ::basic |
| public static const flag_type étendu | regex_constants ::extended |
| public static const flag_type awk | regex_constants ::awk |
| public static const flag_type grep | regex_constants ::grep |
| public static const flag_type egrep | regex_constants ::egrep |
| caractéristiques RXtraits privées |
Constructeurs
| Constructeur | Description |
|---|---|
| basic_regex | Construit l'objet d'expression régulière. |
Typedefs
| Nom de type | Description |
|---|---|
| flag_type | Type des indicateurs d’option de syntaxe. |
| locale_type | Type de l’objet de paramètres régionaux stocké. |
| value_type | Type de l’élément. |
Fonctions Membre
| Fonction membre | Description |
|---|---|
| assign | Assigne une valeur à l’objet d’expression régulière. |
| flags | Retourne des indicateurs d’option de syntaxe. |
| getloc | Retourne l’objet des paramètres régionaux stockés. |
| imbue | Modifie l’objet des paramètres régionaux stocké. |
| mark_count | Retourne le nombre de sous-expressions en correspondance. |
| swap | Échange deux objets d’expression régulière. |
Opérateurs
| Opérateur | Description |
|---|---|
| operator= | Assigne une valeur à l’objet d’expression régulière. |
Spécifications
Header :<regex>
Espace de noms : std
Exemple
// std__regex__basic_regex.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>
using namespace std;
int main()
{
regex::value_type elem = 'x';
regex::flag_type flag = regex::grep;
elem = elem; // to quiet "unused" warnings
flag = flag;
// constructors
regex rx0;
cout << "match(\"abc\", \"\") == " << boolalpha
<< regex_match("abc", rx0) << endl;
regex rx1("abcd", regex::ECMAScript);
cout << "match(\"abc\", \"abcd\") == " << boolalpha
<< regex_match("abc", rx1) << endl;
regex rx2("abcd", 3);
cout << "match(\"abc\", \"abc\") == " << boolalpha
<< regex_match("abc", rx2) << endl;
regex rx3(rx2);
cout << "match(\"abc\", \"abc\") == " << boolalpha
<< regex_match("abc", rx3) << endl;
string str("abcd");
regex rx4(str);
cout << "match(string(\"abcd\"), \"abc\") == " << boolalpha
<< regex_match("abc", rx4) << endl;
regex rx5(str.begin(), str.end() - 1);
cout << "match(string(\"abc\"), \"abc\") == " << boolalpha
<< regex_match("abc", rx5) << endl;
cout << endl;
// assignments
rx0 = "abc";
rx0 = rx1;
rx0 = str;
rx0.assign("abcd", regex::ECMAScript);
rx0.assign("abcd", 3);
rx0.assign(rx1);
rx0.assign(str);
rx0.assign(str.begin(), str.end() - 1);
rx0.swap(rx1);
// mark_count
cout << "\"abc\" mark_count == "
<< regex("abc").mark_count() << endl;
cout << "\"(abc)\" mark_count == "
<< regex("(abc)").mark_count() << endl;
// locales
regex::locale_type loc = rx0.imbue(locale());
cout << "getloc == imbued == " << boolalpha
<< (loc == rx0.getloc()) << endl;
// initializer_list
regex rx6({ 'a', 'b', 'c' }, regex::ECMAScript);
cout << "match(\"abc\") == " << boolalpha
<< regex_match("abc", rx6);
cout << endl;
}
match("abc", "") == false
match("abc", "abcd") == false
match("abc", "abc") == true
match("abc", "abc") == true
match(string("abcd"), "abc") == false
match(string("abc"), "abc") == true
"abc" mark_count == 0
"(abc)" mark_count == 1
getloc == imbued == true
match("abc") == true
basic_regex ::assign
Assigne une valeur à l’objet d’expression régulière.
basic_regex& assign(
const basic_regex& right);
basic_regex& assign(
const Elem* ptr,
flag_type flags = ECMAScript);
basic_regex& assign(
const Elem* ptr,
size_type len,
flag_type flags = ECMAScript);
basic_regex& assign(
initializer_list<_Elem> IList,
flag_type flags = regex_constants::ECMAScript);
template <class STtraits, class STalloc>
basic_regex& assign(
const basic_string<Elem, STtraits, STalloc>& str,
flag_type flags = ECMAScript);
template <class InIt>
basic_regex& assign(
InIt first, InIt last,
flag_type flags = ECMAScript);
Paramètres
STtraits
Classe de caractéristiques pour une source de chaîne.
STalloc
Classe d'allocateurs pour une source de chaîne.
Init
Type d'itérateur d'entrée pour une source de plage.
right
Regex source à copier.
ptr
Pointeur vers le début de la séquence à copier.
flags
Indicateurs d'option de syntaxe à ajouter lors de la copie.
len/TD>
Longueur de la séquence à copier.
str
Chaîne à copier.
first
Début de la séquence à copier.
last
Fin de la séquence à copier.
IList
Initializer_list à copier.
Notes
Les fonctions membres remplacent chacune l'expression régulière détenue par *this par l'expression régulière décrite par la séquence d'opérande, puis retournent *this.
basic_regex ::basic_regex
Construit l'objet d'expression régulière.
basic_regex();
explicit basic_regex(
const Elem* ptr,
flag_type flags);
explicit basic_regex(
const Elem* ptr,
size_type len,
flag_type flags);
basic_regex(
const basic_regex& right);
basic_regex(
initializer_list<Type> IList,
flag_type flags);
template <class STtraits, class STalloc>
explicit basic_regex(
const basic_string<Elem, STtraits, STalloc>& str,
flag_type flags);
template <class InIt>
explicit basic_regex(
InIt first,
InIt last,
flag_type flags);
Paramètres
STtraits
Classe de caractéristiques pour une source de chaîne.
STalloc
Classe d'allocateurs pour une source de chaîne.
Init
Type d'itérateur d'entrée pour une source de plage.
right
Regex source à copier.
ptr
Pointeur vers le début de la séquence à copier.
flags
Indicateurs d'option de syntaxe à ajouter lors de la copie.
len/TD>
Longueur de la séquence à copier.
str
Chaîne à copier.
first
Début de la séquence à copier.
last
Fin de la séquence à copier.
IList
Initializer_list à copier.
Notes
Tous les constructeurs stockent un objet construit par défaut de type RXtraits.
Le premier constructeur construit un objet basic_regex vide. Les autres constructeurs construisent un objet basic_regex qui contient l'expression régulière décrite par la séquence d'opérande.
Un objet vide basic_regex ne correspond à aucune séquence de caractères lorsqu’il est passé à regex_match, regex_search ou regex_replace.
basic_regex ::flag_type
Type des indicateurs d’option de syntaxe.
typedef regex_constants::syntax_option_type flag_type;
Notes
Le type est un synonyme de regex_constants::syntax_option_type.
basic_regex ::flags
Retourne des indicateurs d’option de syntaxe.
flag_type flags() const;
Notes
La fonction membre retourne la valeur de l’argument flag_type passé à l’appel le plus récent des fonctions membres basic_regex::assign ou, si aucun appel n’a été effectué, la valeur passée au constructeur.
basic_regex ::getloc
Retourne l’objet des paramètres régionaux stockés.
locale_type getloc() const;
Notes
La fonction membre retourne traits.regex_traits::getloc().
basic_regex ::imbue
Modifie l’objet des paramètres régionaux stocké.
locale_type imbue(locale_type loc);
Paramètres
Loc
Objet de paramètres régionaux à stocker.
Notes
La fonction membre vide *this et retourne traits.regex_traits::imbue(loc).
basic_regex ::locale_type
Type de l’objet de paramètres régionaux stocké.
typedef typename RXtraits::locale_type locale_type;
Notes
Le type est un synonyme de regex_traits::locale_type.
basic_regex ::mark_count
Retourne le nombre de sous-expressions en correspondance.
unsigned mark_count() const;
Notes
La fonction membre retourne le nombre de groupes de capture dans l’expression régulière.
basic_regex ::operator=
Assigne une valeur à l’objet d’expression régulière.
basic_regex& operator=(const basic_regex& right);
basic_regex& operator=(const Elem *str);
template <class STtraits, class STalloc>
basic_regex& operator=(const basic_string<Elem, STtraits, STalloc>& str);
Paramètres
STtraits
Classe de caractéristiques pour une source de chaîne.
STalloc
Classe d'allocateurs pour une source de chaîne.
right
Regex source à copier.
str
Chaîne à copier.
Notes
Les opérateurs remplacent chacun l’expression régulière détenue par *this par l’expression régulière décrite par la séquence d’opérande, puis retournent *this.
basic_regex ::swap
Échange deux objets d’expression régulière.
void swap(basic_regex& right) throw();
Paramètres
right
Objet d’expression régulière à échanger.
Notes
La fonction membre échange les expressions régulières entre *this et droite. Elle le fait dans un cadre de temps fixe, et ne lève aucune exception.
basic_regex ::value_type
Type de l’élément.
typedef Elem value_type;
Notes
Le type est un synonyme du paramètre de modèle Elem.
Voir aussi
<regex>
regex_match
regex_search
regex_replace
regex
wregex
regex_traits, classe
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour