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_regexright
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
| Miembro | 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)
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente las Cuestiones de GitHub como mecanismo de retroalimentación para el contenido y lo sustituiremos por un nuevo sistema de retroalimentación. Para más información, consulta: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de