std::regex_match

Definido en el archivo de encabezado `<regex>`
`template< class BidirIt, class Alloc, class CharT, class Traits > bool regex_match( 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_match( 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_match( 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 STraits, class SAlloc, class Alloc, class CharT, class Traits > bool regex_match( 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 );	(4)	(desde C++11)
`template< class CharT, class Traits > bool regex_match( 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_match( 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_match( 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 la expresión regular e coincide con la secuencia completa de caracteres de destino, que puede especificarse como std::string, una cadena estilo C, o un par de iteradores.

1) Determina si hay una coincidencia entre la expresión regular e y toda la secuencia de caracteres de destino [first,last), teniendo en cuenta el efecto de flags. Al determinar si hay una coincidencia, solo se consideran las coincidencias potenciales que coinciden con la secuencia completa de caracteres. Los resultados de la coincidencia se devuelven en m.

2) Se comporta como (1) anteriormente, omitiendo los resultados de la coincidencia.

3) Devuelve std::regex_match(str, str + std::char_traits<charT>::length(str), m, e, flags).

4) Devuelve std::regex_match(s.begin(), s.end(), m, e, flags).

5) Devuelve std::regex_match(str, str + std::char_traits<charT>::length(str), e, flags).

6) Devuelve std::regex_match(s.begin(), s.end(), e, flags).

7) Se prohíbe que la sobrecarga (4) acepte cadenas temporales, de lo contrario esta función rellena match_results m con iteradores de cadena que se vuelven inválidos inmediatamente.

Ten en cuenta que regex_match solo hará coincidir correctamente una expresión regular con una secuencia de caracteres completa, mientras que std::regex_search coincidirá correctamente con subsecuencias.

Parámetros

first, last	-	El rango de caracteres de destino al que aplicar la expresión regular, dado como iteradores.
m	-	Los resultados de la coincidencia.
str	-	La cadena de destino, dada como una cadena estilo C terminada en nulo.
s	-	La cadena de destino, dada como un std::basic_string.
e	-	La expresión regular.
flags	-	Indicadores utilizados para determinar cómo se realizará la coincidencia.
Requisitos de tipo
- `BidirIt` debe satisfacer los requisitos de BidirectionalIterator.

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`	`first`
`m.prefix().matched`	`false` (el prefijo de coincidencia está vacío)
`m.suffix().first`	`last`
`m.suffix().second`	`last`
`m.suffix().matched`	`false` (el sufijo de coincidencia está vacío)
`m[0].first`	`first`
`m[0].second`	`last`
`m[0].matched`	`true` (se ha coincidido toda la secuencia)
`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 subexpresión marcada `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

Debido a que regex_match solo considera coincidencias completas, la misma expresión regular puede dar diferentes coincidencias entre regex_match y std::regex_search:

std::regex re("Get|GetValue");
std::cmatch m;
std::regex_search("GetValue", m, re);  // devuelve true, y m[0] contiene "Get"
std::regex_match ("GetValue", m, re);  // devuelve true, y m[0] contiene "GetValue"
std::regex_search("GetValues", m, re); // devuelve true, y m[0] contiene "Get"
std::regex_match ("GetValues", m, re); // devuelve false

Ejemplo

Ejecuta este código

#include <iostream>
#include <string>
#include <regex>

int main()
{
    // Coincidencia de una expresión regular simple
    const std::string fnames[] = {"foo.txt", "bar.txt", "baz.dat", "zoidberg"};
    const std::regex txt_regex("[a-z]+\\.txt");

    for (const auto &fname : fnames) {
        std::cout << fname << ": " << std::regex_match(fname, txt_regex) << '\n';
    }   

    // Extracción de una subcoincidencia
    const std::regex base_regex("([a-z]+)\\.txt");
    std::smatch base_match;

    for (const auto &fname : fnames) {
        if (std::regex_match(fname, base_match, base_regex)) {
            // la primera subcoincidencia es toda la cadena; la próxima
            // subcoincidencia es la primera expresión entre paréntesis
            if (base_match.size() == 2) {
                std::ssub_match base_sub_match = base_match[1];
                std::string base = base_sub_match.str();
                std::cout << fname << " tiene una base de " << base << '\n';
            }
        }
    }

    // Extracción de varias subcoincidencias
    const std::regex pieces_regex("([a-z]+)\\.([a-z]+)");
    std::smatch pieces_match;

    for (const auto &fname : fnames) {
        if (std::regex_match(fname, pieces_match, pieces_regex)) {
            std::cout << fname << '\n';
            for (size_t i = 0; i < pieces_match.size(); ++i) {
                std::ssub_match sub_match = pieces_match[i];
                std::string piece = sub_match.str();
                std::cout << "  subcoincidencia " << i << ": " << piece << '\n';
            }   
        }   
    }   
}

Salida:

foo.txt: 1
bar.txt: 1
baz.dat: 0
zoidberg: 0
foo.txt tiene una base de foo
bar.txt has a base of bar
foo.txt
  subcoincidencia 0: foo.txt
  subcoincidencia 1: foo
  subcoincidencia 2: txt
bar.txt
  subcoincidencia 0: bar.txt
  subcoincidencia 1: bar
  subcoincidencia 2: txt
baz.dat
  subcoincidencia 0: baz.dat
  subcoincidencia 1: baz
  subcoincidencia 2: dat

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_search (C++11)	Intenta coincidir una expresión regular con cualquier parte de una 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