Classe basic_regex

Encapsula uma expressão regular.

Sintaxe

template <class Elem, class RXtraits>
class basic_regex

Parâmetros

Elem
O tipo de elemento a ser correspondido.

RXtraits
Classe de características para elementos.

Comentários

Uma classe de modelo descreve um objeto que mantém uma expressão regular. Objetos desse modelo de classe podem ser passados para as funções de modelo regex_match, regex_search e regex_replace. Ele também passa os argumentos de cadeia de caracteres de texto adequados para pesquisar texto que corresponda à expressão regular. Há duas especializações desse modelo de classe, com as definições de tipo regex para os elementos do tipo char, e wregex para elementos do tipo wchar_t.

O argumento de modelo RXtraits descreve as várias propriedades importantes da sintaxe das expressões regulares que têm suporte do modelo de classe. Uma classe que especifica essas características da expressão regular precisa ter a mesma interface externa que um objeto do tipo classe regex_traits.

Algumas funções usam uma sequência de operando que define uma expressão regular. Você pode especificar uma sequência de operando de várias maneiras:

ptr: uma sequência terminada em nulo (como uma cadeia de caracteres C, para Elem do tipo char) começando em ptr (que não pode ser um ponteiro nulo), em que o elemento terminador é o valor value_type() e não faz parte da sequência de operandos

ptr, count: uma sequência de count elementos começando em ptr (que não pode ser um ponteiro nulo)

str: a sequência especificada pelo objeto basic_string str

first, last: uma sequência de elementos delimitados pelos iteradores first e last, no intervalo [first, last)

right: o objeto basic_regex right

As funções membro acima também usam um argumento flags que especifica várias opções para a interpretação da expressão regular, além daquelas descritas pelo tipo RXtraits.

Membros

Construtores

Typedefs

Funções de membro

Operadores

Requisitos

Cabeçalho:<regex>

Namespace: std

Exemplo

// 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::atribuir

Atribui um valor ao objeto da expressão regular.

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);

Parâmetros

STtraits
Classe de características para uma fonte de cadeia de caracteres.

STalloc
Classe de alocador de uma fonte de cadeia de caracteres.

InIt
Tipo de iterador de entrada para uma fonte de intervalo.

direita
Fonte de regex a copiar.

ptr
Ponteiro para o início da sequência a copiar.

sinalizadores
Sinalizadores de opção de sintaxe a adicionar ao copiar.

len/TD>
Comprimento da sequência a copiar.

str
Cadeia de caracteres a copiar.

first
Início da sequência a copiar.

last
Fim da sequência a copiar.

IList
A initializer_list a ser copiada.

Comentários

As funções membro substituem, cada uma, a expressão regular mantida por *this pela expressão regular descrita pela sequência de operando, então retornam *this.

basic_regex::basic_regex

Construa o objeto de expressão regular.

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);

Parâmetros

STtraits
Classe de características para uma fonte de cadeia de caracteres.

STalloc
Classe de alocador de uma fonte de cadeia de caracteres.

InIt
Tipo de iterador de entrada para uma fonte de intervalo.

direita
Fonte de regex a copiar.

ptr
Ponteiro para o início da sequência a copiar.

sinalizadores
Sinalizadores de opção de sintaxe a adicionar ao copiar.

len/TD>
Comprimento da sequência a copiar.

str
Cadeia de caracteres a copiar.

first
Início da sequência a copiar.

last
Fim da sequência a copiar.

IList
A initializer_list a ser copiada.

Comentários

Todos os construtores armazenam um objeto construído por padrão do tipo RXtraits.

O primeiro construtor constrói um objeto basic_regex vazio. Os outros construtores constroem um objeto basic_regex que contém a expressão regular descrita pela sequência de operando.

Um objeto basic_regex vazio não corresponde a nenhuma sequência de caracteres quando passado para a regex_match, regex_search ou regex_replace.

basic_regex::flag_type

O tipo de sinalizadores de opção de sintaxe.

typedef regex_constants::syntax_option_type flag_type;

Comentários

O tipo é sinônimo de regex_constants::syntax_option_type.

basic_regex::flags

Retorna os sinalizadores de opção de sintaxe.

flag_type flags() const;

Comentários

A função membro retorna o valor do argumento flag_type passado para a chamada mais recente para uma das funções membro basic_regex::assign ou, se nenhuma chamada assim tiver sido feita, o valor passado para o construtor.

basic_regex::getloc

Retorna o objeto de localidade armazenado.

locale_type getloc() const;

Comentários

A função membro retorna traits.regex_traits::getloc().

basic_regex::imbuir

Altera o objeto de localidade armazenado.

locale_type imbue(locale_type loc);

Parâmetros

loc
O objeto de localidade a ser armazenado.

Comentários

A função de membro esvazia *this e retorna traits.regex_traits::imbue(loc).

basic_regex::locale_type

O tipo do objeto de localidade armazenado.

typedef typename RXtraits::locale_type locale_type;

Comentários

O tipo é um sinônimo de regex_traits::locale_type.

basic_regex::mark_count

Retorna o número de subexpressões correspondente.

unsigned mark_count() const;

Comentários

A função membro retorna o número de grupos de captura na expressão regular.

basic_regex::operador=

Atribui um valor ao objeto da expressão regular.

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);

Parâmetros

STtraits
Classe de características para uma fonte de cadeia de caracteres.

STalloc
Classe de alocador de uma fonte de cadeia de caracteres.

direita
Fonte de regex a copiar.

str
Cadeia de caracteres a copiar.

Comentários

Os operadores substituem, cada um, a expressão regular mantida por *this pela expressão regular descrita pela sequência de operando, então retornam *this.

basic_regex::swap

Troca dois objetos de expressão regular.

void swap(basic_regex& right) throw();

Parâmetros

direita
O objeto de expressão regular com o qual trocar.

Comentários

A função membro troca as expressões regulares entre *this e right. Ela faz isso em um horário constante e não gera exceções.

basic_regex::value_type

O tipo de elemento.

typedef Elem value_type;

Comentários

O tipo é um sinônimo do parâmetro de modelo Elem.

Confira também

<regex>
regex_match
regex_search
regex_replace
regex
wregex
Classe regex_traits