C++ Academy · Leçon

Les bases de regex

Faire correspondre des motifs dans du texte

Leçon 1 sur 413 étapes

Les bases de regex est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que <regex> ?

L'en-tête <regex> vous permet de faire correspondre du texte à des expressions régulières qui décrivent des ensembles de chaînes. Vous construisez un motif, puis vous l'utilisez pour tester ou rechercher du texte.

std::regex contient un motif compilé.
Les fonctions de correspondance indiquent si le texte correspond au motif.

#include <iostream>
#include <regex>

int main() {
    std::regex pattern("hello");
    std::cout << std::boolalpha << std::regex_match("hello", pattern) << '\n';
    return 0;
}

regex_match contre regex_search

regex_match exige que la chaîne entière corresponde. regex_search réussit si le motif apparaît n'importe où dans la chaîne.

#include <iostream>
#include <regex>

int main() {
    std::regex p("cat");
    std::string s = "the cat sat";
    std::cout << std::boolalpha;
    std::cout << "match: " << std::regex_match(s, p) << '\n';
    std::cout << "search: " << std::regex_search(s, p) << '\n';
    return 0;
}

Classes de caractères

Les crochets définissent un ensemble de caractères autorisés. [aeiou] correspond à n'importe quelle voyelle ; les intervalles comme [a-z] correspondent aux lettres minuscules.

#include <iostream>
#include <regex>

int main() {
    std::regex p("[a-z]+");
    std::cout << std::boolalpha << std::regex_match("hello", p) << '\n';
    std::cout << std::regex_match("Hello", p) << '\n';
    return 0;
}

Quantificateurs

Les quantificateurs contrôlent les répétitions : * zéro fois ou plus, + une fois ou plus, ? de manière facultative, et {n,m} selon un intervalle de quantités.

#include <iostream>
#include <regex>

int main() {
    std::regex p("a+b");
    std::cout << std::boolalpha;
    std::cout << std::regex_match("aaab", p) << '\n';
    std::cout << std::regex_match("b", p) << '\n';
    return 0;
}

Classes prédéfinies

Les classes abrégées évitent la saisie répétitive : \\d correspond à un chiffre, \\w à un caractère de mot et \\s à un espace. Dans le code source C++, la barre oblique inverse doit être doublée.

#include <iostream>
#include <regex>

int main() {
    std::regex p("\\d+");
    std::cout << std::boolalpha;
    std::cout << std::regex_match("12345", p) << '\n';
    std::cout << std::regex_match("12a45", p) << '\n';
    return 0;
}

Ancres

Les ancres fixent une correspondance à une position : ^ marque le début et $ la fin du texte. Elles correspondent à des positions, pas à des caractères.

#include <iostream>
#include <regex>

int main() {
    std::regex p("^abc$");
    std::cout << std::boolalpha;
    std::cout << std::regex_search("abc", p) << '\n';
    std::cout << std::regex_search("xabc", p) << '\n';
    return 0;
}

Alternance

La barre verticale | signifie « ou ». Le motif cat|dog correspond à l'un ou l'autre mot. Regroupez avec des parenthèses pour limiter sa portée.

#include <iostream>
#include <regex>

int main() {
    std::regex p("cat|dog");
    std::cout << std::boolalpha;
    std::cout << std::regex_match("cat", p) << '\n';
    std::cout << std::regex_match("dog", p) << '\n';
    std::cout << std::regex_match("fish", p) << '\n';
    return 0;
}

Échapper les caractères spéciaux

Des caractères comme ., * et ( ont une signification spéciale. Échappez-les avec une barre oblique inverse pour les faire correspondre littéralement.

#include <iostream>
#include <regex>

int main() {
    std::regex p("3\\.14");
    std::cout << std::boolalpha;
    std::cout << std::regex_match("3.14", p) << '\n';
    std::cout << std::regex_match("3x14", p) << '\n';
    return 0;
}

Correspondance insensible à la casse

Transmettez un indicateur tel que std::regex::icase lors de la construction du motif pour ignorer la casse des lettres pendant la correspondance.

#include <iostream>
#include <regex>

int main() {
    std::regex p("hello", std::regex::icase);
    std::cout << std::boolalpha;
    std::cout << std::regex_match("HELLO", p) << '\n';
    std::cout << std::regex_match("Hello", p) << '\n';
    return 0;
}

Validation simple

Les motifs sont très utiles pour valider des formats d'entrée, par exemple pour vérifier qu'une chaîne ressemble à un nombre simple avec un signe facultatif.

#include <iostream>
#include <regex>

bool isNumber(const std::string& s) {
    static const std::regex p("-?\\d+");
    return std::regex_match(s, p);
}

int main() {
    std::cout << std::boolalpha;
    std::cout << isNumber("-42") << '\n';
    std::cout << isNumber("4a2") << '\n';
    return 0;
}

Effectuer plusieurs correspondances

Combinez des classes et des quantificateurs pour valider des formats plus riches, comme une suite de lettres suivie de chiffres.

#include <iostream>
#include <regex>

int main() {
    std::regex p("[A-Za-z]+\\d+");
    std::cout << std::boolalpha;
    std::cout << std::regex_match("abc123", p) << '\n';
    std::cout << std::regex_match("123abc", p) << '\n';
    return 0;
}

Vérification rapide

Vérifiez votre compréhension de la différence entre correspondance et recherche.

Réponds-y dans la leçon interactive

Bilan

Vous avez appris les bases de <regex> :

regex_match pour une chaîne entière et regex_search pour des correspondances dans une sous-chaîne
les classes de caractères, les quantificateurs, les ancres et l'alternance
les classes prédéfinies comme \\d et l'échappement des caractères spéciaux
les indicateurs tels que icase

Ensuite, vous extrairez des parties précises d'une correspondance à l'aide de groupes capturants.

Gratuit pour commencer

Apprends C++ avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 51
Leçons: 203

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Les bases de regex » est-elle gratuite ?

Oui — le texte complet de « Les bases de regex » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Les bases de regex » ?

Faire correspondre des motifs dans du texte Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Les bases de regex » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy