std:: regex_match

From es.cppreference.net

Definido en el 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 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 ) ;	(4)	(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 ) ;	(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 ) = eliminar ;	(7)	(desde C++11)

Determina si la expresión regular e coincide con la secuencia completa 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 la 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 la coincidencia existe, 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
Expresión	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	first	str	s. begin ( )
m. `prefix` ( ) . matched	false ^[1]
m. `suffix` ( ) . first	last	std:: char_traits < CharT > :: length ( str ) + str	s. end ( )
m. `suffix` ( ) . second	last	std:: char_traits < CharT > :: length ( str ) + str	s. end ( )
m. `suffix` ( ) . matched	false ^[2]
m `[0]` . first	first	str	s. begin ( )
m `[0]` . second	last	std:: char_traits < CharT > :: length ( str ) + str	s. end ( )
m `[0]` . matched	true ^[3]
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	false si la subexpresión marcada n no participó en la coincidencia true en caso contrario

↑ El prefijo de coincidencia está vacío.
↑ El sufijo de coincidencia está vacío.
↑ La secuencia completa coincide.

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 toda la secuencia objetivo coincide con e , false en caso contrario.

Notas

Debido a que regex_match solo considera coincidencias completas, la misma expresión regular puede dar diferentes resultados 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

Ejecutar este código

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
int main()
{
    // Coincidencia simple de expresión regular
    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 la cadena completa; la siguiente
            // 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 (std::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 tiene una base de 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 que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

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 2273	C++11	no estaba claro si se consideraban coincidencias parciales	solo considera coincidencias completas
LWG 2329	C++11	la sobrecarga (5) aceptaba rvalues de `basic_string` , lo que podría resultar en iteradores colgantes	rechazada mediante sobrecarga eliminada (7)

Véase también

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

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

Classes
basic_regex (C++11)
sub_match (C++11)
match_results (C++11)
Algorithms
regex_match (C++11)
regex_search (C++11)
regex_replace (C++11)
Iterators
regex_iterator (C++11)
regex_token_iterator (C++11)
Exceptions
regex_error (C++11)
Traits
regex_traits (C++11)
Constants
syntax_option_type (C++11)
match_flag_type (C++11)
error_type (C++11)
Regex Grammar
Modified ECMAScript-262 (C++11)

es.cppreference.net

Namespaces

Variants