Comment utiliser des expressions régulières en c

Pour utiliser des expressions régulières en C, vous devez inclure le fichier d'en-tête et utiliser les fonctions qu'il fournit pour la correspondance des modèles et le traitement de texte. 1. Utilisez Std :: Regex_Match pour correspondre à la chaîne complète, et renvoyez True uniquement lorsque la chaîne entière se conforme au modèle; 2. Utilisez Std :: Regex_Search pour trouver des correspondances à n'importe quelle position de la chaîne; 3. Utilisez STD :: Smatch pour extraire le groupe de capture, obtenez la correspondance complète via des correspondances [0], des matchs [1] et des sous-matchs ultérieurs; 4. Utilisez STD :: Regex_Replace pour remplacer le texte correspondant et prendre en charge le groupe de capture par des références telles que 1 $ et 2 $; 5. Vous pouvez ajouter l'icône (ignorer le boîtier), le multiline (modèle multi-ligne) et d'autres indicateurs lors de la construction du regex pour ajuster le comportement de correspondance; 6. Pour améliorer les performances, les objets regex doivent être réutilisés pour éviter la construction répétée dans la boucle. La bibliothèque régulière de C 11 est puissante pour valider, extraire et convertir du texte, recommandé pour les opérations régulières de base en intermédiaires et faire attention à la compatibilité du compilateur pour la portabilité.

L'utilisation d'expressions régulières en C est devenue simple avec l'introduction de l'en-tête <regex></regex> en C 11. Cette bibliothèque fournit des outils pour la correspondance de motifs et la manipulation du texte. Voici comment l'utiliser efficacement.

Inclure l'en-tête regex

Pour travailler avec des expressions régulières, incluez l'en-tête standard <regex></regex> :

 #include <refgex>

Vous aurez également généralement besoin <string> et <iostream> pour la saisie / sortie de l'entrée et de la chaîne.

Correspondance de modèle de base avec std :: regex_match

std::regex_match vérifie si la chaîne entière correspond au modèle donné.

 #include <iostream>
#include <string>
#include <refgex>

int main () {
    std :: string text = "Hello123";
    STD :: motif regex (r "([a-za-z] \ d)"); // lettres suivies de chiffres

    if (std :: regex_match (texte, modèle)) {
        stdiegel :: cout << "match complet trouvé! \ n";
    } autre {
        std :: cout << "pas de correspondance complète. \ n";
    }

    retour 0;
}

Remarque: R"(...)" est un littéral à cordes bruts, ce qui évite d'échapper à des réchauffes.

• Utilisez std::regex_match lorsque vous voulez que la chaîne entière se conforme à un modèle (par exemple, validant un e-mail).
• Il ne true que si la chaîne entière correspond.

Correspondance partielle avec std :: regex_search

std::regex_search trouve une correspondance n'importe où dans la chaîne.

 std :: string text = "Contactez-nous à support@example.com aujourd'hui.";
std :: regex email_pattern (r "(\ b [a-za-z0-9 ._% -] @ [a-za-z0-9.-] \. [a-za-z] {2,} \ b)");

if (std :: regex_search (text, email_pattern)) {
    std :: cout << "e-mail trouvé dans le texte. \ n";
}

Ceci est utile pour la numérisation du texte pour extraire ou détecter des modèles comme les numéros de téléphone, les URL, etc.

Extraction de pièces assorties avec STD :: Smatch

Pour capturer et extraire les parties du match, utilisez std::smatch (pour std::string ) ou std::cmatch (pour les cordes C).

 std :: string text = "Date: 2023-10-05";
std :: regex date_pattern (r "((\ d {4}) - (\ d {2}) - (\ d {2}))");
Matchs STD :: Smatch;

if (std :: regex_search (texte, correspondant, date_pattern)) {
    std :: cout << "match complet:" << correspond [0] << "\ n"; // 2023-10-05
    std :: cout << "année:" << correspond [1] << "\ n"; // 2023
    std :: cout << "mois:" << correspond [2] << "\ n"; // 10
    std :: cout << "jour:" << correspond [3] << "\ n"; // 05
}

• matches[0] sont le match complet.
• matches[1] , matches[2] , etc., correspondent aux groupes capturés chez les parents.

Remplacer le texte par std :: regex_replace

Vous pouvez remplacer les correspondances à l'aide de std::regex_replace .

 std :: string text = "Appelez-moi au 123-456-7890 demain.";
std :: regex phone_pattern (r "(\ d {3} - \ d {3} - \ d {4})");
std :: string anonymized = std :: regex_replace (text, téléphone_pattern, "[téléphone]");

std :: cout << anonymisé << "\ n"; 
// Sortie: appelez-moi au [téléphone] demain.

Vous pouvez également utiliser des groupes capturés dans les remplacements:

 std :: string name = "Doe, John";
std :: regex name_pattern (r "((\ w), \ s * (\ w))");
std :: string formated = std :: regex_replace (name, name_pattern, "2 $ $ 1");
// Résultats: "John Doe"

• $1 , $2 , etc., reportez-vous aux groupes capturés.

Drapeaux regex communs

Lors de la construction d'un regex, vous pouvez transmettre des drapeaux pour modifier le comportement:

 STD :: Regex Pattern ("Hello", std :: regex_constants :: iase); // Case-Insitive
std :: regex multi_line ("^ start", std :: regex_constants :: iase | std :: regex_constants :: multiline);

Facteurs communs:

• std::regex_constants::icase - correspondance insensible à la casse
• std::regex_constants::multiline - ^ et $ correspond à la ligne commence / se termine
• std::regex_constants::optimize - hiérarchisez la vitesse sur le temps de construction

Conseils de performance

• Les objets regex sont coûteux à construire. Réutilisez-les si vous êtes utilisé plusieurs fois.
• Évitez de créer le même regex dans une boucle.

 std :: regex valid_email (r "(\ b [a-za-z0-9 ._% -] @ [a-za-z0-9.-] \. [a-za-z] {2,} \ b)"); // fais ça une fois

pour (const auto & e-mail: email_list) {
    if (std :: regex_match (email, valid_email)) {
        // traite un e-mail valide
    }
}

Résumé des fonctions clés

• std::regex_match - la chaîne complète doit correspondre
• std::regex_search - trouve le premier match n'importe où
• std::regex_replace - remplace les matchs dans une chaîne
• std::smatch - stocke plusieurs sous-matchs (avec des groupes de capture)

La bibliothèque C Regex prend en charge les fonctionnalités regex les plus courantes, bien qu'elle puisse varier légèrement selon le compilateur (en particulier les versions plus anciennes de GCC). Tenez-vous à des modèles de base pour la portabilité.

Fondamentalement, incluez <regex></regex> , définissez votre modèle, puis utilisez la correspondance, la recherche ou remplacez au besoin. Les groupes de capture et les chaînes de remplacement le rendent puissant pour l'analyse et la transformation de texte.

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!