Partager via

basic_regex, classe

  • Article

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