basic_regex (Clase)

Contiene una expresión regular.

Sintaxis

template <class Elem, class RXtraits>
class basic_regex

Parámetros

Elem
Tipo de los elementos que debe coincidir.

RXtraits
Clase Traits para los elementos.

Comentarios

La plantilla de clase describe un objeto que contiene una expresión regular. Los objetos de esta plantilla de clase pueden pasarse a las funciones de plantilla regex_match, regex_search y regex_replace. También pasa los argumentos de cadena de texto adecuados para buscar texto que coincida con la expresión regular. Hay dos especializaciones de esta plantilla de clase, con las definiciones de tipo regex para los elementos de tipo char y wregex para los elementos de tipo wchar_t.

El argumento de plantilla RXtraits describe las distintas propiedades importantes de la sintaxis de las expresiones regulares que la plantilla de clase admite. Una clase que especifica estos rasgos de expresiones regulares debe tener la misma interfaz externa que un objeto de tipo regex_traits (Clase).

Algunas funciones toman una secuencia de operandos que define una expresión regular. Puede especificar dicha secuencia de operandos de varias maneras:

ptr: secuencia terminada en null, (como una cadena de C, para Elem de tipo char) que comience en ptr (que no puede ser un puntero null), donde el elemento que finaliza es el valor value_type() y no forma parte de la secuencia de operandos

ptr, count: una secuencia de elementos count que comienza en ptr (que no puede ser un puntero null)

str: la secuencia especificada por el objeto basic_stringstr

first, last: una secuencia de elementos delimitada por los iteradores first y last, en el intervalo [first, last)

right: el objeto basic_regex right

Las funciones anteriores miembro también toman un argumento flags que especifica las distintas opciones para la interpretación de la expresión regular además de las descritas por el tipo RXtraits.

Miembros

Member	Valor predeterminado
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 extended	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
rasgos de RXtraits privados

Constructores

Constructor	Descripción
basic_regex	Construye el objeto de expresión regular.

Typedefs

Nombre de tipo	Descripción
flag_type	El tipo de marcas de opción de sintaxis.
locale_type	El tipo de objeto de configuración regional almacenado.
value_type	El tipo de elemento.

Funciones miembro

Función de miembro	Descripción
assign	Asigna un valor al objeto de expresión regular.
flags	Devuelve marcas de opción de sintaxis.
getloc	Devuelve el objeto de configuración regional almacenado.
imbue	Modifica el objeto de configuración regional almacenado.
mark_count	Devuelve el número de subexpresiones coincidentes.
swap	Intercambia dos objetos de expresión regular.

Operadores

Operador	Descripción
operator=	Asigna un valor al objeto de expresión regular.

Requisitos

Encabezado:<regex>

Espacio de nombres: std

Ejemplo

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

Asigna un valor al objeto de expresión 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
Clase traits para un origen de cadena.

STalloc
Clase de asignador para un origen de cadena.

InIt
Tipo de iterador de entrada para un origen de intervalo.

right
Origen regex que se va a copiar.

ptr
Puntero al inicio de la secuencia que se va a copiar.

flags
Marcas de opción de sintaxis que se van a agregar al copiar.

len/TD>
Longitud de la secuencia que se va a copiar.

str
Cadena que se va a copiar.

first
Principio de la secuencia que se va a copiar.

last
Final de la secuencia que se va a copiar.

IList
initializer_list que se va a copiar.

Comentarios

Cada una de las funciones miembro reemplaza la expresión regular que contiene *this con la expresión regular descrita por la secuencia de operandos y después devuelve *this.

basic_regex::basic_regex

Construye el objeto de expresión 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
Clase traits para un origen de cadena.

STalloc
Clase de asignador para un origen de cadena.

InIt
Tipo de iterador de entrada para un origen de intervalo.

right
Origen regex que se va a copiar.

ptr
Puntero al inicio de la secuencia que se va a copiar.

flags
Marcas de opción de sintaxis que se van a agregar al copiar.

len/TD>
Longitud de la secuencia que se va a copiar.

str
Cadena que se va a copiar.

first
Principio de la secuencia que se va a copiar.

last
Final de la secuencia que se va a copiar.

IList
initializer_list que se va a copiar.

Comentarios

Todos los constructores almacenan un objeto construido de forma predeterminada de tipo RXtraits.

El primer constructor crea un objeto basic_regex vacío. Los otros constructores crean un objeto basic_regex que contiene la expresión regular descrita por la secuencia de operandos.

Un objeto basic_regex vacío no coincide con ninguna secuencia de caracteres cuando se pasa a regex_match, regex_search o regex_replace.

basic_regex::flag_type

El tipo de marcas de opción de sintaxis.

typedef regex_constants::syntax_option_type flag_type;

Comentarios

El tipo es sinónimo de regex_constants::syntax_option_type.

basic_regex::flags

Devuelve marcas de opción de sintaxis.

flag_type flags() const;

Comentarios

La función miembro devuelve el valor del argumento flag_type pasado a la llamada más reciente a una de las funciones miembro basic_regex::assign o, si no se hizo dicha llamada, el valor pasado al constructor.

basic_regex::getloc

Devuelve el objeto de configuración regional almacenado.

locale_type getloc() const;

Comentarios

La función miembro devuelve traits.regex_traits::getloc().

basic_regex::imbue

Modifica el objeto de configuración regional almacenado.

locale_type imbue(locale_type loc);

Parámetros

loc
El objeto de configuración regional que se va a almacenar.

Comentarios

La función miembro vacía *this y devuelve traits.regex_traits::imbue(loc).

basic_regex::locale_type

El tipo de objeto de configuración regional almacenado.

typedef typename RXtraits::locale_type locale_type;

Comentarios

El tipo es un sinónimo de regex_traits::locale_type.

basic_regex::mark_count

Devuelve el número de subexpresiones coincidentes.

unsigned mark_count() const;

Comentarios

La función miembro devuelve el número de grupos de capturas de la expresión regular.

basic_regex::operator=

Asigna un valor al objeto de expresión 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
Clase traits para un origen de cadena.

STalloc
Clase de asignador para un origen de cadena.

right
Origen regex que se va a copiar.

str
Cadena que se va a copiar.

Comentarios

Cada uno de los operandos reemplaza la expresión regular incluida en *this con la expresión regular descrita por la secuencia de operandos y después devuelve *this.

basic_regex::swap

Intercambia dos objetos de expresión regular.

void swap(basic_regex& right) throw();

Parámetros

right
El objeto de expresión regular con el que se intercambia.

Comentarios

La función miembro intercambia las expresiones regulares entre *this y right. Lo hace en tiempo constante y no inicia ninguna excepción.

basic_regex::value_type

El tipo de elemento.

typedef Elem value_type;

Comentarios

El tipo es un sinónimo del parámetro de plantilla Elem.

Consulte también

<regex>
regex_match
regex_search
regex_replace
regex
wregex
regex_traits (Clase)