Namespaces
Variants

std:: regex_match

From cppreference.net
C++
Text processing library
Regular expressions library
Classes
(C++11)
(C++11)
(C++11)
Algorithms
regex_match
(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)
Défini dans l'en-tête <regex>
template < class BidirIt, class Alloc, class CharT, class Traits >

bool regex_match ( BidirIt first, BidirIt last,
std:: match_results < BidirIt, Alloc > & m,
const std:: basic_regex < CharT, Traits > & e,
std:: regex_constants :: match_flag_type flags =

std:: regex_constants :: match_default ) ;
(1) (depuis C++11)
template < class BidirIt, class CharT, class Traits >

bool regex_match ( BidirIt first, BidirIt last,
const std:: basic_regex < CharT, Traits > & e,
std:: regex_constants :: match_flag_type flags =

std:: regex_constants :: match_default ) ;
(2) (depuis C++11)
template < class CharT, class Alloc, class Traits >

bool regex_match ( const CharT * str,
std:: match_results < const CharT * , Alloc > & m,
const std:: basic_regex < CharT, Traits > & e,
std:: regex_constants :: match_flag_type flags =

std:: regex_constants :: match_default ) ;
(3) (depuis C++11)
template < class CharT, class Traits >

bool regex_match ( const CharT * str, const std:: basic_regex < CharT, Traits > & e,
std:: regex_constants :: match_flag_type flags =

std:: regex_constants :: match_default ) ;
(4) (depuis C++11)
template < class STraits, class SAlloc, class Alloc,

class CharT, class Traits >
bool regex_match
( const std:: basic_string < CharT, STraits, SAlloc > & s,
std:: match_results
< typename std:: basic_string < CharT, STraits, SAlloc > :: const_iterator ,
Alloc > & m,
const std:: basic_regex < CharT, Traits > & e,
std:: regex_constants :: match_flag_type flags =

std:: regex_constants :: match_default ) ;
(5) (depuis C++11)
template < class STraits, class SAlloc, class CharT, class Traits >

bool regex_match ( const std:: basic_string < CharT, STraits, SAlloc > & s,
const std:: basic_regex < CharT, Traits > & e,
std:: regex_constants :: match_flag_type flags =

std:: regex_constants :: match_default ) ;
(6) (depuis C++11)
template < class STraits, class SAlloc, class Alloc,

class CharT, class Traits >
bool regex_match
( const std:: basic_string < CharT, STraits, SAlloc > && ,
std:: match_results
< typename std:: basic_string < CharT, STraits, SAlloc > :: const_iterator ,
Alloc > & ,
const std:: basic_regex < CharT, Traits > & ,
std:: regex_constants :: match_flag_type flags =

std:: regex_constants :: match_default ) = supprimé ;
(7) (depuis C++11)

Détermine si l'expression régulière e correspond à la séquence de caractères cible dans son intégralité. Le résultat détaillé de la correspondance est stocké dans m (si présent).

1,2) La séquence de caractères cible est représentée par l'intervalle [ first , last ) .

Si BidirIt ne satisfait pas aux exigences de LegacyBidirectionalIterator , le comportement est indéfini.

(jusqu'à C++23)

Si BidirIt ne modélise pas bidirectional_iterator , le comportement est indéfini.

(depuis C++23)
3,4) La séquence de caractères cible est représentée par la plage [ str , str + std:: char_traits < CharT > :: length ( str ) ) .
5,6) La séquence de caractères cible est représentée par la chaîne s .
7) La séquence de caractères cible ne peut pas être représentée par une std::string rvalue.

Si la correspondance n'existe pas, les expressions suivantes impliquant m (si elle existe) doivent produire les valeurs spécifiées :

Expression Valeur
m. ready ( ) true
m. size ( ) ​ 0 ​
m. empty ( ) true

Si la correspondance existe, étant donné n'importe quel entier dans ( ​ 0 , m. size ( ) ) comme n , les expressions suivantes impliquant m doivent produire les valeurs spécifiées pour chaque surcharge listée ci-dessous :

**Note:** Aucune traduction n'a été effectuée car : - Tous les textes se trouvent dans des balises ` ` qui contiennent du code C++ - Les termes C++ (`m.prefix().first`, `first`, `str`, `s.begin()`) ne doivent pas être traduits - La structure HTML et les attributs ont été préservés intacts **Note:** Aucune traduction n'a été effectuée car tout le texte se trouve dans des balises ` ` qui contiennent du code C++, et selon les instructions : - Le code C++ ne doit pas être traduit - Les termes spécifiques au C++ doivent être conservés - Le texte dans les balises ` `, ` 
`, `` ne doit pas être traduit
Le contenu visible est exclusivement du code C++ et des références techniques qui doivent rester en anglais pour préserver leur signification technique.
 **Note:** Le code HTML a été conservé intact comme demandé. Le contenu textuel à traduire était très limité dans cet extrait, principalement constitué de code C++ qui ne doit pas être traduit. Les seuls éléments potentiellement traduisibles ("last") sont des termes C++ spécifiques qui doivent rester en anglais selon les instructions.
Expression Valeur
Surcharge (1) Surcharge (3) Surcharge (5)
m. ready ( ) true
m. size ( ) 1 + e. mark_count ( )
m. empty ( ) false
m. prefix ( ) . first first str s. begin ( )
m. prefix ( ) . second
m. prefix ( ) . matched false [1]
m. suffix ( ) . first last std:: char_traits < CharT > ::
length ( str ) + str 		s. end ( )
m. suffix ( ) . second
m. suffix ( ) . matched false [2]
m [0] . first first str s. begin ( )
m [0] . second last std:: char_traits < CharT > ::
length ( str ) + str 		s. end ( )
m [0] . matched true [3]
m [n] . first
  • last si la sous-expression marquée n n'a pas participé à la correspondance
  • le début de la séquence correspondant à la sous-expression n sinon
m [n] . second
  • last si la sous-expression marquée n n'a pas participé à la correspondance
  • la fin de la séquence sinon correspondant à la sous-expression n sinon
m [n] . matched
  1. ↑ Le préfixe de correspondance est vide.
  2. ↑ Le suffixe de correspondance est vide.
  3. ↑ La séquence entière est correspondante.

Table des matières

Paramètres

first, last - la plage de caractères cible
str - la chaîne de style C cible terminée par un caractère nul
s - la std::basic_string cible
m - les résultats de correspondance
e - l'expression régulière
flags - les indicateurs utilisés pour déterminer comment la correspondance sera effectuée

Valeur de retour

Retourne true si la séquence cible entière correspond à e , false sinon.

Notes

Parce que regex_match ne considère que les correspondances complètes, la même expression régulière peut donner des résultats différents entre regex_match et std::regex_search : 

std::regex re("Get|GetValue");
std::cmatch m;
std::regex_search("GetValue", m, re);  // renvoie true, et m[0] contient "Get"
std::regex_match ("GetValue", m, re);  // renvoie true, et m[0] contient "GetValue"
std::regex_search("GetValues", m, re); // renvoie true, et m[0] contient "Get"
std::regex_match ("GetValues", m, re); // renvoie false

Exemple

Exécuter ce code 
#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
int main()
{
    // Correspondance d'expression régulière simple
    const std::string fnames[] = {"foo.txt", "bar.txt", "baz.dat", "zoidberg"};
    const std::regex txt_regex("[a-z]+\\.txt");
    for (const auto& fname : fnames)
        std::cout << fname << ": " << std::regex_match(fname, txt_regex) << '\n';
    // Extraction d'une sous-correspondance
    const std::regex base_regex("([a-z]+)\\.txt");
    std::smatch base_match;
    for (const auto& fname : fnames)
        if (std::regex_match(fname, base_match, base_regex))
            // La première sous-correspondance est la chaîne entière ; la suivante
            // est la première expression entre parenthèses.
            if (base_match.size() == 2)
            {
                std::ssub_match base_sub_match = base_match[1];
                std::string base = base_sub_match.str();
                std::cout << fname << " a une base de " << base << '\n';
            }
    // Extraction de plusieurs sous-correspondances
    const std::regex pieces_regex("([a-z]+)\\.([a-z]+)");
    std::smatch pieces_match;
    for (const auto& fname : fnames)
        if (std::regex_match(fname, pieces_match, pieces_regex))
        {
            std::cout << fname << '\n';
            for (std::size_t i = 0; i < pieces_match.size(); ++i)
            {
                std::ssub_match sub_match = pieces_match[i];
                std::string piece = sub_match.str();
                std::cout << "  sous-correspondance " << i << ": " << piece << '\n';
            }
        }
}

Sortie : 

foo.txt: 1
bar.txt: 1
baz.dat: 0
zoidberg: 0
foo.txt a une base de foo
bar.txt a une base de bar
foo.txt
  sous-correspondance 0: foo.txt
  sous-correspondance 1: foo
  sous-correspondance 2: txt
bar.txt
  sous-correspondance 0: bar.txt
  sous-correspondance 1: bar
  sous-correspondance 2: txt
baz.dat
  sous-correspondance 0: baz.dat
  sous-correspondance 1: baz
  sous-correspondance 2: dat

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 2205 C++11 n pouvait être zéro dans la postcondition ne peut être que positif
LWG 2273 C++11 il n'était pas clair si les correspondances partielles étaient considérées ne considère que les correspondances complètes
LWG 2329 C++11 la surcharge (5) acceptait les rvalues de basic_string ,
ce qui pouvait entraîner des itérateurs pendants 		rejetée via la surcharge supprimée (7)

Voir aussi

(C++11)
objet d'expression régulière
(modèle de classe)
(C++11)
identifie une correspondance d'expression régulière, incluant toutes les sous-correspondances
(modèle de classe)
(C++11)
tente de faire correspondre une expression régulière à n'importe quelle partie d'une séquence de caractères
(modèle de fonction)