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
Défini dans l'en-tête <regex>
template < class BidirIt >
class sub_match ;
(depuis C++11)

Le modèle de classe std::sub_match est utilisé par le moteur d'expressions régulières pour désigner les séquences de caractères correspondant aux sous-expressions marquées. Une correspondance est une paire [ begin , end ) dans la plage cible correspondant à l'expression régulière, mais avec des fonctions d'observation supplémentaires pour améliorer la clarté du code.

Seul le constructeur par défaut est accessible publiquement. Les instances de std::sub_match sont normalement construites et remplies en tant que partie d'un conteneur std::match_results durant le traitement d'un des algorithmes d'expressions rationnelles.

Les fonctions membres renvoient des valeurs par défaut définies à moins que le membre matched ne soit true .

std::sub_match hérite de std:: pair < BidirIt, BidirIt > , bien qu'il ne puisse pas être traité comme un objet std::pair car les fonctions membres telles que l'affectation ne fonctionneront pas comme prévu.

Table des matières

Exigences de type

-
BidirIt doit satisfaire aux exigences de LegacyBidirectionalIterator .

Spécialisations

Plusieurs spécialisations pour les types courants de séquences de caractères sont fournies :

Défini dans l'en-tête <regex>
Type Définition
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 >

Types imbriqués

Type Définition
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 >

Membres de données

Membre Description
bool matched
indique si cette correspondance a réussi
(objet membre public)

Hérité de std:: pair

BidirIt first
début de la séquence de correspondance
(membre public)
BidirIt second
fin de la séquence de correspondance (position après le dernier élément)
(membre public)

Fonctions membres

construit l'objet de correspondance
(fonction membre publique)
Observateurs
retourne la longueur de la correspondance (si elle existe)
(fonction membre publique)
convertit vers le type de chaîne sous-jacent
(fonction membre publique)
compare la sous-séquence correspondante (si elle existe)
(fonction membre publique)
Modificateurs
échange le contenu
(fonction membre publique)

Fonctions non membres

(supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (C++20)
compare un sub_match avec un autre sub_match , une chaîne ou un caractère
(modèle de fonction)
affiche la sous-séquence de caractères correspondante
(modèle de fonction)

Exemple

Exécuter ce code 
#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";
    }
}

Sortie : 

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: '.'

Voir aussi

(C++11)
itère à travers les sous-expressions spécifiées dans toutes les correspondances d'expressions rationnelles d'une chaîne donnée ou à travers les sous-chaînes non correspondantes
(modèle de classe)