Namespaces
Variants

std:: sub_match

From cppreference.net
C++
Text processing library
Regular expressions library
Classes
(C++11)
sub_match
(C++11)
(C++11)
Algorithms
(C++11)
(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)
std::sub_match
Definido en el encabezado <regex>
template < class BidirIt >
class sub_match ;
(desde C++11)

La plantilla de clase std::sub_match es utilizada por el motor de expresiones regulares para denotar secuencias de caracteres coincidentes con subexpresiones marcadas. Una coincidencia es un par [ begin , end ) dentro del rango objetivo que coincide con la expresión regular, pero con funciones observadoras adicionales para mejorar la claridad del código.

Solo el constructor por defecto es públicamente accesible. Las instancias de std::sub_match normalmente se construyen y se llenan como parte de un contenedor std::match_results durante el procesamiento de uno de los algoritmos de expresiones regulares.

Las funciones miembro retornan valores predeterminados definidos a menos que el matched miembro sea true .

std::sub_match hereda de std:: pair < BidirIt, BidirIt > , aunque no puede tratarse como un objeto std::pair porque funciones miembro como la asignación no funcionarán como se espera.

Contenidos

Requisitos de tipo

-
BidirIt debe cumplir con los requisitos de LegacyBidirectionalIterator .

Especializaciones

Se proporcionan varias especializaciones para tipos comunes de secuencias de caracteres:

Definido en el encabezado <regex>
Tipo Definición
std::csub_match std :: sub_match < const char * >
std::wcsub_match std :: sub_match < const wchar_t * >
std::ssub_match std :: sub_match < std :: string :: const_iterator >
std::wssub_match std :: sub_match < std :: wstring :: const_iterator >

Tipos anidados

Tipo Definición
iterator BidirIt
value_type std:: iterator_traits < BidirIt > :: value_type
difference_type std:: iterator_traits < BidirIt > :: difference_type
string_type std:: basic_string < value_type >

Miembros de datos

Miembro Descripción
bool matched
si esta coincidencia fue exitosa
(objeto miembro público)

Heredado de std:: pair

BidirIt first
inicio de la secuencia de coincidencia
(objeto miembro público)
BidirIt second
fin de la secuencia de coincidencia (posición posterior al último elemento)
(objeto miembro público)

Funciones miembro

construye el objeto de coincidencia
(función miembro pública)
Observadores
retorna la longitud de la coincidencia (si existe)
(función miembro pública)
convierte al tipo de cadena subyacente
(función miembro pública)
compara la subsecuencia coincidente (si existe)
(función miembro pública)
Modificadores
intercambia los contenidos
(función miembro pública)

Funciones no miembro

(eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (C++20)
compara un sub_match con otro sub_match , una cadena, o un carácter
(plantilla de función)
imprime la subsecuencia de caracteres coincidentes
(plantilla de función)

Ejemplo

Ejecutar este código 
#include <cassert>
#include <iostream>
#include <regex>
#include <string>
int main()
{
    std::string sentence{"Friday the thirteenth."};
    const std::regex re{"([A-z]+) ([a-z]+) ([a-z]+)"};
    std::smatch words;
    std::regex_search(sentence, words, re);
    std::cout << std::boolalpha;
    for (const auto& m : words)
    {
        assert(m.matched);
        std::cout << "m: [" << m << "], m.length(): " << m.length() << ", "
                     "*m.first: '" << *m.first << "', "
                     "*m.second: '" << *m.second << "'\n";
    }
}

Salida: 

m: [Friday the thirteenth], m.length(): 21, *m.first: 'F', *m.second: '.'
m: [Friday], m.length(): 6, *m.first: 'F', *m.second: ' '
m: [the], m.length(): 3, *m.first: 't', *m.second: ' '
m: [thirteenth], m.length(): 10, *m.first: 't', *m.second: '.'

Véase también

(C++11)
itera a través de las subexpresiones especificadas dentro de todas las coincidencias de regex en una cadena dada o a través de subcadenas no coincidentes
(plantilla de clase)