Espacios de nombres
Variantes
Acciones

std::regex_search

De cppreference.com
< cpp‎ | regex
Definido en el archivo de encabezado <regex>
template< class BidirIt,

          class Alloc, class CharT, class Traits >
bool regex_search( BidirIt first, BidirIt last,
                   std::match_results<BidirIt,Alloc>& m,
                   const std::basic_regex<CharT,Traits>& e,
                   std::regex_constants::match_flag_type flags =

                       std::regex_constants::match_default );
(1) (desde C++11)
template< class CharT, class Alloc, class Traits >

bool regex_search( const CharT* str,
                   std::match_results<const CharT*,Alloc>& m,
                   const std::basic_regex<CharT,Traits>& e,
                   std::regex_constants::match_flag_type flags =

                       std::regex_constants::match_default );
(2) (desde C++11)
template< class STraits, class SAlloc,

          class Alloc, class CharT, class Traits >
bool regex_search( const std::basic_string<CharT,STraits,SAlloc>& s,
                   std::match_results<
                       typename std::basic_string<CharT,STraits,SAlloc>::const_iterator,
                       Alloc
                   >& m,
                   const std::basic_regex<CharT, Traits>& e,
                   std::regex_constants::match_flag_type flags =

                       std::regex_constants::match_default );
(3) (desde C++11)
template< class BidirIt,

          class CharT, class Traits >
bool regex_search( BidirIt first, BidirIt last,
                   const std::basic_regex<CharT,Traits>& e,
                   std::regex_constants::match_flag_type flags =

                       std::regex_constants::match_default );
(4) (desde C++11)
template< class CharT, class Traits >

bool regex_search( const CharT* str,
                   const std::basic_regex<CharT,Traits>& e,
                   std::regex_constants::match_flag_type flags =

                       std::regex_constants::match_default );
(5) (desde C++11)
template< class STraits, class SAlloc,

          class CharT, class Traits >
bool regex_search( const std::basic_string<CharT,STraits,SAlloc>& s,
                   const std::basic_regex<CharT,Traits>& e,
                   std::regex_constants::match_flag_type flags =

                       std::regex_constants::match_default );
(6) (desde C++11)
template< class STraits, class SAlloc,

          class Alloc, class CharT, class Traits >
bool regex_search( const std::basic_string<CharT,STraits,SAlloc>&&,
                   std::match_results<
                       typename std::basic_string<CharT,STraits,SAlloc>::const_iterator,
                       Alloc
                   >&,
                   const std::basic_regex<CharT, Traits>&,
                   std::regex_constants::match_flag_type flags =

                       std::regex_constants::match_default ) = delete;
(7) (desde C++11)

Determina si hay una coincidencia entre la expresión regular e y alguna subsecuencia en la secuencia de caracteres de destino.

1) Analiza el rango genérico [first,last). Los resultados de la coincidencia se devuelven en m.
2) Analiza una cadena terminada en nulo a la que apunta str. Los resultados de la coincidencia se devuelven en m.
3) Analiza una cadena s. Los resultados de la coincidencia se devuelven en m.
4-6) Equivalente (1-3), solo que omite los resultados de la coincidencia.
7) Se prohíbe que la sobrecarga (3) acepte cadenas temporales, de lo contrario esta función rellena match_results m con iteradores de cadena que se vuelven inválidos inmediatamente.

regex_search hará coincidir correctamente cualquier subsecuencia de una secuencia dada, mientras que std::regex_match solo devolverá true si la expresión regular hace coincidir la secuencia completa.

Contenido

[editar] Parámetros

first, last - Un rango que identifica la secuencia de caracteres de destino.
str - Un puntero a una secuencia de caracteres de destino terminada en nulo.
s - Una cadena que identifica la secuencia de caracteres de destino.
e - La expresión regular std::regex que deberá ser aplicada a la secuencia de caracteres de destino.
m - Los resultados de la coincidencia.
flags - Los indicadores de tipo std::regex_constants::match_flag_type que gobiernan el comportamiento de la búsqueda.
Requisitos de tipo
-
BidirIt debe satisfacer los requisitos de BidirectionalIterator.
-
Alloc debe satisfacer los requisitos de Allocator.

[editar] Valor de retorno

Devuelve true si existe una coincidencia, false de lo contrario. En cualquier caso, el objeto m se actualiza de la siguiente manera:

Si la coincidencia no existe:

m.ready() == true
m.empty() == true
m.size() == 0

Si la coincidencia existe:

m.ready() true
m.empty() false
m.size() El número de subexpresiones marcadas más 1, es decir, 1+e.mark_count().
m.prefix().first first
m.prefix().second m[0].first
m.prefix().matched m.prefix().first != m.prefix().second
m.suffix().first m[0].second
m.suffix().second last
m.suffix().matched m.suffix().first != m.suffix().second
m[0].first El principio de la secuencia de coincidencias.
m[0].second El fin de la secuencia de coincidencias.
m[0].matched true
m[n].first El principio de la secuencia que coincidió con la subexpresión marcada n, o last si la subexpresión no participó en la coincidencia.
m[n].second El final de la secuencia que coincidió con la marked sub-expression n, o last si la subexpresión no participó en la coincidencia.
m[n].matched true si la subexpresión n participó en la coincidencia, false de lo contrario.

[editar] Notas

Para poder examinar todas las coincidencias dentro de la secuencia de destino, std::regex_search puede llamarse en un bucle, volviendo a empezar cada vez de m[0].second de la llamada anterior. std::regex_iterator ofrece una interfaz fácil para esta iteración.

[editar] Ejemplo

#include <iostream>
#include <string>
#include <regex>
 
int main()
{
    std::string lineas[] = {"Rosas son #ff0000",
                           "violetas son #0000ff",
                           "todo lo que soy te pertenece"};
 
    std::regex color_regex("#([a-f0-9]{2})"
                            "([a-f0-9]{2})"
                            "([a-f0-9]{2})");
 
    // coincidencia simple, busca coincidencias de colores en líneas
    for (const auto &linea : lineas) {
        std::cout << linea << ": " << std::boolalpha
                  << std::regex_search(linea, color_regex) << '\n';
    }   
    std::cout << '\n';
 
    // mostrar el contenido de las subexpresiones marcadas dentro de cada coincidencia
    std::smatch color_match;
    for (const auto& linea : lineas) {
        if(std::regex_search(linea, color_match, color_regex)) {
            std::cout << "coincidencias para '" << linea << "'\n";
            std::cout << "Prefijo: '" << color_match.prefix() << "'\n";
            for (size_t i = 0; i < color_match.size(); ++i) 
                std::cout << i << ": " << color_match[i] << '\n';
            std::cout << "Sufijo: '" << color_match.suffix() << "\'\n\n";
        }
    }
 
    // búsqueda repetida (véase también std::regex_iterator)
    std::string log(R"(
        Velocidad:	366
        Masa:	35
        Velocidad:	378
        Masa:	32
        Velocidad:	400
	Masa:	30)");
    std::regex r(R"(Velocidad:\t\d*)");
    std::smatch sm;
    while(regex_search(log, sm, r))
    {
        std::cout << sm.str() << '\n';
        log = sm.suffix();
    }
 
    // Demo usando cadena estilo C
    std::cmatch cm;
    if(std::regex_search("esto es una prueba", cm, std::regex("prueba"))) 
        std::cout << "\nSe encontró " << cm[0] << " en la posición " << cm.prefix().length();
}

Salida:

Rosas son #ff0000: true
violetas son #0000ff: true
todo lo que soy te pertenece: false
 
coincidencias para 'Rosas son #ff0000'
Prefijo: 'Rosas son '
0: #ff0000
1: ff
2: 00
3: 00
Sufijo: ''
 
coincidencias para 'violetas son #0000ff'
Prefijo: 'violetas son '
0: #0000ff
1: 00
2: 00
3: ff
Sufijo: ''
 
Velocidad:	366
Velocidad:	378
Velocidad:	400
 
Se encontró prueba en la posición 12

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID Aplicado a Comportamiento según lo publicado Comportamiento correcto
LWG 2329 C++11 Se aceptaban r-valores basic_string, que probablemente daría lugar a iteradores pendientes. Se rechazaron mediante una sobrecarga eliminada.

[editar] Véase también

Objeto de expresiones regulares.
(plantilla de clase) [editar]
Identifica una coincidencia de expresión regular, incluyendo todas las coincidencias de subexpresión.
(plantilla de clase) [editar]
Intenta coincidir una expresión regular para toda la secuencia de caracteres.
(plantilla de función) [editar]