Classe sub_match

Descreve uma subcorrespondência.

Sintaxe

template <class BidIt>
class sub_match
    : public std::pair<BidIt, BidIt>

Parâmetros

BidIt
O tipo de iterador para subcorrespondências.

Comentários

O modelo de classe descreve um objeto que designa uma sequência de caracteres que corresponde a um grupo de captura em uma chamada para regex_match ou regex_search. Objetos do tipo Classe match_results contêm uma matriz desses objetos, uma para cada grupo de captura na expressão regular que foi usada na pesquisa.

Se o grupo de captura não tiver correspondência no membro de dados do objeto, matched será falso e os dois iteradores first e second (herdados de std::pair base) serão iguais. Se o grupo de captura for correspondido, matched será verdadeiro, o iterador first apontará para o primeiro caractere na sequência de destino que corresponde ao grupo de captura e o iterador second apontará para uma posição após o último caractere na sequência de destino que corresponde ao grupo de captura. Para uma correspondência de comprimento zero, o membro matched será verdadeiro, os dois iteradores serão iguais e ambos apontarão para a posição da correspondência.

Uma correspondência de comprimento zero pode ocorrer quando um grupo de captura consiste exclusivamente em uma declaração ou em uma repetição que permite repetições de zero. Por exemplo:

“^” corresponde à sequência de destino “a”; o objeto sub_match correspondente ao grupo de captura 0 contém iteradores que apontam para o primeiro caractere na sequência.

“b(a*)b” corresponde à sequência de destino “bb”; o objeto sub_match correspondente ao grupo de captura 1 contém iteradores que apontam para o segundo caractere na sequência.

Typedefs

Funções de membro

Operadores

Exemplo

// std__regex__sub_match.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>

int main()
    {
    std::regex rx("c(a*)|(b)");
    std::cmatch mr;

    std::regex_search("xcaaay", mr, rx);

    std::csub_match sub = mr[1];
    std::cout << "matched == " << std::boolalpha
        << sub.matched << std::endl;
    std::cout << "length == " << sub.length() << std::endl;

    std::csub_match::difference_type dif = std::distance(sub.first, sub.second);
    std::cout << "difference == " << dif << std::endl;

    std::csub_match::iterator first = sub.first;
    std::csub_match::iterator last = sub.second;
    std::cout << "range == " << std::string(first, last)
        << std::endl;
    std::cout << "string == " << sub << std::endl;

    std::csub_match::value_type const *ptr = "aab";
    std::cout << "compare(\"aab\") == "
        << sub.compare(ptr) << std::endl;
    std::cout << "compare(string) == "
        << sub.compare(std::string("AAA")) << std::endl;
    std::cout << "compare(sub) == "
        << sub.compare(sub) << std::endl;

    return (0);
    }

matched == true
length == 3
difference == 3
range == aaa
string == aaa
compare("aab") == -1
compare(string) == 1
compare(sub) == 0

Requisitos

Cabeçalho:<regex>

Namespace: std

sub_match::comparar

Compare a subcorrespondência com uma sequência.

int compare(const sub_match& right) const;
int compare(const basic_string<value_type>& str) const;
int compare(const value_type *ptr) const;

Parâmetros

direita
A subcorrespondência com a qual comparar.

str
A cadeia de caracteres a ser comparada com .

ptr
A sequência com terminação nula com a qual comparar.

Comentários

A primeira função membro compara a sequência correspondente [first, second) à sequência correspondente [right.first, right.second). A segunda função membro compara a sequência correspondente [first, second) à sequência de caracteres [right.begin(), right.end()). A terceira função membro compara a sequência correspondente [first, second) à sequência de caracteres [right, right + std::char_traits<value_type>::length(right)).

Cada função retorna:

um valor negativo se o primeiro valor diferente na sequência correspondente for comparado como menor que o elemento correspondente na sequência de operando (conforme determinado por std::char_traits<value_type>::compare) ou se os dois tiverem um prefixo comum, mas a sequência de destino for mais longa

zero se os dois forem comparados como iguais elemento por elemento e tiverem o mesmo tamanho

caso contrário, um valor positivo

sub_match::d tipo_de_ifferência

O tipo de uma diferença de iterador.

typedef typename iterator_traits<BidIt>::difference_type difference_type;

Comentários

O typedef é um sinônimo de iterator_traits<BidIt>::difference_type.

sub_match::iterador

O tipo de um iterador.

typedef BidIt iterator;

Comentários

O typedef é um sinônimo do argumento de tipo de modelo Bidit.

sub_match::comprimento

Retorna o tamanho de uma subcorrespondência.

difference_type length() const;

Comentários

A função membro retorna o tamanho da sequência correspondente ou zero se não houve nenhuma sequência correspondente.

sub_match::combinado

Indica se a correspondência teve êxito.

bool matched;

Comentários

O membro conterá true somente se o grupo de captura associado a *this fazia parte da correspondência da expressão regular.

sub_match::operator basic_string<value_type>

Molda a subcorrespondência em uma cadeia de caracteres.

operator basic_string<value_type>() const;

Comentários

O operador de membro retorna str().

sub_match::str

Converte a subcorrespondência em uma cadeia de caracteres.

basic_string<value_type> str() const;

Comentários

A função membro retorna basic_string<value_type>(first, second).

sub_match::value_type

O tipo de um elemento.

typedef typename iterator_traits<BidIt>::value_type value_type;

Comentários

O typedef é um sinônimo de iterator_traits<BidIt>::value_type.

Confira também

<regex>
sub_match