regex_match Function

Article
03/04/2013

Correspond exactement une expression régulière.

template<class BidIt, class Alloc, class Elem, class RXtraits, class Alloc2>
    bool regex_match(BidIt first, Bidit last,
        match_results<BidIt, Alloc>& match,
        const basic_regex<Elem, RXtraits, Alloc2>& re,
        match_flag_type flags = match_default);
template<class BidIt, class Elem, class RXtraits, class Alloc2>
    bool regex_match(BidIt first, Bidit last,
        const basic_regex<Elem, RXtraits, Alloc2>& re,
        match_flag_type flags = match_default);
template<class Elem, class Alloc, class RXtraits, class Alloc2>
    bool regex_match(const Elem *ptr,
        match_results<const Elem*, Alloc>& match,
        const basic_regex<Elem, RXtraits, Alloc2>& re,
        match_flag_type flags = match_default);
template<class Elem, class RXtraits, class Alloc2>
    bool regex_match(const Elem *ptr,
        const basic_regex<Elem, RXtraits, Alloc2>& re,
        match_flag_type flags = match_default);
template<class IOtraits, class IOalloc, class Alloc, class Elem, class RXtraits, class Alloc2>
    bool regex_match(const basic_string<Elem, IOtraits, IOalloc>& str,
        match_results<typename basic_string<Elem, IOtraits, IOalloc>::const_iterator, Alloc>& match,
        const basic_regex<Elem, RXtraits, Alloc2>& re,
        match_flag_type flags = match_default);
template<class IOtraits, class IOalloc, class Elem, class RXtraits, class Alloc2>
    bool regex_match(const basic_string<Elem, IOtraits, IOalloc>& str,
        const basic_regex<Elem, RXtraits, Alloc2>& re,
        match_flag_type flags = match_default);

Paramètres

BidIt
Le type d'itérateur pour les sous-correspondances.
Alloc
La correspondance résultats classe de l'allocateur.
Elem
Le type des éléments à la correspondance.
RXtraits
Classe Ctraits pour les éléments.
Alloc2
La classe de l'allocateur d'expression régulière.
IOtraits
La classe Ctraits de chaîne.
IOalloc
La classe de l'allocateur de chaîne.
flags
Balises pour les correspondances.
first
Début de séquence à la correspondance.
last
Fin de séquence à la correspondance.
match
Les résultats de correspondance.
ptr
Pointeur vers le démarrage de la séquence en correspondance.
re
L'expression régulière en correspondance.
str
Chaîne en correspondance.

Notes

Chaque fonction de modèle retourne la valeur true uniquement si sa séquence d'opérande pondère exactement son argument red'expression régulière.Les fonctions acceptant un jeu d'objets d' match_results ses membres pour refléter si la correspondance a réussi et si ce que la capture autre groupe dans l'expression régulière capturée.

Exemple

// std_tr1__regex__regex_match.cpp 
// compile with: /EHsc 
#include <regex> 
#include <iostream> 
 
int main() 
    { 
    const char *first = "abc"; 
    const char *last = first + strlen(first); 
    std::cmatch mr; 
    std::regex rx("abc"); 
    std::regex_constants::match_flag_type fl = 
        std::regex_constants::match_default; 
 
    std::cout << "match(f, f+1, \"abc\") == " << std::boolalpha 
        << regex_match(first, first + 1, rx, fl) << std::endl; 
 
    std::cout << "match(f, l, \"abc\") == " << std::boolalpha 
        << regex_match(first, last, mr, rx) << std::endl; 
    std::cout << "  matched: \"" << mr.str() << "\"" << std::endl; 
 
    std::cout << "match(\"a\", \"abc\") == " << std::boolalpha 
        << regex_match("a", rx) << std::endl; 
 
    std::cout << "match(\"abc\", \"abc\") == " << std::boolalpha 
        << regex_match("abc", mr, rx) << std::endl; 
    std::cout << "  matched: \"" << mr.str() << "\"" << std::endl; 
 
    std::cout << "match(string, \"abc\") == " << std::boolalpha 
        << regex_match(std::string("a"), rx) << std::endl; 
 
    std::string str("abc"); 
    std::match_results<std::string::const_iterator> mr2; 
    std::cout << "match(string, \"abc\") == " << std::boolalpha 
        << regex_match(str, mr2, rx) << std::endl; 
    std::cout << "  matched: \"" << mr2.str() << "\"" << std::endl; 
 
    return (0); 
    }