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_2|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[validation_motifs|Chapitre suivant]] ^

====== [Aller plus loin] Les expressions régulières 3 ======

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

Les groupes de capture permettent de réutiliser une sous-chaîne de la séquence cible, identifiée par un motif. La sous-chaîne capturée peut être réutilisée dans le motif ou être récupérée dans le code C++. Pour créer un groupe de capture, vous devez simplement écrire le motif correspondant à ce groupe entre parenthèses. Pour que cela soit plus clair, voyons quelques exemples. 

==== Répéter un groupe de capture ====

Commençons par un exemple simple de groupe, sans utiliser la capture (donc sans réutiliser la sous-chaîne identifiée par le groupe). Le but est d'écrire un motif qui permet de valider une chaîne constituée de répétition la chaîne <html>"ab"</html>, comme par exemple <html>"ab"</html> ou <html>"ababab"</html>. En première intention, on pourrait être tenté d'écrire le motif suivant : <html>"ab*"</html>.

Cependant, le caractère de répétition <html>*</html> s'applique que sur le caractère <html>b</html>. Pour indiquer que l'on souhaite répéter le motif <html>"ab"</html>, il faut donc le mettre entre parenthèses : <html>"(ab)*"</html>.

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

affiche :

<code>
'ab*' match with '': false
'ab*' match with 'ab': true
'ab*' match with 'abab': false

'(ab)*' match with '': true
'(ab)*' match with 'ab': true
'(ab)*' match with 'abab': true
</code>


==== Réutiliser un groupe de capture ====

Les chaînes identifiées par un groupe de capture peuvent être réutilisées dans le motif. Chaque groupe est identifié par un numéro, dans l'ordre de leur déclaration. Pour réutiliser une chaîne, il faut indiquer le numéro de groupe précédé d'une barre oblique inversée : <html>\1</html>, <html>\2</html>, <html>\3</html>, etc.

Par exemple, pour écrire un motif qui permet d'identifier n'importe quelle chaîne commençant et terminant par le même caractère, on pourra écrire le motif suivant :

  * pour récupérer le premier caractère : <html>(.)</html> ;
  * pour les caractères de la chaîne autre que le premier et le dernier caractère : <html>.*</html> ;
  * pour le dernier caractère, qui doit être identique au premier : <html>\1</html>.

Donc le motif final est <html>(.).*\1</html>. Pour écrire ce motif en C++, n'oubliez pas qu'il faut ajouter un caractère d'échappement devant la barre oblique inversée (le motif s'écrit alors <html>"(.).*\\1"</html>) ou il faut écrire une littérale chaîne brute (le motif s'écrit alors <html>R"((.).*\1)"</html>).

<code cpp main.cpp>
#include <iostream>
#include <regex>
 
int main()
{
    std::regex const pattern { R"((.).*\1)" };
    std::cout << "'(.).*\\1' match with '': " << std::boolalpha << 
        std::regex_match("", pattern) << std::endl;
 
    std::cout << "'(.).*\\1' match with 'abc': " << std::boolalpha << 
        std::regex_match("abc", pattern) << std::endl;
 
    std::cout << "'(.).*\\1' match with 'aba': " << std::boolalpha << 
        std::regex_match("aba", pattern) << std::endl;
 
    std::cout << "'(.).*\\1' match with 'abcdefa': " << std::boolalpha << 
        std::regex_match("abcdefa", pattern) << std::endl;
}
</code>

affiche :

<code>
'(.).*\1' match with '': false
'(.).*\1' match with 'abc': false
'(.).*\1' match with 'aba': true
'(.).*\1' match with 'abcdefa': true
</code>

De la même façon, si on veut pouvoir identifier une chaîne qui commence par deux caractères et qui se termine par ces deux caractères dans l'ordre inverse, on va pouvoir utiliser deux groupes de capture. Le motif s'écrit alors : <html>(.)(.).*\2\1</html>.

Pour terminer avec les groupes de capture, ils vont permettre de récupérer dans le code C++ une sous-chaîne correspondant à un motif complet de la chaîne. En effet, imaginons que l'on souhaite écrire un motif qui permet de reconnaître une date au format <html>jj/mm/aa</html> (jour-mois-année, chaque élément étant écrit avec deux chiffres) et qui permet de récupérer le jour. On pourrait écrire simplement le motif <html>^[[:digit:]]{2}</html> (ou <html>^\d{2}</html>). Le problème est que ce motif peut correspondre à n'importe quelle chaîne commençant par deux chiffre (pour rappel, le caractère <html>^</html> est une ancre indiquant le début de la séquence cible), par exemple <html>"12abcde"</html> ou <html>"123456"</html>.

Pour éviter cela, on va simplement écrire un motif qui correspond à une date, selon le format indiqué : <html>\d{2}/\d{2}/\d{2}</html>. On ajoute ensuite un groupe de capture pour les sous-chaînes que l'on souhaite récupérer dans le code C++. Par exemple, pour récupérer les jours, on écrit : <html>(\d{2})/\d{2}/\d{2}</html>. Cela permet de récupérer la date du jour, en garantissant que le format de date est respecté.

Nous verrons par la suite le code C++ utilisé pour récupérer les groupes capturés.

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

Outils d'utilisateurs

Outils du Site

Outils de la Page
