Analyser du texte à l'aide d'expressions régulières en C++

Analyser du texte à l'aide d'expressions régulières en C++

Les expressions régulières sont un outil puissant et flexible pour faire correspondre et rechercher des modèles de texte. En C++, nous pouvons utiliser une bibliothèque d'expressions régulières pour analyser du texte.

Il existe deux choix principaux pour les bibliothèques d'expressions régulières en C++ : std::regex et Boost.Regex. Les deux bibliothèques fournissent des interfaces et des fonctionnalités similaires. Cependant, comme ils sont implémentés différemment, il peut y avoir des différences de performances dans certains cas. Boost.Regex est généralement considéré comme l'option la plus rapide et la plus précise, mais elle nécessite également l'utilisation de la bibliothèque Boost.

Dans cet article, nous présenterons comment utiliser la bibliothèque std::regex pour analyser du texte en C++. Nous montrerons à travers plusieurs exemples comment faire correspondre et extraire du texte en utilisant différentes syntaxes d'expressions régulières.

Exemple 1 : Faire correspondre le texte de base

Dans cet exemple, nous ferons correspondre une chaîne qui contient « bonjour ».

#include <iostream>
#include <regex>
 
int main() {
    std::string text = "hello world!";
    std::regex pattern("hello");
 
    if (std::regex_search(text, pattern)) {
        std::cout << "Match found!" << std::endl;
    } else {
        std::cout << "Match not found." << std::endl;
    }
 
    return 0;
}

Ce programme simple utilise la fonction std::regex_search() pour rechercher si la chaîne "hello" existe dans le texte. Si une correspondance est trouvée, le programme affichera « Match trouvé ! », sinon il affichera « Match non trouvé. ». Notez que nous avons utilisé les classes std::string et std::regex et avons transmis l'expression régulière sous forme de chaîne à l'objet regex.

Exemple 2 : Utilisation de métacaractères

Les métacaractères dans les expressions régulières font référence à des caractères ayant une signification particulière. Voici quelques-uns des métacaractères les plus couramment utilisés et leurs significations :

• Correspond à n'importe quel caractère.
• ^ correspond au début d'une chaîne.
• $ correspond à la fin de la chaîne.
• d correspond à un nombre.
• w Correspond à un caractère de mot (lettre, chiffre ou trait de soulignement).
• s correspond à un caractère d'espacement (espace, tabulation, etc.).

Dans l'exemple ci-dessous, nous ferons correspondre toute chaîne commençant par "hello".

#include <iostream>
#include <regex>
 
int main() {
    std::string text1 = "hello world!";
    std::string text2 = "world hello!";
    std::regex pattern("^hello");
 
    if (std::regex_search(text1, pattern)) {
        std::cout << "Match found in text1!" << std::endl;
    }
 
    if (std::regex_search(text2, pattern)) {
        std::cout << "Match found in text2!" << std::endl;
    }
 
    return 0;
}

Dans cet exemple, nous utilisons le métacaractère "^" pour faire correspondre les chaînes commençant par "hello". Dans le premier texte "hello world!", l'expression régulière et la chaîne commencent par "hello", le programme affichera donc "Match found in text1!". Dans le deuxième texte "world hello!", l'expression régulière ne correspond pas au début de la chaîne, donc le programme n'imprime rien.

Exemple 3 : Utilisation de quantificateurs

Les quantificateurs dans les expressions régulières spécifient le nombre de correspondances de modèles. Voici quelques-uns des quantificateurs les plus couramment utilisés et leurs significations :

• • Correspond au modèle précédent zéro ou plusieurs fois.
• • Faites correspondre le motif précédent une ou plusieurs fois.
• ? Correspond au motif précédent zéro ou une fois.
• {n} correspond exactement n fois au modèle précédent.
• {n,} correspond au modèle précédent au moins n fois.
• {n,m} correspond au modèle précédent au moins n fois, mais pas plus de m fois.

Dans l'exemple ci-dessous, nous utiliserons le quantificateur "+" pour faire correspondre un ou plusieurs nombres.

#include <iostream>
#include <regex>
 
int main() {
    std::string text1 = "1234";
    std::string text2 = "a1234";
    std::regex pattern("\d+");
 
    if (std::regex_search(text1, pattern)) {
        std::cout << "Match found in text1!" << std::endl;
    }
 
    if (std::regex_search(text2, pattern)) {
        std::cout << "Match found in text2!" << std::endl;
    }
 
    return 0;
}

Dans cet exemple, nous utilisons l'expression régulière "d+" pour faire correspondre un ou plusieurs nombres. Dans le premier texte "1234", l'expression régulière correspond à la chaîne entière, le programme affichera donc "Match found in text1!". Dans le deuxième texte "a1234", l'expression régulière correspond uniquement à la sous-chaîne numérique "1234", le programme affichera donc "Match found in text2!".

Exemple 4 : Utiliser le regroupement

Le regroupement dans des expressions régulières nous permet de diviser un modèle en sous-modèles et de ne prendre en compte qu'un seul d'entre eux lors de la correspondance. Le regroupement est exprimé à l'aide de parenthèses. Dans l'exemple ci-dessous, nous ferons correspondre les chaînes contenant « hello » ou « world ».

#include <iostream>
#include <regex>
 
int main() {
    std::string text1 = "hello";
    std::string text2 = "world";
    std::string text3 = "hello world!";
    std::regex pattern("(hello|world)");
 
    if (std::regex_search(text1, pattern)) {
        std::cout << "Match found in text1!" << std::endl;
    }
 
    if (std::regex_search(text2, pattern)) {
        std::cout << "Match found in text2!" << std::endl;
    }
 
    if (std::regex_search(text3, pattern)) {
        std::cout << "Match found in text3!" << std::endl;
    }
 
    return 0;
}

Dans cet exemple, nous utilisons l'expression régulière "(hello|world)" pour regrouper "hello" et "world" en deux groupes. Dans le premier texte "hello", l'expression régulière ne correspond qu'au premier groupe, donc le programme affichera "Match found in text1!". Dans le deuxième texte "world", l'expression régulière ne correspond qu'au deuxième groupe, donc le programme affichera "Match found in text2!". Dans le troisième texte "hello world!", l'expression régulière correspond au premier ou au deuxième groupe, donc le programme affichera "Match found in text3!".

Résumé

Dans cet article, nous avons présenté comment utiliser des expressions régulières pour analyser du texte en C++. Nous détaillons certaines des syntaxes d'expressions régulières les plus couramment utilisées, notamment les métacaractères, les quantificateurs et le regroupement. Espérons que ces exemples vous aideront à mieux comprendre comment utiliser des expressions régulières pour traiter des données textuelles.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!