C++, Qt, OpenGL, CUDA

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.

^ [[expressions_regulieres|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[comparer_strings|Chapitre suivant]] ^

====== Les expressions régulières 2 ======

==== Caractère générique, classe de caractères et ensemble de caractères ====

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"''.

<note info>Ceci explique pourquoi, dans le code précédent, le motif ''"."'' était retrouvé dans n'importe quelle chaîne, puisque cela signifie simple "trouve un caractère quelconque dans la chaîne". Donc seule la chaîne vide ''""'' retourne faux avec ce motif.</note>

<code cpp 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;
}
</code>

affiche :

<code>
'.' 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
</code>

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.

<code cpp 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;
}
</code>

affiche :

<code>
'[abc]' match with '': false
'[abc]' match with 'a': true
'[abc]' match with 'b': true
'[abc]' match with 'z': false
'[abc]' match with 'ab': false
</code>

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]".

<code cpp 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;
}
</code>
    
affiche :

<code>
'[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
</code>

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 :

^ Classe de caractères ^ Description                       ^ Ensemble équivalent                         ^
|  ''[:alnum:]''       | Caractères alphanumériques        |  ''[a-zA-Z0-9]''                            |
|  ''[:alpha:]''       | Caractères alphabétiques          |  ''[a-zA-Z]''                               |
|  ''[:ascii:]''       | Caractères ASCII                  |  ''[\x00-\x7F]''                            |
|  ''[:blank:]''       | Espace et tabulation              |  ''[ \t]''                                  |
|  ''[:cntrl:]''       | Caractères de contrôle            |  ''[\x00-\x1F\x7F]''                        |
|  ''[:digit:]''       | Chiffres                          |  ''[0-9]''                                  | 
|  ''[:graph:]''       | Caractères visibles               |  ''[\x21-\x7E]''                            |
|  ''[:lower:]''       | Caractères minuscules             |  ''[a-z]''                                  |
|  ''[:print:]''       | Caractères visibles et espace     |  ''[\x20-\x7E]''                            |
|  ''[:punct:]''       | Ponctuation et symboles           |  ''[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]''  |
|  ''[:space:]''       | Caractères blancs                 |  ''[ \t\r\n\v\f]''                          |
|  ''[:upper:]''       | Caractères majuscules             |  ''[A-Z]''                                  |
|  ''[:word:]''        | Lettre, chiffre ou tiret bas      |  ''[A-Za-z0-9_]''                           |
|  ''[:xdigit:]''      | Chiffres hexadécimaux             |  ''[A-Fa-f0-9]''                            |

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

<code cpp 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;
}
</code>

affiche :

<code>
'[[: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
</code>

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" :

<code cpp 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;
}
</code>

affiche :

<code>
'[[:alpha:]]' match with 'a': false
'[[:alpha:]]' match with '1': true
'[[:alpha:]]' match with '&': true
</code>

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.

<code cpp 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;
}
</code>

affiche :

<code>
'[123[:alpha:]]' match with 'a': true
'[123[:alpha:]]' match with '1': true
'[123[:alpha:]]' match with '4': false
'[123[:alpha:]]' match with '&': false
</code>

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 :

^ Écriture simplifiée ^ Classe de caractères ^
|  ''\d''             |  ''[[:digit:]]''     |
|  ''\D''             |  ''[^[:digit:]]''    |
|  ''\s''             |  ''[[:space:]]''     |
|  ''\S''             |  ''[^[:space:]]''    |
|  ''\w''             |  ''[_[:alnum:]]''    |
|  ''\W''             |  ''[^_[:alnum:]]''   |

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++ :

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

<code cpp 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;
}
</code>

affiche :

<code>
'\w' match with 'a': true
'\w' match with '1': true
'\w' match with '&': false
</code>

==== Les répétitions ====


<code cpp 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;
}
</code>

affiche :

<code>
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)
</code>

==== Les groupes de capture ====

<code cpp 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;
    }
}
</code>

<code>
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
</code>

^ [[expressions_regulieres|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[comparer_strings|Chapitre suivant]] ^

{{tag> Cours C++}}
C++, Qt, OpenGL, CUDA

Outils d'utilisateurs

Outils du Site

Outils de la Page
