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 <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 <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 <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 <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 <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;
}