Comment utiliser les fonctions d'expressions régulières en C++ ?

Comment utiliser la fonction d'expression régulière en C++ ?

Les expressions régulières sont un puissant outil de traitement de texte qui peut être utilisé pour faire correspondre, rechercher et remplacer des modèles dans le texte. En C++, nous pouvons utiliser la bibliothèque de fonctions d'expressions régulières pour traiter du texte. Cet article explique comment utiliser les fonctions d'expression régulière en C++.

Tout d'abord, nous devons inclure le fichier d'en-tête regex de la bibliothèque standard C++ :

#include <regex>

Ensuite, nous pouvons déclarer un objet d'expression régulière en utilisant std::regex et lui transmettre le modèle correspondant. Par exemple, si nous voulons faire correspondre une chaîne composée de plusieurs lettres et chiffres, nous pouvons utiliser le code suivant :

std::regex pattern("[a-zA-Z0-9]+");

Lors de l'utilisation d'expressions régulières, nous pouvons également spécifier certains indicateurs pour modifier le comportement de correspondance. Les indicateurs courants incluent :

• std::regex_constants::ECMAScript : utiliser la syntaxe d'expression régulière de style ECMAScript
• std::regex_constants::grep : utiliser la syntaxe d'expression régulière de style grep
• std::regex_constants ::extended ; : Utiliser la syntaxe d'expression régulière étendue POSIX ;
• std::regex_constants::icase : ignorer la casse ;
• std::regex_constants::nosubs : ne pas renvoyer les sous-expressions qui correspondent au résultat.

Vous pouvez choisir un logo adapté en fonction de la situation réelle.

Avant d'effectuer une correspondance d'expression régulière, nous devons définir un objet std::smatch pour stocker les résultats correspondants. std::smatch est un conteneur de résultats correspondants, qui peut stocker plusieurs résultats correspondants. Par exemple :

std::smatch matches;

Ensuite, nous pouvons utiliser la fonction std::regex_match pour vérifier si une chaîne correspond à une expression régulière donnée. Le prototype de cette fonction est le suivant :

bool std::regex_match(const std::string& str, std::smatch& match, const std::regex& pattern);

Parmi eux, str est la chaîne à faire correspondre, match est l'objet std::smatch utilisé pour stocker les résultats de correspondance et pattern est l'objet d'expression régulière à faire correspondre. La fonction renvoie une valeur booléenne indiquant si la correspondance est réussie.

Ce qui suit est un exemple de code qui montre comment utiliser la fonction std::regex_match pour vérifier si une chaîne est une adresse e-mail valide :

#include 
#include <regex>

int main()
{
    std::string email = "example@example.com";
    std::regex pattern("\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b");
    std::smatch matches;

    if (std::regex_match(email, matches, pattern))
    {
        std::cout << "Valid email address!" << std::endl;
    }
    else
    {
        std::cout << "Invalid email address!" << std::endl;
    }

    return 0;
}

En plus d'utiliser la fonction std::regex_match pour une correspondance complète, nous pouvons également utiliser la fonction std ::regex_search effectue une correspondance partielle. Le prototype de la fonction std::regex_search est le suivant :

bool std::regex_search(const std::string& str, std::smatch& match, const std::regex& pattern);

La fonction std::regex_search recherchera dans une chaîne toute sous-chaîne correspondant à l'expression régulière donnée et stockera les résultats correspondants dans un objet std::smatch.

Voici un exemple de code qui montre comment utiliser la fonction std::regex_search pour rechercher tous les entiers dans une chaîne :

#include 
#include <regex>

int main()
{
    std::string text = "abc123def456ghi789";
    std::regex pattern("\d+");
    std::smatch matches;

    while (std::regex_search(text, matches, pattern))
    {
        std::cout << matches.str() << std::endl;
        text = matches.suffix().str();
    }

    return 0;
}

L'exemple ci-dessus affichera : "123", "456" et "789", respectivement caractères Trois entiers dans la chaîne.

En plus de la correspondance et de la recherche, nous pouvons également utiliser la fonction std::regex_replace pour remplacer la partie de la chaîne qui correspond à l'expression régulière. Le prototype de la fonction std::regex_replace est le suivant :

std::string std::regex_replace(const std::string& str, const std::regex& pattern, const std::string& replacement);

La fonction std::regex_replace recherchera dans la chaîne str toutes les sous-chaînes qui correspondent au modèle d'expression régulière donné et les remplacera par la chaîne de remplacement.

Voici un exemple de code qui montre comment utiliser la fonction std::regex_replace pour remplacer tous les espaces d'une chaîne par des traits de soulignement :

#include 
#include <regex>

int main()
{
    std::string text = "Hello,   World!";
    std::regex pattern("\s+");
    std::string replacement = "_";

    std::string result = std::regex_replace(text, pattern, replacement);
    std::cout << result << std::endl;

    return 0;
}

L'exemple ci-dessus affichera : "Hello,_World!", en remplaçant tous les espaces par Underline.

Ce qui précède est une introduction à la façon d'utiliser la fonction d'expression régulière en C++. En utilisant des expressions régulières, nous pouvons traiter efficacement les chaînes et obtenir des capacités de traitement de texte plus flexibles et plus puissantes. J'espère que cet article vous aidera à comprendre et à utiliser les fonctions d'expression régulière en C++.

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!