match_results, classe

Contient une séquence de sous-correspondances.

Syntaxe

template <class BidIt, class Alloc>
class match_results

Paramètres

BidIt
Type d'itérateur pour les sous-correspondances.

Alloc
Type d'un allocateur pour la gestion du stockage.

Notes

Le modèle de classe décrit un objet qui contrôle une séquence non modifiable d’éléments de type sub_match<BidIt> générés par une recherche d’expression régulière. Chaque élément pointe vers la sous-séquence qui correspond au groupe de capture correspondant à cet élément.

Constructeurs

Constructeur	Description
match_results	Construit l’objet.

Typedefs

Nom de type	Description
allocator_type	Type d'un allocateur pour la gestion du stockage.
char_type	Type d’un élément.
const_iterator	Type d’itérateur const pour les sous-correspondances.
const_reference	Type d'une référence constante d'élément.
difference_type	Type d’une différence d’itérateur.
iterator	Type d'itérateur pour les sous-correspondances.
référence	Type d’une référence d’élément.
size_type	Type d’un nombre de sous-correspondances.
string_type	Type d’une chaîne.
value_type	Type d’une sous-correspondance.

Fonctions Membre

Fonction membre	Description
begin	Désigne le début de la séquence de sous-correspondance.
empty	Vérifie l’absence de sous-correspondances.
end	Désigne la fin de la séquence de sous-correspondance.
format	Met en forme les sous-correspondances.
get_allocator	Retourne l'allocateur stocké.
length	Retourne la longueur d’une sous-correspondance.
max_size	Obtient le plus grand nombre de sous-correspondances.
position	Obtenez l’offset de démarrage d’un sous-groupe.
prefix	Obtient la séquence avant la première sous-correspondance.
size	Compte le nombre de sous-correspondances.
str	Retourne une sous-correspondance.
suffix	Obtient la séquence après la dernière sous-correspondance.
swap	Échange deux objets match_results.

Opérateurs

Opérateur	Description
operator=	Copier un objet match_results.
operator[]	Accédez à un sous-objet.

Spécifications

Header :<regex>

Espace de noms : std

Exemple

// std__regex__match_results.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::cout << "prefix: matched == " << std::boolalpha
        << mr.prefix().matched
        << ", value == " << mr.prefix() << std::endl;
    std::cout << "whole match: " << mr.length() << " chars, value == "
        << mr.str() << std::endl;
    std::cout << "suffix: matched == " << std::boolalpha
        << mr.suffix().matched
        << ", value == " << mr.suffix() << std::endl;
    std::cout << std::endl;

    std::string fmt("\"c(a*)|(b)\" matched \"$&\"\n"
        "\"(a*)\" matched \"$1\"\n"
        "\"(b)\" matched \"$2\"\n");
    std::cout << mr.format(fmt) << std::endl;
    std::cout << std::endl;

    // index through submatches
    for (size_t n = 0; n < mr.size(); ++n)
    {
        std::cout << "submatch[" << n << "]: matched == " << std::boolalpha
            << mr[n].matched <<
            " at position " << mr.position(n) << std::endl;
        std::cout << "  " << mr.length(n)
            << " chars, value == " << mr[n] << std::endl;
    }
    std::cout << std::endl;

    // iterate through submatches
    for (std::cmatch::iterator it = mr.begin(); it != mr.end(); ++it)
    {
        std::cout << "next submatch: matched == " << std::boolalpha
            << it->matched << std::endl;
        std::cout << "  " << it->length()
            << " chars, value == " << *it << std::endl;
    }
    std::cout << std::endl;

    // other members
    std::cout << "empty == " << std::boolalpha << mr.empty() << std::endl;

    std::cmatch::allocator_type al = mr.get_allocator();
    std::cmatch::string_type str = std::string("x");
    std::cmatch::size_type maxsiz = mr.max_size();
    std::cmatch::char_type ch = 'x';
    std::cmatch::difference_type dif = mr.begin() - mr.end();
    std::cmatch::const_iterator cit = mr.begin();
    std::cmatch::value_type val = *cit;
    std::cmatch::const_reference cref = val;
    std::cmatch::reference ref = val;

    maxsiz = maxsiz;  // to quiet "unused" warnings
    if (ref == cref)
        ch = ch;
    dif = dif;

    return (0);
}

prefix: matched == true, value == x
whole match: 4 chars, value == caaa
suffix: matched == true, value == y

"c(a*)|(b)" matched "caaa"
"(a*)" matched "aaa"
"(b)" matched ""

submatch[0]: matched == true at position 1
  4 chars, value == caaa
submatch[1]: matched == true at position 2
  3 chars, value == aaa
submatch[2]: matched == false at position 6
  0 chars, value ==

next submatch: matched == true
  4 chars, value == caaa
next submatch: matched == true
  3 chars, value == aaa
next submatch: matched == false
  0 chars, value ==

empty == false

match_results ::allocator_type

Type d'un allocateur pour la gestion du stockage.

typedef Alloc allocator_type;

Notes

Typedef est un synonyme de l’argument De modèle Alloc.

match_results ::begin

Désigne le début de la séquence de sous-correspondance.

const_iterator begin() const;

Notes

La fonction membre retourne un itérateur d’accès aléatoire qui pointe vers le premier élément de la séquence (ou juste après la fin d’une séquence vide).

match_results ::char_type

Type d’un élément.

typedef typename iterator_traits<BidIt>::value_type char_type;

Notes

Le typedef est un synonyme du type iterator_traits<BidIt>::value_type, qui est le type d’élément de la séquence de caractères recherchée.

match_results ::const_iterator

Type d’itérateur const pour les sous-correspondances.

typedef T0 const_iterator;

Notes

Le typedef décrit un objet pouvant servir d’itérateur à accès aléatoire de constante pour la séquence contrôlée.

match_results ::const_reference

Type d'une référence constante d'élément.

typedef const typename Alloc::const_reference const_reference;

Notes

Le typedef décrit un objet pouvant servir de référence constante à un élément de la séquence contrôlée.

match_results ::d ifference_type

Type d’une différence d’itérateur.

typedef typename iterator_traits<BidIt>::difference_type difference_type;

Notes

Le typedef est un synonyme du type iterator_traits<BidIt>::difference_type. Il décrit un objet capable de représenter la différence entre deux itérateurs qui pointent vers des éléments de la séquence contrôlée.

match_results ::empty

Vérifie l’absence de sous-correspondances.

bool empty() const;

Notes

La fonction membre retourne true uniquement en cas d’échec de la recherche d’expression régulière.

match_results ::end

Désigne la fin de la séquence de sous-correspondance.

const_iterator end() const;

Notes

La fonction membre retourne un itérateur qui pointe juste après la fin de la séquence.

match_results ::format

Met en forme les sous-correspondances.

template <class OutIt>
OutIt format(OutIt out,
    const string_type& fmt, match_flag_type flags = format_default) const;

string_type format(const string_type& fmt, match_flag_type flags = format_default) const;

Paramètres

OutIt
Type d'itérateur de sortie.

out
Flux de sortie dans lequel écrire.

Fmt
Chaîne de format.

flags
Indicateurs de format.

Notes

Chaque fonction membre génère du texte mis en forme sous le contrôle du format fmt. La première fonction membre écrit le texte mis en forme dans la séquence définie par son argument et retourne. La deuxième fonction membre retourne un objet de chaîne contenant une copie du texte mis en forme.

Pour générer du texte mis en forme, le texte littéral dans la chaîne de format est habituellement copié dans la séquence cible. Chaque séquence d'échappement dans la chaîne de format est remplacée par le texte qu'elle représente. Les détails de la copie et du remplacement sont contrôlés par les indicateurs de format transmis à la fonction.

match_results ::get_allocator

Retourne l'allocateur stocké.

allocator_type get_allocator() const;

Notes

La fonction membre retourne une copie de l'objet allocateur utilisé par *this pour allouer ses objets sub_match.

match_results ::iterator

Type d'itérateur pour les sous-correspondances.

typedef const_iterator iterator;

Notes

Le type décrit un objet pouvant servir d'itérateur à accès aléatoire pour la séquence contrôlée.

match_results ::length

Retourne la longueur d’une sous-correspondance.

difference_type length(size_type sub = 0) const;

Paramètres

sub
Index de la sous-correspondance.

Notes

La fonction membre retourne (*this)[sub].length().

match_results ::match_results

Construit l’objet.

explicit match_results(const Alloc& alloc = Alloc());

match_results(const match_results& right);

Paramètres

alloc
Objet allocateur à stocker.

right
Objet match_results à copier.

Notes

Le premier constructeur construit un objet match_results qui ne contient aucune sous-correspondance. Le deuxième constructeur construit un match_results objet qui est une copie de droite.

match_results ::max_size

Obtient le plus grand nombre de sous-correspondances.

size_type max_size() const;

Notes

La fonction membre retourne la longueur de la séquence la plus longue que l'objet peut contrôler.

match_results ::operator=

Copier un objet match_results.

match_results& operator=(const match_results& right);

Paramètres

right
Objet match_results à copier.

Notes

L’opérateur membre remplace la séquence contrôlée par *this une copie de la séquence contrôlée par le droit.

match_results ::operator[]

Accédez à un sous-objet.

const_reference operator[](size_type n) const;

Paramètres

n
Index de la sous-correspondance.

Notes

La fonction membre retourne une référence à l’élément n de la séquence contrôlée, ou une référence à un objet vide sub_match si size() <= n ou si le groupe de capture n’a pas fait partie de la correspondance.

match_results ::p osition

Obtenez l’offset de démarrage d’un sous-groupe.

difference_type position(size_type sub = 0) const;

Paramètres

sub
Index de la sous-correspondance.

Notes

La fonction membre retourne std::distance(prefix().first, (*this)[sub].first), c’est-à-dire la distance entre le premier caractère de la séquence cible et le premier caractère de la sous-correspondance vers laquelle pointe l’élément n de la séquence contrôlée.

match_results ::p refix

Obtient la séquence avant la première sous-correspondance.

const_reference prefix() const;

Notes

La fonction membre retourne une référence à un objet de type sub_match<BidIt> qui pointe vers la séquence de caractères qui commence au début de la séquence cible et qui se termine à (*this)[0].first, c’est-à-dire qu’il pointe vers le texte qui précède la sous-séquence correspondante.

match_results ::reference

Type d’une référence d’élément.

typedef const_reference reference;

Notes

Le type est un synonyme du type const_reference.

match_results ::size

Compte le nombre de sous-correspondances.

size_type size() const;

Notes

La fonction membre retourne le nombre de groupes de capture plus un dans l’expression régulière utilisée pour la recherche, ou zéro si aucune recherche n’a été effectuée.

match_results ::size_type

Type d’un nombre de sous-correspondances.

typedef typename Alloc::size_type size_type;

Notes

Le type est un synonyme du type Alloc::size_type.

match_results ::str

Retourne une sous-correspondance.

string_type str(size_type sub = 0) const;

Paramètres

sub
Index de la sous-correspondance.

Notes

La fonction membre retourne string_type((*this)[sub]).

match_results ::string_type

Type d’une chaîne.

typedef basic_string<char_type> string_type;

Notes

Le type est un synonyme du type basic_string<char_type>.

match_results ::suffixe

Obtient la séquence après la dernière sous-correspondance.

const_reference suffix() const;

Notes

La fonction membre retourne une référence à un objet de type sub_match<BidIt> , qui pointe vers la séquence de caractères qui commence à (*this)[size() - 1].second et qui se termine à la fin de la séquence cible. En d’autres termes, il pointe vers le texte qui suit la sous-séquence correspondante.

match_results ::swap

Échange deux objets match_results.

void swap(const match_results& right) throw();

Paramètres

right
Objet match_results à échanger.

Notes

La fonction membre échange le contenu et *this le droit dans le temps constant et ne lève pas d’exceptions.

match_results ::value_type

Type d’une sous-correspondance.

typedef sub_match<BidIt> value_type;

Notes

Le typedef est un synonyme du type sub_match<BidIt>.

Voir aussi

<regex>