Bibliothèque standard C++<regex>

Dans la bibliothèque standard C++, le<regex>fichier d'en-tête fournit des fonctionnalités d'expressions régulières, permettant aux développeurs de rechercher, remplacer ou découper des chaînes de manière très flexible. Les expressions régulières sont un puissant outil de traitement de texte, largement utilisé dans des domaines tels que la validation de données, l'analyse de texte et la correspondance de motifs.

Une expression régulière est un motif qui utilise une seule chaîne pour décrire et faire correspondre une série de chaînes conformes à une certaine règle de syntaxe. En C++, les expressions régulières sont implémentées via<regex>l'implémentation de la bibliothèque.

Dans C++11,<regex>Lorsque vous utilisez des expressions régulières, vous devez échapper les barres obliques inverses dans les littéraux de chaîne.\échappez-la, c'est-à-dire écrivez-la sous forme de double barre oblique inverse\\。

Pourquoi une double barre oblique inverse ?

Le compilateur C++ traite d'abord les caractères d'échappement dans les littéraux de chaîne, tandis que le moteur d'expressions régulières les traite ensuite.

Par exemple, vous écrivez\d+, le compilateur va\dil sera traité comme un caractère d'échappement inconnu, provoquant une erreur, ou devenird, la syntaxe correcte\\d+, le compilateur d'abord\\convertit en\, et lorsque le moteur d'expressions régulières lit ensuite\d。

C++11 prend également en charge les chaînes brutes, qui permettent d'éviter les doubles barres obliques inverses et qui sont très adaptées à l'écriture d'expressions régulières complexes :
regex re(R"(\d+)");         // 原始字符串,不需要写 \\d
  • Le contenu à l'intérieur de R"(...)" ne subira pas de traitement d'échappement.
  • Il est recommandé d'utiliser ceci lors de l'écriture d'expressions régulières complexes comportant plusieurs barres obliques inverses.

Syntaxe de base

Composants de base des expressions régulières

  • classe de caractères: comme[abc]Indique la correspondance avec n'importe quel caractère parmi a, b ou c.
  • quantificateur: comme*(zéro ou plusieurs fois),+(une ou plusieurs fois),?(zéro ou une fois).
  • correspondance de limites: comme^(début de ligne),$(fin de ligne).
  • groupement: à l'aide de parenthèses()pour créer un groupe.

C++ <regex>Classes et fonctions principales de la bibliothèque

  • std::regex: représente un objet d'expression régulière.
  • std::regex_match: vérifie si la chaîne entière correspond à l'expression régulière.
  • std::regex_search: recherche dans la chaîne les parties qui correspondent à l'expression régulière.
  • std::regex_replace: Remplace les parties de la chaîne qui correspondent à l'expression régulière.
  • std::sregex_iterator: Un itérateur, utilisé pour parcourir toutes les correspondances.

Exemple

1. Correspondance globale: regex_match

Exemple

#include <iostream>
#include <regex>
using namespace std;

int main() {
    regex re("\\d+");          // correspond aux chiffres
    string s = "12345";

    if (regex_match(s, re))
        cout << "Correspondance réussie\n";
    else
        cout << "Échec de la correspondance\n";
}

Résultat de sortie :

Match successful

2. Vérifier si la chaîne correspond à l'expression régulière

Exemple

#include <iostream>
#include <string>
#include <regex>
using namespace std;

int main() {
    string text = "Hello, World!";
    regex pattern("^[a-zA-Z]+, [a-zA-Z]+!$");

    if (regex_match(text, pattern)) {
        cout << "La chaîne correspond au motif." << endl;
    } else {
        cout << "La chaîne ne correspond pas au motif." << endl;
    }

    return 0;
}

Résultat de sortie :

The string matches the pattern.

3. Rechercher les correspondances dans une chaîne

Exemple

#include <iostream>
#include <string>
#include <regex>
using namespace std;

int main() {
    string text = "123-456-7890 et 987-654-3210";
    regex pattern("\\d{3}-\\d{3}-\\d{4}");

    smatch matches;
    while (regex_search(text, matches, pattern)) {
        cout << "Trouvé : " << matches[0] << endl;
        text = matches.suffix().str();  // continuer la recherche dans le reste
    }

    return 0;
}

Résultat de sortie :

Found: 123-456-7890
Found: 987-654-3210

4. Remplacer les éléments correspondants dans la chaîne

Exemple

#include <iostream>
#include <string>
#include <regex>
using namespace std;

int main() {
    string text = "Hello, World!";
    motif regex("World");
    chaîne de remplacement = "Universe";

    string result = regex_replace(text, pattern, replacement);

    cout << "Original: " << text << endl;
    cout << "Modified: " << result << endl;

    return 0;
}

Résultat de sortie :

Original: Hello, World!
Modified: Hello, Universe!

Plus de contenu

Classes et types courants

Name Description
std::regex Compiler l'objet d'expression régulière
std::smatch std::stringRésultat de correspondance
std::cmatch Résultats de correspondance de chaîne C (const char*)
std::sregex_iterator utilisé pourstd::stringitérateur de correspondance
std::cregex_iterator Itérateur de correspondance pour les chaînes C
std::syntax_option_type Options de syntaxe des expressions régulières
std::match_flag_type Drapeaux de contrôle de correspondance

Fonctions courantes

Nom de la fonction Objectif Valeur de retour Exemple
regex_match(s, re) Vérifier si la chaîne entière correspond bool regex_match("123", re)
regex_search(s, m, re) Trouver la première correspondance bool regex_search(s, m, re)
regex_replace(s, re, fmt) remplacer les correspondances string regex_replace(s, re, "#")

smatchObjet de résultat de correspondance

membre Description Exemple
m.str() Renvoyer tout le contenu correspondant cout << m.str()
m[i] Renvoyer le i-ème groupe de capture m[1].str()
m.position() Position de début de la correspondance m.position(0)
m.size() nombre de groupes de capture m.size()
m.empty() Indique si la correspondance est vide m.empty()

Syntaxe courante des expressions régulières

symbole Signification Exemple
. n'importe quel caractère a.ccorrespondanceabc
\d Nombres \d+
\w Alphanumérique et trait de soulignement \w+
\s caractère d'espacement \s+
^ début ^abc
$ end xyz$
+ 1 fois ou plus a+
* 0 fois ou plus a*
? 0 ou 1 fois a?
{n,m} n~m fois \d{2,4}
() groupe de capture (ab)+
[] jeu de caractères [A-Z]
` ` ou `cat dog`

Dans la chaîne de code source C++, vous devez écrire\\dau lieu de\d, car\doit être échappé.

Exemples d'utilisation typiques

Exemple

#include <iostream>
#include <regex>
using namespace std;

int main() {
    regex re("\\d+");
    string s = "abc123def456";

    // Trouver la première correspondance
    smatch m;
    if (regex_search(s, m, re))
        cout << "Première correspondance : " << m.str() << endl;

    // Parcourir toutes les correspondances
    for (sregex_iterator it(s.begin(), s.end(), re), end_it; it != end_it; ++it)
        cout << "Correspondance : " << it->str() << endl;

    // Remplacer
    string result = regex_replace(s, re, "#");
    cout << result << endl;
}
autres extensions