Chaque caractère de base correspond à un seul caractère dans la séquence terminale, mais il est parfois nécessaire de pouvoir exprimer dans un motif que l'on souhaite n'importe quel caractère issu d'un ensemble. Par exemple, pour créer un motif permettant de valider une date, il faut pouvoir écrire que l'on souhaite avoir n'importe quelle chiffre. Peut importe le chiffre, du moment que c'est un chiffre. Les caractères génériques, classes de caractères et ensembles de caractères permettent d'écrire cela.

Le caractère générique correspond au point dans une expression régulière. Il signifie “n'importe quel caractère”, mais uniquement un seul caractère. Par exemple, le motif “ab.de” peut correspondre aux chaînes “abcde” ou “ab$de”, mais pas à la chaîne “ab$$de”.

main.cpp

#include <iostream>
#include <string>
#include <regex>
 
int main()
{
    std::regex pattern { "." };
    std::cout << "'.' match with '': " << std::boolalpha << 
        std::regex_match("", pattern) << std::endl;
 
    std::cout << "'.' match with 'a': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
 
    std::cout << "'.' match with 'ab': " << std::boolalpha << 
        std::regex_match("ab", pattern) << std::endl;
 
    pattern = "abc";
    std::cout << "'abc' match with 'abc': " << std::boolalpha << 
        std::regex_match("abc", pattern) << std::endl;
 
    std::cout << "'abc' match with 'a$c': " << std::boolalpha << 
        std::regex_match("a$c", pattern) << std::endl;
 
    pattern = "a.c";
    std::cout << "'a.c' match with 'abc': " << std::boolalpha << 
        std::regex_match("abc", pattern) << std::endl;
 
    std::cout << "'a.c' match with 'a$c': " << std::boolalpha << 
        std::regex_match("a$c", pattern) << std::endl;
}

affiche :

'.' match with '': false
'.' match with 'a': true
'.' match with 'ab': false
'abc' match with 'abc': true
'abc' match with 'a$c': false
'a.c' match with 'abc': true
'a.c' match with 'a$c': true

On voit donc bien que la chaîne correspond au motif uniquement si elle ne contient un et un seul caractère, pas plus, pas moins.

Les ensembles de caractères (character set) permettent de représenter une liste de caractères entre crochets droits []. Chaque ensemble permet de remplacer un et un seul caractère. Par exemple, le motif ”[abc]” représente un seul caractère, qui peut être a, b ou c.

main.cpp

#include <iostream>
#include <string>
#include <regex>
 
int main()
{
    std::regex const pattern { "[abc]" };
    std::cout << "'[abc]' match with '': " << std::boolalpha << 
        std::regex_match("", pattern) << std::endl;
 
    std::cout << "'[abc]' match with 'a': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
 
    std::cout << "'[abc]' match with 'b': " << std::boolalpha << 
        std::regex_match("b", pattern) << std::endl;
 
    std::cout << "'[abc]' match with 'z': " << std::boolalpha << 
        std::regex_match("z", pattern) << std::endl;
 
    std::cout << "'[abc]' match with 'ab': " << std::boolalpha << 
        std::regex_match("ab", pattern) << std::endl;
}

affiche :

'[abc]' match with '': false
'[abc]' match with 'a': true
'[abc]' match with 'b': true
'[abc]' match with 'z': false
'[abc]' match with 'ab': false

Si l'on souhaite écrire un motif qui permet de valider n'importe quelle lettre minuscule ou n'importe quel chiffre, il est fastidieux d'écrire tous les caractères correspondant : ”[abcdefghijklmnopqrstuvwxyz]” et ”[0123456789]”. Pour éviter cela, il est possible de spécifier une plage de valeur en indiquant le premier et le dernier caractère de la plage, séparés par un tiret. Par exemple : ”[a-z]” ou ”[0-9]”.

main.cpp

#include <iostream>
#include <string>
#include <regex>
 
int main()
{
    std::regex pattern { "[a-e]" };
    std::cout << "'[a-e]' match with '': " << std::boolalpha << 
        std::regex_match("", pattern) << std::endl;
 
    std::cout << "'[a-e]' match with 'a': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
 
    std::cout << "'[a-e]' match with 'e': " << std::boolalpha << 
        std::regex_match("e", pattern) << std::endl;
 
    std::cout << "'[a-e]' match with 'z': " << std::boolalpha << 
        std::regex_match("z", pattern) << std::endl;
 
    std::cout << "'[a-e]' match with 'ab': " << std::boolalpha << 
        std::regex_match("ab", pattern) << std::endl;
 
    pattern = "ab[c-f]";
    std::cout << "'ab[c-f]' match with '': " << std::boolalpha << 
        std::regex_match("", pattern) << std::endl;
 
    std::cout << "'ab[c-f]' match with 'abc': " << std::boolalpha << 
        std::regex_match("abc", pattern) << std::endl;
 
    std::cout << "'ab[c-f]' match with 'abz': " << std::boolalpha << 
        std::regex_match("abz", pattern) << std::endl;
}

affiche :

'[a-e]' match with '': false
'[a-e]' match with 'a': true
'[a-e]' match with 'e': true
'[a-e]' match with 'z': false
'[a-e]' match with 'ab': false
'ab[c-f]' match with '': false
'ab[c-f]' match with 'abc': true
'ab[c-f]' match with 'abz': false

Il est possible de spécifier plusieurs plages dans un ensemble, par exemple ”[a-er-z]” correspond à un caractère qui peut être a, b, c, d, e, r, s, t, u, v, w, x, y ou z.

Certains ensembles de classes sont souvent utilisées, il existe donc des raccourcis pour éviter de les réécrire à chaque fois. Ce sont les classes de caractères (character class). Par exemple, le motif ”[ [ : alpha:]]” correspond à n'importe quel caractère alphabétique, donc est équivalent à ”[a-zA-Z]”. Le tableau suivant présente l'ensemble des classes de caractères possible :

Ces classes de caractères permettent de simplifier l'écriture des motifs.

main.cpp

#include <iostream>#include <regex>
 
int main()
{
    std::regex pattern { "[[:alpha:]]" };
    std::cout << "'[[:alpha:]]' match with 'a': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
 
    std::cout << "'[[:alpha:]]' match with '1': " << std::boolalpha << 
        std::regex_match("1", pattern) << std::endl;
 
    std::cout << "'[[:alpha:]]' match with '&': " << std::boolalpha << 
        std::regex_match("&", pattern) << std::endl;
 
    pattern = "[[:alnum:]]";
    std::cout << "'[[:alnum:]]' match with 'a': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
 
    std::cout << "'[[:alnum:]]' match with '1': " << std::boolalpha << 
        std::regex_match("1", pattern) << std::endl;
 
    std::cout << "'[[:alnum:]]' match with '&': " << std::boolalpha << 
        std::regex_match("&", pattern) << std::endl;
}

affiche :

'[[:alpha:]]' match with 'a': true
'[[:alpha:]]' match with '1': false
'[[:alpha:]]' match with '&': false
'[[:alnum:]]' match with 'a': true
'[[:alnum:]]' match with '1': true
'[[:alnum:]]' match with '&': false

Il est possible de prendre la négation d'une classe de caractères, c'est-à-dire de pouvoir accepter tous les caractères sauf ceux de la classe, en utilisant le symbole ^. Par exemple, [^[:alpha:]] signifie “tous les caractères non alphabétiques” :

main.cpp

#include <iostream>
#include <regex>
 
int main()
{
    std::regex const pattern { "[^[:alpha:]]" };
    std::cout << "'[[:alpha:]]' match with 'a': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
 
    std::cout << "'[[:alpha:]]' match with '1': " << std::boolalpha << 
        std::regex_match("1", pattern) << std::endl;
 
    std::cout << "'[[:alpha:]]' match with '&': " << std::boolalpha << 
        std::regex_match("&", pattern) << std::endl;
}

affiche :

'[[:alpha:]]' match with 'a': false
'[[:alpha:]]' match with '1': true
'[[:alpha:]]' match with '&': true

Il est possible d'ajouter des caractères à une classe de caractères, en les spéciant entre les premiers crochets droits. Par exemple, l'ensemble [123[:alpha:]] permet de représenter tous les caractères alphabétiques, ainsi que les caractères 1, 2 et 3.

main.cpp

#include <iostream>
#include <regex>
 
int main()
{
    std::regex const pattern { "[123[:alpha:]]" };
    std::cout << "'[123[:alpha:]]' match with 'a': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
 
    std::cout << "'[123[:alpha:]]' match with '1': " << std::boolalpha << 
        std::regex_match("1", pattern) << std::endl;
 
    std::cout << "'[123[:alpha:]]' match with '4': " << std::boolalpha << 
        std::regex_match("4", pattern) << std::endl;
 
    std::cout << "'[123[:alpha:]]' match with '&': " << std::boolalpha << 
        std::regex_match("&", pattern) << std::endl;
}

affiche :

'[123[:alpha:]]' match with 'a': true
'[123[:alpha:]]' match with '1': true
'[123[:alpha:]]' match with '4': false
'[123[:alpha:]]' match with '&': false

Pour terminer avec les classes de caractères, il existe une écriture simplifiée pour certaines classes. Ces écritures simplifiés s'écrivent avec la barre oblique inversée \ suivi d'un caractère. Lorsque le caractère est minuscule, cela correspond à une classe de caractères. Lorsqu'il est en majuscule, cela correspond à l'inverse de la classe de caractères correspondante. Le tableau suivant liste l'ensemble des écritures simplifiées :

N'oubliez pas qu'il faut faut ajouter une barre oblique inversée en C++ pour échapper le caractère \ ou utiliser les littérales chaînes brutes. Par exemple, pour écrire \d, il faut écrire en C++ :

std::regex const pattern { "\\d" };
// ou
std::regex const pattern { R"(\d)" };

main.cpp

#include <iostream>
#include <regex>
 
int main()
{
    std::regex const pattern { R"(\w)" };
    std::cout << R"('\w' match with 'a': )" << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
 
    std::cout << R"('\w' match with '1': )" << std::boolalpha << 
        std::regex_match("1", pattern) << std::endl;
 
    std::cout << R"('\w' match with '&': )" << std::boolalpha << 
        std::regex_match("&", pattern) << std::endl;
}

affiche :

'\w' match with 'a': true
'\w' match with '1': true
'\w' match with '&': false

main.cpp

    std::cout << "Répétition" << std::endl;
    match("", R"(a*)"); // zero or more
    match("a", R"(a*)");
    match("aa", R"(a*)");
    match("aaaaaa", R"(a*)");
    match("b", R"(a*)");
    search("jdsihbhvdsv", R"(a*)");
    std::cout << std::endl;
 
    match("", R"(a+)"); // one or more
    match("a", R"(a+)");
    match("aa", R"(a+)");
    match("aaaaaa", R"(a+)");
    match("b", R"(a+)");
    std::cout << std::endl;
 
    match("", R"(a?)"); // zero or one
    match("a", R"(a?)");
    match("aa", R"(a?)");
    std::cout << std::endl;
 
    match("", R"(a{3})"); // bounded repeat
    match("a", R"(a{3})");
    match("aaa", R"(a{3})");
    match("aaaaa", R"(a{3})");
    match("", R"(a{3,})");
    match("a", R"(a{3,})");
    match("aaa", R"(a{3,})");
    match("aaaaa", R"(a{3,})");
    match("", R"(a{3,5})");
    match("a", R"(a{3,5})");
    match("aaa", R"(a{3,5})");
    match("aaaaa", R"(a{3,5})");
    match("aaaaaaa", R"(a{3,5})");
    std::cout << std::endl;
 
     // non-greedy (non vorace)
    search("aaaaa", R"(a{3})");     // -> aaaaa = plus longue correspondance
    search("aaaaa", R"(a{3}?)");    // -> aaa = plus courte correspondance
    std::cout << std::endl;
 
    std::cout << "Ancres (anchor)" << std::endl;
    search("", R"(^a)"); // début
    search("a", R"(^a)");
    search("abc", R"(^a)");
    search("cba", R"(^a)");
    std::cout << std::endl;
 
    search("", R"(a$)"); // fin
    search("a", R"(a$)");
    search("abc", R"(a$)");
    search("cba", R"(a$)");
    std::cout << std::endl;
 
    std::cout << "Groupes (group)" << std::endl;
    std::cout << "Priorité des opérateurs (precedence)" << std::endl;
}

affiche :

Caractères de base
"a" match with "" = false
"a" match with "a" = true
"a" match with "b" = false
"a" match with "ab" = false
"ab" match with "ab" = true
"ab" match with "abb" = false

différence entre match et search
"a" match with "ab" = false
search "a" in "ab" = true

Caractères générique (wildcard)
"." match with "" = false
"." match with "a" = true
"." match with "abc" = false

"abc" match with "abc" = true
"abc" match with "a5c" = false
"a.c" match with "abc" = true
"a.c" match with "a5c" = true

"[[:alpha:]]" match with "a" = true
"[[:alpha:]]" match with "1" = false
"[[:alpha:]]" match with "&" = false
"[[:alnum:]]" match with "a" = true
"[[:alnum:]]" match with "1" = true
"[[:alnum:]]" match with "&" = false
Autres : alnum ou w, alpha, blank, cntrl, digit ou d, graph, lower,
    print, punct, space ou s, upper, xdigit (digit hexa)

Ensemble de caractères (character set)
"[ab]" match with "" = false
"[ab]" match with "a" = true
"[ab]" match with "b" = true
"[ab]" match with "ab" = false

"[a-e]" match with "" = false
"[a-e]" match with "a" = true
"[a-e]" match with "e" = true
"[a-e]" match with "f" = false
"[a-e]" match with "ab" = false

"ab[c-f]" match with "" = false
"ab[c-f]" match with "abc" = true

Répétition
"a*" match with "" = true
"a*" match with "a" = true
"a*" match with "aa" = true
"a*" match with "aaaaaa" = true
"a*" match with "b" = false
search "a*" in "jdsihbhvdsv" = true

"a+" match with "" = false
"a+" match with "a" = true
"a+" match with "aa" = true
"a+" match with "aaaaaa" = true
"a+" match with "b" = false

"a?" match with "" = true
"a?" match with "a" = true
"a?" match with "aa" = false

"a{3}" match with "" = false
"a{3}" match with "a" = false
"a{3}" match with "aaa" = true
"a{3}" match with "aaaaa" = false
"a{3,}" match with "" = false
"a{3,}" match with "a" = false
"a{3,}" match with "aaa" = true
"a{3,}" match with "aaaaa" = true
"a{3,5}" match with "" = false
"a{3,5}" match with "a" = false
"a{3,5}" match with "aaa" = true
"a{3,5}" match with "aaaaa" = true
"a{3,5}" match with "aaaaaaa" = false

search "a{3}" in "aaaaa" = true
search "a{3}?" in "aaaaa" = true

Ancres (anchor)
search "^a" in "" = false
search "^a" in "a" = true
search "^a" in "abc" = true
search "^a" in "cba" = false

search "a$" in "" = false
search "a$" in "a" = true
search "a$" in "abc" = false
search "a$" in "cba" = true

Groupes (group)
Priorité des opérateurs (precedence)

main.cpp

#include <iostream>
#include <string>
#include <regex>
 
void search(std::string const& target, std::string const& pattern_str) {
    std::regex pattern { pattern_str };
    std::cout << R"(search ")" << pattern_str << R"(" in ")" << target << R"(" = )"  
        << std::boolalpha << std::regex_search(target, pattern) << std::endl;
}
 
void match(std::string const& target, std::string const& pattern_str) {
    std::regex pattern { pattern_str };
    std::cout << R"(")" << pattern_str << R"(" match with ")" << target << R"(" = )"
        << std::boolalpha << std::regex_match(target, pattern) << std::endl;
}
 
std::string tr(std::string const& s, int i) {
    return std::regex_replace(s, std::regex(R"(\$\d)"), std::to_string(i));
}
 
int main()
{    
    std::cout << "Groups" << std::endl;
    {
        std::regex pattern("(ab)cd(ef)");    // Find double word.
        std::string replacement = "le premier groupe est $1 et le second groupe est $2"; 
        std::string target = "abcdef";
        std::string output_str = regex_replace(target, pattern, replacement);
        std::cout << output_str << std::endl;
    }
    {
        std::regex pattern(R"((\d{2})[-/](\d{2})[-/](\d{4}))");
        std::smatch match;
        std::regex_search(std::string("12-03-2014"), match, pattern);
        for (size_t i = 0; i < match.size(); ++i) 
        {
            std::cout << i << ": " << match[i].str() << '\n';
        }  
    }
 
    std::cout << "Traduction" << std::endl;
    {
        std::regex pattern("([a-zA-Z]+) \\1");    
        std::string replacement = "$1";     
        std::string target = "The cat cat bites the dog dog.";
        std::string output_str = regex_replace(target, pattern, replacement);
        std::cout << output_str << std::endl;
    }
 
    std::cout << tr("bla bla $1 bla bla", 123) << std::endl;
    std::cout << tr("bli bli bli bli $1", 123) << std::endl;
    std::cout << std::endl;
 
 
    std::cout << "Groupe" << std::endl;
    match("", R"((ab)*)");
    match("a", R"((ab)*)");
    match("b", R"((ab)*)");
    match("ab", R"((ab)*)");
    match("abc", R"((ab)*)");
    match("ababab", R"((ab)*)");
    std::cout << std::endl;
 
 
    match("cat", R"(c[a-z]*t)");
    std::cout << std::endl;
 
    std::cout << "Exemples de regex" << std::endl;
    std::cout << "Date" << std::endl;
    match("12-03-2014", R"(\d{2}[-/]\d{2}[-/]\d{4})");
    std::cout << "Time" << std::endl;
    match("15:17", R"(\d{2}:\d{2})");
    std::cout << std::endl;
 
    // vérifier qu'un identifiant C++ est valide
    // [a-zA-Z_][a-zA-Z_0-9]*
 
    // fichier windows
    //[a-zA-Z_][a-zA-Z_0-9]*\.[a-zA-Z0-9]+
 
    std::string regex_str = "[a-z_][a-z_0-9]*\\.[a-z0-9]+";
    std::regex reg1(regex_str, std::regex_constants::icase);
    std::string str = "File names are readme.txt and my.cmd.";
    std::sregex_iterator it(str.begin(), str.end(), reg1);
    std::sregex_iterator it_end;
    while(it != it_end) {
        std::cout << it->str() << std::endl;
        ++it;
    }
}

Groups
le premier groupe est ab et le second groupe est ef
0: 12-03-2014
1: 12
2: 03
3: 2014
Traduction
The cat bites the dog.
bla bla 123 bla bla
bli bli bli bli 123

Groupe
"(ab)*" match with "" = true
"(ab)*" match with "a" = false
"(ab)*" match with "b" = false
"(ab)*" match with "ab" = true
"(ab)*" match with "abc" = false
"(ab)*" match with "ababab" = true

"c[a-z]*t" match with "cat" = true

Exemples de regex
Date
"\d{2}[-/]\d{2}[-/]\d{4}" match with "12-03-2014" = true
Time
"\d{2}:\d{2}" match with "15:17" = true

readme.txt
my.cmd