Regular expressions library (since C++11)

La bibliothèque d'expressions régulières fournit une classe qui représente les expressions régulières , qui sont une sorte de mini-langage utilisé pour effectuer des correspondances de motifs dans les chaînes de caractères. Presque toutes les opérations avec les regex peuvent être caractérisées en opérant sur plusieurs des objets suivants :

• Séquence cible . La séquence de caractères dans laquelle on recherche un motif. Il peut s'agir d'une plage spécifiée par deux itérateurs, d'une chaîne de caractères terminée par un caractère nul ou d'un std::string .

• Modèle . Ceci est l'expression régulière elle-même. Il détermine ce qui constitue une correspondance. C'est un objet de type std::basic_regex , construit à partir d'une chaîne avec une grammaire spéciale.

• Matched array . Les informations sur les correspondances peuvent être récupérées sous la forme d'un objet de type std::match_results .

• Chaîne de remplacement . Il s'agit d'une chaîne qui détermine comment remplacer les correspondances.

Grammaires d'expressions régulières

Les motifs et les chaînes de remplacement prennent en charge les grammaires d'expressions régulières suivantes :

• Grammaire d'expression régulière ECMAScript modifiée . Il s'agit de la grammaire par défaut.
• Grammaire d'expression régulière POSIX de base .
• Grammaire d'expression régulière POSIX étendue .
• La grammaire d'expression régulière utilisée par l'utilitaire awk dans POSIX.
• La grammaire d'expression régulière utilisée par l'utilitaire grep dans POSIX. C'est effectivement la même que la grammaire d'expression régulière POSIX de base, avec l'ajout du saut de ligne ' \n ' comme séparateur d'alternative.
• La grammaire d'expression régulière utilisée par l'utilitaire grep , avec l'option - E , dans POSIX. C'est effectivement la même que la grammaire d'expression régulière POSIX étendue, avec l'ajout du saut de ligne ' \n ' comme séparateur d'alternative en plus de '|' .

Certaines variations grammaticales (telles que la correspondance insensible à la casse) sont également disponibles, consultez cette page pour plus de détails.

Classes principales

Ces classes encapsulent une expression régulière et les résultats de la correspondance d'une expression régulière dans une séquence cible de caractères.

Algorithmes

Ces fonctions sont utilisées pour appliquer l'expression régulière encapsulée dans un regex à une séquence cible de caractères.

Itérateurs

Les itérateurs d'expressions régulières sont utilisés pour parcourir l'ensemble complet des correspondances d'expressions régulières trouvées dans une séquence.

Exceptions

Cette classe définit le type d'objets lancés comme exceptions pour signaler des erreurs de la bibliothèque d'expressions régulières.

Traits

La classe de traits regex est utilisée pour encapsuler les aspects localisables d'une regex.

Constantes

Exemple

#include <iostream>
#include <iterator>
#include <regex>
#include <string>
int main()
{
    std::string s = "Some people, when confronted with a problem, think "
        "\"I know, I'll use regular expressions.\" "
        "Now they have two problems.";
    std::regex self_regex("REGULAR EXPRESSIONS",
        std::regex_constants::ECMAScript | std::regex_constants::icase);
    if (std::regex_search(s, self_regex))
        std::cout << "Text contains the phrase 'regular expressions'\n";
    std::regex word_regex("(\\w+)");
    auto words_begin = 
        std::sregex_iterator(s.begin(), s.end(), word_regex);
    auto words_end = std::sregex_iterator();
    std::cout << "Found "
              << std::distance(words_begin, words_end)
              << " words\n";
    const int N = 6;
    std::cout << "Words longer than " << N << " characters:\n";
    for (std::sregex_iterator i = words_begin; i != words_end; ++i)
    {
        std::smatch match = *i;
        std::string match_str = match.str();
        if (match_str.size() > N)
            std::cout << "  " << match_str << '\n';
    }
    std::regex long_word_regex("(\\w{7,})");
    std::string new_s = std::regex_replace(s, long_word_regex, "[$&]");
    std::cout << new_s << '\n';
}

Text contains the phrase 'regular expressions'
Found 20 words
Words longer than 6 characters:
  confronted
  problem
  regular
  expressions
  problems
Some people, when [confronted] with a [problem], think 
"I know, I'll use [regular] [expressions]." Now they have two [problems].