regex_match, fonction

Article
06/09/2015

Teste si une expression régulière correspond à l'intégralité de la chaîne cible.

 // (1)  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);  // (2)  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);  // (3) 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);  // (4)  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);  // (5) 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);  // (6) 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
Type d'itérateur pour les sous-correspondances. Pour les cas courants, il s'agit de string::const_iterator, wstring::const_iterator, const char* ou const wchar_t*.
Alloc
Classe d'allocateur des résultats de correspondances.
Elem
Type des éléments à faire correspondre. Pour les cas courants, il s'agit de string, wstring, char* ou wchar_t*.
RXtraits
Classe Traits des éléments.
Alloc2
Classe d'allocateur d'expressions régulières.
IOtraits
Classe de caractéristiques des chaînes.
IOalloc
Classe d'allocateur de chaînes.
flags
Indicateurs pour les correspondances.
first
Début de la séquence à mettre en correspondance.
last
Fin de la séquence à mettre en correspondance.
match
Résultats de correspondances. Correspond au type Elem : smatch pour string, wsmatch pour wstring, cmatch pour char* ou wcmatch pour wchar_t*.
ptr
Pointeur vers le début de la séquence à mettre en correspondance. Si ptr est char*, utilisez cmatch et regex. Si ptr est wchar_t*, utilisez wcmatch et wregex.
re
Expression régulière à mettre en correspondance. Type regex pour string et char*, ou wregex pour wstring et wchar_t*.
str
Chaîne à mettre en correspondance. Correspond au type Elem.

Notes

Chaque fonction avec modèle retourne true uniquement si toute la séquence d'opérande str correspond exactement à l'argument d'expression régulière re. Utilisez regex_search pour mettre en correspondance une sous-chaîne dans une séquence cible et regex_iterator pour rechercher plusieurs correspondances.

Les fonctions qui acceptent un objet match_results définissent ses membres pour refléter si la correspondance a abouti et, si tel est le cas, ce que les différents groupes de capture dans l'expression régulière ont capturé.

(1):

Exemple

// RegexTestBed.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <regex> 
#include <iostream> 

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
   
    // (1) with char*
    // Note how const char* requires cmatch and regex
    const char *first = "abc";
    const char *last = first + strlen(first);
    cmatch narrowMatch;
    regex rx("a(b?)c");

    bool found = regex_match(first, last, narrowMatch, rx);

    // (1) with std::wstring
    // Note how wstring requires wsmatch and wregex.
    // Note use of const iterators cbegin() and cend().
    wstring target(L"Hello");
    wsmatch wideMatch;
    wregex wrx(L"He(l+)o");

    if (regex_match(target.cbegin(), target.cend(), wideMatch, wrx))
        wcout << L"The matching text is:" << wideMatch.str() << endl; 

    // (2) with std::string
    string target2("Drizzle");
    regex rx2(R"(D\w+e)"); // no double backslashes with raw string literal
    found = regex_match(target2.cbegin(), target2.cend(), rx2);

    // (3) with wchar_t*
    const wchar_t* target3 = L"2014-04-02";
    wcmatch wideMatch2;

    // LR"(...)" is a  raw wide-string literal. Open and close parens
    // are delimiters, not string elements.
    wregex wrx2(LR"(\d{4}(-|/)\d{2}(-|/)\d{2})"); 
    if (regex_match(target3, wideMatch2, wrx2))
    {
        wcout << L"Matching text: " << wideMatch2.str() << endl;
    }
   


     return 0;
}