Namespaces
Variants

std:: regex_search

From cppreference.net
C++
Text processing library
Regular expressions library
Classes
(C++11)
(C++11)
(C++11)
Algorithms
(C++11)
regex_search
(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)
Definido en el 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 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 ) ;
(2) (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 ) ;
(3) (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 ) ;
(4) (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 ) ;
(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 ) = eliminada ;
(7) (desde C++11)

Determina si hay una coincidencia entre la expresión regular e y alguna subsecuencia en la secuencia de caracteres objetivo. El resultado detallado de la coincidencia se almacena en m (si está presente).

1,2) La secuencia de caracteres objetivo está representada por el rango [ first , last ) .

Si BidirIt no satisface los requisitos de LegacyBidirectionalIterator , el comportamiento es indefinido.

(hasta C++23)

Si BidirIt no modela bidirectional_iterator , el comportamiento es indefinido.

(desde C++23)
3,4) La secuencia de caracteres objetivo está representada por el rango [ str , str + std:: char_traits < CharT > :: length ( str ) ) .
5,6) La secuencia de caracteres objetivo está representada por la cadena s .
7) La secuencia de caracteres objetivo no puede ser representada por un std::string rvalue.

Si una coincidencia no existe, las siguientes expresiones que involucran m (si existe) deben producir los valores especificados:

Expresión Valor
m. ready ( ) true
m. size ( ) ​ 0 ​
m. empty ( ) true

Si existe una coincidencia, dado cualquier entero en ( ​ 0 , m. size ( ) ) como n , las siguientes expresiones que involucran m deben producir los valores especificados para cada sobrecarga listada a continuación:

Expresión Valor
Sobrecarga (1) Sobrecarga (3) Sobrecarga (5)
m. ready ( ) true
m. size ( ) 1 + e. mark_count ( )
m. empty ( ) false
m. prefix ( ) . first first str s. begin ( )
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 std:: char_traits < CharT > ::
length ( str ) + str 		s. end ( )
m. suffix ( ) . matched m. suffix ( ) . first ! = m. suffix ( ) . second
m [0] . first el inicio de la secuencia que coincidió e
m [0] . second el final de la secuencia que coincidió e
m [0] . matched true
m [n] . first
  • last si la subexpresión marcada n no participó en la coincidencia
  • el inicio de la secuencia que coincide con la subexpresión n en caso contrario
m [n] . second
  • last si la subexpresión marcada n no participó en la coincidencia
  • el final de la secuencia en caso contrario que coincide con la subexpresión n en otro caso
m [n] . matched

Contenidos

Parámetros

first, last - el rango de caracteres objetivo
str - la cadena estilo C terminada en nulo objetivo
s - el objetivo std::basic_string
m - los resultados de coincidencia
e - la expresión regular
flags - banderas utilizadas para determinar cómo se realizará la coincidencia

Valor de retorno

Devuelve true si existe una coincidencia, false en caso contrario.

Notas

Para examinar todas las coincidencias dentro de la secuencia objetivo, std::regex_search puede llamarse en un bucle, reiniciando cada vez desde m [ 0 ] . second de la llamada anterior. std::regex_iterator ofrece una interfaz sencilla para esta iteración.

Ejemplo

Ejecutar este código 
#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
int main()
{
    std::string lines[] = {"Roses are #ff0000",
                           "violets are #0000ff",
                           "all of my base are belong to you"};
    std::regex color_regex("#([a-f0-9]{2})"
                            "([a-f0-9]{2})"
                            "([a-f0-9]{2})");
    // coincidencia simple
    for (const auto& line : lines)
        std::cout << line << ": " << std::boolalpha
                  << std::regex_search(line, color_regex) << '\n';
    std::cout << '\n';
    // mostrar contenido de subexpresiones marcadas dentro de cada coincidencia
    std::smatch color_match;
    for (const auto& line : lines)
        if (std::regex_search(line, color_match, color_regex))
        {
            std::cout << "coincidencias para '" << line << "'\n";
            std::cout << "Prefijo: '" << color_match.prefix() << "'\n";
            for (std::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 (ver también std::regex_iterator)
    std::string log(R"(
        Speed:	366
        Mass:	35
        Speed:	378
        Mass:	32
        Speed:	400
	Mass:	30)");
    std::regex r(R"(Speed:\t\d*)");
    for (std::smatch sm; regex_search(log, sm, r);)
    {
        std::cout << sm.str() << '\n';
        log = sm.suffix();
    }
    // demostración con cadenas estilo C
    std::cmatch cm;
    if (std::regex_search("this is a test", cm, std::regex("test"))) 
        std::cout << "\nEncontrado " << cm[0] << " en posición "
                  << cm.prefix().length() << '\n';
}

Salida: 

Roses are #ff0000: true
violets are #0000ff: true
all of my base are belong to you: false
coincidencias para 'Roses are #ff0000'
Prefijo: 'Roses are '
0: #ff0000
1: ff
2: 00
3: 00
Sufijo: ''
coincidencias para 'violets are #0000ff'
Prefijo: 'violets are '
0: #0000ff
1: 00
2: 00
3: ff
Sufijo: ''
Speed:	366
Speed:	378
Speed:	400
Encontrado test en posición 10

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2205 C++11 n podría ser cero en la postcondición solo puede ser positivo
LWG 2329 C++11 la sobrecarga (5) aceptaba valores r de basic_string ,
lo que podría resultar en iteradores colgantes 		rechazada mediante sobrecarga eliminada (7)

Véase también

(C++11)
objeto de expresión regular
(plantilla de clase)
(C++11)
identifica una coincidencia de expresión regular, incluyendo todas las coincidencias de subexpresiones
(plantilla de clase)
(C++11)
intenta hacer coincidir una expresión regular con una secuencia completa de caracteres
(plantilla de función)