std::regex_search

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.

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.

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.

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.

Ejemplo

Ejecuta este código

#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

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.

Véase también

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

Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

Clases
basic_regex (C++11)
sub_match (C++11)
match_results (C++11)
Algoritmos
regex_match (C++11)
regex_search (C++11)
regex_replace (C++11)
Iteradores
regex_iterator (C++11)
regex_token_iterator (C++11)
Excepciones
regex_error (C++11)
Rasgos
regex_traits (C++11)
Constantes
syntax_option_type (C++11)
match_flag_type (C++11)
error_type (C++11)
Gramática de las expresiones regulares
ECMAScript-262 modificado (C++11)

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones