Namespaces
Variants

std::basic_regex<CharT,Traits>:: basic_regex

From cppreference.net
C++
Text processing library
Regular expressions library
Classes
(C++11)
(C++11)
(C++11)
Algorithms
(C++11)
(C++11)
(C++11)
Iterators
(C++11)
(C++11)
Exceptions
(C++11)
Traits
(C++11)
Constants
(C++11)
(C++11)
(C++11)
Regex Grammar
(C++11)
std::basic_regex
basic_regex ( ) ;
(1) (desde C++11)
explicit basic_regex ( const CharT * s,
flag_type f = std:: regex_constants :: ECMAScript ) ;
(2) (desde C++11)
basic_regex ( const CharT * s, std:: size_t count,
flag_type f = std:: regex_constants :: ECMAScript ) ;
(3) (desde C++11)
basic_regex ( const basic_regex & other ) ;
(4) (desde C++11)
basic_regex ( basic_regex && other ) noexcept ;
(5) (desde C++11)
template < class ST, class SA >

explicit basic_regex ( const std:: basic_string < CharT,ST,SA > & str,

flag_type f = std:: regex_constants :: ECMAScript ) ;
(6) (desde C++11)
template < class ForwardIt >

basic_regex ( ForwardIt first, ForwardIt last,

flag_type f = std:: regex_constants :: ECMAScript ) ;
(7) (desde C++11)
basic_regex ( std:: initializer_list < CharT > init,
flag_type f = std:: regex_constants :: ECMAScript ) ;
(8) (desde C++11)

Construye una nueva expresión regular a partir de una secuencia de caracteres interpretada según los indicadores f .

1) Constructor por defecto. Construye una expresión regular vacía que no coincidirá con nada.
2) Construye una expresión regular a partir de una cadena terminada en nulo s .
3) Construye una expresión regular a partir de una secuencia de count caracteres, apuntada por s .
4) Constructor de copia. Construye una regex copiando other .
5) Constructor de movimiento. Construye una expresión regular con el contenido de other utilizando semánticas de movimiento.
6) Construye una expresión regular a partir de una cadena str .
7) Constructor de rango. Construye la cadena con los contenidos del rango [ first , last ) .
8) Constructor de lista de inicialización. Construye la cadena con el contenido de la lista de inicialización init .

Parámetros

s - puntero a una cadena terminada en nulo
count - longitud de una secuencia de caracteres utilizada para inicializar la expresión regular
first, last - rango de una secuencia de caracteres utilizada para inicializar la expresión regular
str - una basic_string utilizada como fuente para inicializar la expresión regular
other - otra expresión regular utilizada como fuente para inicializar la expresión regular
init - lista de inicializadores utilizada para inicializar la expresión regular
f - banderas utilizadas para guiar la interpretación de la secuencia de caracteres como expresión regular
Requisitos de tipo
-
ForwardIt debe cumplir con los requisitos de LegacyForwardIterator .

Excepciones

1) Puede lanzar excepciones definidas por la implementación.
2,3) std::regex_error si la expresión regular proporcionada no es válida.
4) Puede lanzar excepciones definidas por la implementación.
6-8) std::regex_error si la expresión regular proporcionada no es válida.

Ejemplo

Ejecutar este código 
#include <iomanip>
#include <iostream>
#include <regex>
#include <string>
void match_and_print(const std::string& text, const std::regex& pattern)
{
    std::sregex_iterator it(text.begin(), text.end(), pattern), it_end;
    int count = 0;
    for (; it != it_end; ++it)
    {
        const std::smatch& match = *it;
        std::cout << ++count << ". " << std::quoted(match.str()) << '\n';
    }
    std::cout << (count ? "\n" : "no match found\n\n");
}
int main()
{
    const std::string text = "Hello, World! 12345";
    // Coincide con uno o más dígitos
    std::string pattern_text = "\\d+";
    std::cout << "dígitos (" << pattern_text << "):\n";
    auto pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Coincide con uno o más caracteres separados por espacio
    pattern_text = "[^\\s]+";
    std::cout << "palabras (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Coincide con uno o más caracteres alfabéticos
    pattern_text = "[a-zA-Z]+";
    std::cout << "palabras sin símbolos ni dígitos (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Coincide con un carácter que no es dígito ni alfabético
    pattern_text = "[^0-9A-Za-z]";
    std::cout << "símbolo (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Coincide con uno o más caracteres en minúscula
    pattern_text = "[a-z]+";
    std::cout << "minúsculas (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Coincide con uno o más caracteres en minúscula con el flag std::regex::icase
    pattern_text = "[a-z]+";
    std::cout << "minúsculas con flag de ignorar mayúsculas (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::icase);
    match_and_print(text, pattern);
    // Coincide con expresión regular POSIX básica
    pattern_text = "[[:digit:]]+";
    std::cout << "regex POSIX básico (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::basic);
    match_and_print(text, pattern);
    // Coincide con expresión regular POSIX extendida
    pattern_text = "[[:digit:]]+";
    std::cout << "regex POSIX extendido (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::extended);
    match_and_print(text, pattern);
}

Salida: 

dígitos (\d+):
1. "12345"
palabras ([^\s]+):
1. "Hello,"
2. "World!"
3. "12345"
palabras sin símbolos y dígitos ([a-zA-Z]+):
1. "Hello"
2. "World"
símbolo ([^0-9A-Za-z]):
1. ","
2. " "
3. "!"
4. " "
minúsculas ([a-z]+):
1. "ello"
2. "orld"
minúsculas con bandera de ignorar mayúsculas ([a-z]+):
1. "Hello"
2. "World"
expresión regular POSIX básica ([[:digit:]]+):
no se encontraron coincidencias
expresión regular POSIX extendida ([[:digit:]]+):
1. "12345"