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]] ^ [[expressions_regulieres_3|Chapitre suivant]] ^

====== [Aller plus loin] 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. Peu 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 <html>[[:alpha:]]</html> correspond à n'importe quel caractère alphabétique, donc est équivalent à <html>[a-zA-Z]</html>. 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, <html>[^[:alpha:]]</html> 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écifiant 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 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 =====

Jusqu'à maintenant, les syntaxes que l'on a vu ne permettent de remplacer qu'un seul caractère. Si l'on veut écrire un motif correspondant à trois lettres, il faudra écrire : ''[ [:alpha:]][ [:alpha:]][ [:alpha:]]''. C'est un peu lourd à écrire (surtout si l'on veut 20 lettres par exemple) et cela ne permet pas de spécifier des motifs comme "5 à 10 lettres" ou "tous les caractères jusqu'au premier point".

Une répétition permet de répéter un caractères ou un groupe de caractères. Il existe plusieurs répétitions :

^ Symbole     ^ Écriture     ^ Répétition               ^
|  ''*''      |  ''a*''      | zéro ou plus             |
|  ''+''      |  ''a+''      | un ou plus               |
|  ''?''      |  ''a?''      | zéro ou un               |
|  ''{n}''    |  ''a{3}''    | n répétitions            |
|  ''{n,}''   |  ''a{3,}''   | n ou plus répétitions    |
|  ''{n,m}''  |  ''a{3,5}''  | entre n et m répétitions |

La première répétition ''*'' permet de répéter zéro ou plusieurs fois un caractère. Par exemple, le motif ''a*'' correspond à une chaîne vide ''""'' ou une chaîne contenant un nombre quelconque de caractère ''a'' (par exemple ''"aaa"'' ou ''"aaaaaa"''), mais aucun autre caractère.

<code cpp main.cpp>
#include <iostream>
#include <regex>
 
int main()
{
    std::regex const pattern { "a*" };
    std::cout << "'a*' match with '': " << std::boolalpha << 
        std::regex_match("", pattern) << std::endl;
        
    std::cout << "'a*' match with 'a': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
        
    std::cout << "'a*' match with 'aaaa': " << std::boolalpha << 
        std::regex_match("aaaa", pattern) << std::endl;
        
    std::cout << "'a*' match with 'abcd': " << std::boolalpha << 
        std::regex_match("abcd", pattern) << std::endl;
}
</code>

affiche :

<code>
'a*' match with '': true
'a*' match with 'a': true
'a*' match with 'aaaa': true
'a*' match with 'abcd': false
</code>

La répétition ''+'' permet de répéter une ou plusieurs fois un caractère. Le motif ''a+'' est similaire au motif précédent, mais interdit la chaîne vide :

<code cpp main.cpp>
#include <iostream>
#include <regex>
 
int main()
{
    std::regex const pattern { "a+" };
    std::cout << "'a+' match with '': " << std::boolalpha << 
        std::regex_match("", pattern) << std::endl;
        
    std::cout << "'a+' match with 'a': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
        
    std::cout << "'a+' match with 'aaaa': " << std::boolalpha << 
        std::regex_match("aaaa", pattern) << std::endl;
        
    std::cout << "'a+' match with 'abcd': " << std::boolalpha << 
        std::regex_match("abcd", pattern) << std::endl;
}
</code>

affiche :

<code>
'a+' match with '': false
'a+' match with 'a': true
'a+' match with 'aaaa': true
'a+' match with 'abcd': false
</code>

La répétition ''?'' permet de répéter zéro ou une fois un caractère. Le motif ''"a?"'' accepte donc uniquement la chaîne vide et la chaîne ''"a"''.

<code cpp main.cpp>
#include <iostream>
#include <regex>
 
int main()
{
    std::regex const pattern { "a?" };
    std::cout << "'a?' match with '': " << std::boolalpha << 
        std::regex_match("", pattern) << std::endl;
        
    std::cout << "'a?' match with 'a': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
        
    std::cout << "'a?' match with 'aaaa': " << std::boolalpha << 
        std::regex_match("aaaa", pattern) << std::endl;
}
</code>

affiche :

<code>
'a?' match with '': true
'a?' match with 'a': true
'a?' match with 'aaaa': false
</code>

Les répétitions avec les crochets s'appellent des répétitions bornées (//bounded repeat//). La première permet de spécifier le nombre exact de répétitions du caractère, la seconde le nombre minimal de répétitions et la dernière les nombres minimal et maximal de répétitions.

__ pourquoi je m'amuse à recopier le std::boolalpha à chaque cout ?? __

<code cpp main.cpp>
#include <iostream>
#include <regex>
 
int main()
{
    std::regex pattern { "a{3}" };
    std::cout << "'a{3}' match with '': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
        
    std::cout << "'a{3}' match with 'aaaa': " << std::boolalpha << 
        std::regex_match("aaaa", pattern) << std::endl;
        
    std::cout << "'a{3}' match with 'aaaaaaaa': " << std::boolalpha << 
        std::regex_match("aaaaaaaa", pattern) << std::endl << std::endl;
        
    pattern = "a{3,}";
    std::cout << "'a{3,}' match with '': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
        
    std::cout << "'a{3,}' match with 'aaaa': " << std::boolalpha << 
        std::regex_match("aaaa", pattern) << std::endl;
        
    std::cout << "'a{3,}' match with 'aaaaaaaa': " << std::boolalpha << 
        std::regex_match("aaaaaaaa", pattern) << std::endl << std::endl;
        
    pattern = "a{3,5}";
    std::cout << "'a{3,5}' match with '': " << std::boolalpha << 
        std::regex_match("a", pattern) << std::endl;
        
    std::cout << "'a{3,5}' match with 'aaaa': " << std::boolalpha << 
        std::regex_match("aaaa", pattern) << std::endl;
        
    std::cout << "'a{3,5}' match with 'aaaaaaaa': " << std::boolalpha << 
        std::regex_match("aaaaaaaa", pattern) << std::endl;
}
</code>

affiche :

<code>
'a{3}' match with '': false
'a{3}' match with 'aaaa': false
'a{3}' match with 'aaaaaaaa': false

'a{3,}' match with '': false
'a{3,}' match with 'aaaa': true
'a{3,}' match with 'aaaaaaaa': true

'a{3,5}' match with '': false
'a{3,5}' match with 'aaaa': true
'a{3,5}' match with 'aaaaaaaa': false
</code>

===== Les ancres =====

Les ancres (//anchor//) permettent d'attacher un motif au début (avec ''^'') ou à la fin (avec ''$'') de la séquence cible. Elles servent uniquement (__principalement ?__) pour les recherches. Ainsi, le motif ''^a'' recherche le caractère ''a'' au début d'une chaîne, alors que le motif ''a$'' le recherche à la fin.

<code cpp main.cpp>
#include <iostream>
#include <regex>
 
int main()
{
    std::regex pattern { "^a" };
    std::cout << "'^a' match with '': " << std::boolalpha << 
        std::regex_search("", pattern) << std::endl;
        
    std::cout << "'^a' match with 'abcd': " << std::boolalpha << 
        std::regex_search("abcd", pattern) << std::endl;
        
    std::cout << "'^a' match with 'dcba': " << std::boolalpha << 
        std::regex_search("dcba", pattern) << std::endl << std::endl;
        
    pattern = "a$";
    std::cout << "'a$' match with '': " << std::boolalpha << 
        std::regex_search("", pattern) << std::endl;
        
    std::cout << "'a$' match with 'abcd': " << std::boolalpha << 
        std::regex_search("abcd", pattern) << std::endl;
        
    std::cout << "'a$' match with 'dcba': " << std::boolalpha << 
        std::regex_search("dcba", pattern) << std::endl;
}
</code>

affiche :

<code>
'^a' match with '': false
'^a' match with 'abcd': true
'^a' match with 'dcba': false

'a$' match with '': false
'a$' match with 'abcd': false
'a$' match with 'dcba': true
</code>

^ [[expressions_regulieres|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[expressions_regulieres_3|Chapitre suivant]] ^
C++, Qt, OpenGL, CUDA

Outils d'utilisateurs

Outils du Site

Outils de la Page
