basic_regex Class

Encapsula una expresión regular.

template<class Elem,
    class RXtraits = regex_traits<Elem>,
    class basic_regex {
public:
    basic_regex();
    explicit basic_regex(const Elem *ptr,
        flag_type flags = ECMAScript);
    basic_regex(const Elem *ptr, size_type len,
        flag_type flags = ECMAScript);
    basic_regex(const basic_regex& right);
    template<class STtraits, class STalloc>
        explicit basic_regex(const basic_string<Elem, STtraits, STalloc>& str,
            flag_type flags = ECMAScript);
    template<class InIt>
        explicit basic_regex(InIt first, InIt last,
            flag_type flags = ECMAScript);

    basic_regex& operator=(const basic_regex& right);
    basic_regex& operator=(const Elem *ptr);
    template<class STtraits, class STalloc>
        basic_regex& operator=(const basic_string<Elem, STtraits, STalloc>& str);
    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);
    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);

    locale_type imbue(locale_type loc);
    locale_type getloc() const;
    void swap(basic_regex& other) throw();
    unsigned mark_count() const;
    flag_type flags() const;

    typedef Elem value_type;
    typedef regex_constants::syntax_option_type flag_type;
    typedef typename RXtraits::locale_type locale_type;
    static const flag_type icase = regex_constants::icase;
    static const flag_type nosubs = regex_constants::nosubs;
    static const flag_type optimize = regex_constants::optimize;
    static const flag_type collate = regex_constants::collate;
    static const flag_type ECMAScript = regex_constants::ECMAScript;
    static const flag_type basic = regex_constants::basic;
    static const flag_type extended = regex_constants::extended;
    static const flag_type awk = regex_constants::awk;
    static const flag_type grep = regex_constants::grep;
    static const flag_type egrep = regex_constants::egrep;
private:
    RXtraits traits;    // exposition only
    };

Parámetros

Elem
El tipo de elementos que se va a comparar.
RXtraits
Clase de los rasgos para elementos.

Comentarios

La clase de plantilla describe un objeto que contiene una expresión regular.Los objetos de este tipo de plantilla se pueden pasar a funciones regex_match Function, regex_search Function, y regex_replace Functionde plantilla, junto con argumentos adecuadas para la cadena de texto, para buscar texto que coincide con la expresión regular.La biblioteca TR1 proporciona dos especializaciones de esta clase de plantilla, con las definiciones de tipo regex Typedef para los elementos de chary, a wregex Typedef para los elementos de wchar_tescrito.

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

Algunas funciones toman una secuencia de operando que defina una expresión regular.Puede especificar este tipo de secuencia de operando varias maneras:

ptr -- un principio terminado en null de la secuencia (como cadena de C/C++., para Elem de charescribe) en ptr (que no deben ser punteros NULL), donde el valor value_type() y no forma parte el elemento que termina de operando

ptr, count -- una secuencia de elementos de count que comienzan en ptr (que no deben ser punteros NULL)

str -- la secuencia especificada por el objeto strde basic_string

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

right -- el objeto rightde basic_regex

Estas funciones 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 de RXtraits .