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 ====

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 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 exacte 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>

==== 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>

===== Manque : vorace =====

__ A déplacer dans le chapitre sur les recherches ? __

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

affiche :

<code>
search "a{3}" in "aaaaa" = true
search "a{3}?" in "aaaaa" = true
</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
