C++ Academy · Leçon

Groupes de capture

Extraire les parties correspondantes

Groupes de capture est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 2 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 qu'un groupe capturant ?

Les parenthèses d'un motif créent un groupe capturant qui mémorise la partie du texte à laquelle elles correspondent, afin que vous puissiez l'extraire ensuite.

(\\d+) capture une suite de chiffres.
Les résultats sont placés dans un std::smatch.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\d+)");
    std::smatch m;
    std::string s = "order 42";
    if (std::regex_search(s, m, p)) {
        std::cout << "Captured: " << m[1] << '\n';
    }
    return 0;
}

Le résultat smatch

std::smatch stocke les résultats de la correspondance. L'index [0] représente la correspondance complète, tandis que [1], [2], ... représentent les groupes capturants dans leur ordre.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\w+)@(\\w+)");
    std::smatch m;
    std::string s = "user@host";
    if (std::regex_search(s, m, p)) {
        std::cout << "Whole: " << m[0] << '\n';
        std::cout << "User: " << m[1] << ", Host: " << m[2] << '\n';
    }
    return 0;
}

Groupes multiples

Vous pouvez capturer plusieurs éléments à la fois, par exemple en séparant une date en année, mois et jour.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\d{4})-(\\d{2})-(\\d{2})");
    std::smatch m;
    std::string s = "2026-05-30";
    if (std::regex_match(s, m, p)) {
        std::cout << "Y=" << m[1] << " M=" << m[2] << " D=" << m[3] << '\n';
    }
    return 0;
}

str(), position(), length()

Chaque groupe fournit str() pour son texte, position() pour son décalage et length() pour sa taille dans l'entrée.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\d+)");
    std::smatch m;
    std::string s = "abc 789 xyz";
    if (std::regex_search(s, m, p)) {
        std::cout << "str: " << m[1].str() << '\n';
        std::cout << "pos: " << m.position(1) << '\n';
        std::cout << "len: " << m.length(1) << '\n';
    }
    return 0;
}

Préfixe et suffixe

L'objet de correspondance fournit également prefix() (le texte avant la correspondance) et suffix() (le texte après).

#include <iostream>
#include <regex>

int main() {
    std::regex p("\\d+");
    std::smatch m;
    std::string s = "left 55 right";
    if (std::regex_search(s, m, p)) {
        std::cout << "prefix: [" << m.prefix() << "]\n";
        std::cout << "suffix: [" << m.suffix() << "]\n";
    }
    return 0;
}

Groupes non capturants

Utilisez (?:...) pour regrouper sans capturer. Vos groupes numérotés restent ainsi pertinents lorsque vous n'avez besoin d'un regroupement que pour des quantificateurs ou l'alternance.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(?:Mr|Ms) (\\w+)");
    std::smatch m;
    std::string s = "Ms Smith";
    if (std::regex_search(s, m, p)) {
        std::cout << "Name: " << m[1] << '\n';
    }
    return 0;
}

Vérifier si un groupe a correspondu

Un groupe facultatif peut ne pas participer à une correspondance. Testez matched sur la sous-correspondance pour vérifier s'il a capturé quelque chose.

#include <iostream>
#include <regex>

int main() {
    std::regex p("file(\\.txt)?");
    std::smatch m;
    std::string s = "file";
    if (std::regex_match(s, m, p)) {
        std::cout << std::boolalpha << "ext matched: " << m[1].matched << '\n';
    }
    return 0;
}

Parcourir toutes les correspondances

std::sregex_iterator parcourt chaque correspondance d'une chaîne et vous fournit chaque groupe au passage.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\d+)");
    std::string s = "a1 b22 c333";
    auto begin = std::sregex_iterator(s.begin(), s.end(), p);
    auto end = std::sregex_iterator();
    for (auto it = begin; it != end; ++it) {
        std::cout << (*it)[1] << '\n';
    }
    return 0;
}

Compter les correspondances

Combinez l'itérateur avec std::distance pour compter le nombre d'occurrences d'un motif.

#include <iostream>
#include <regex>

int main() {
    std::regex p("\\d+");
    std::string s = "1 22 333 4444";
    auto begin = std::sregex_iterator(s.begin(), s.end(), p);
    auto end = std::sregex_iterator();
    std::cout << "Count: " << std::distance(begin, end) << '\n';
    return 0;
}

Extraire des paires clé-valeur

Deux groupes par correspondance vous permettent d'analyser du texte structuré simple, comme des éléments key=value.

#include <iostream>
#include <regex>

int main() {
    std::regex p("(\\w+)=(\\w+)");
    std::string s = "a=1 b=2 c=3";
    auto begin = std::sregex_iterator(s.begin(), s.end(), p);
    auto end = std::sregex_iterator();
    for (auto it = begin; it != end; ++it) {
        std::cout << (*it)[1] << " -> " << (*it)[2] << '\n';
    }
    return 0;
}

Stocker les captures

Copiez une sous-correspondance capturée dans un std::string avec str() afin que les données restent valides après la destruction de l'objet de correspondance.

#include <iostream>
#include <regex>
#include <string>

int main() {
    std::regex p("v(\\d+)");
    std::smatch m;
    std::string s = "version v7";
    std::string version;
    if (std::regex_search(s, m, p)) {
        version = m[1].str();
    }
    std::cout << "Stored: " << version << '\n';
    return 0;
}

Vérification rapide

Vérifiez votre compréhension de l'indexation des groupes capturants.

Bilan

Vous avez appris à extraire des données avec des groupes capturants :

les parenthèses capturent ; (?:...) regroupe sans capturer
smatch[0] représente la correspondance complète, et [1]+ les groupes
str(), position(), length(), prefix(), suffix()
sregex_iterator parcourt toutes les correspondances

Ensuite, vous transformerez du texte à l'aide de la recherche et du remplacement.

Questions Fréquemment Posées

La leçon « Groupes de capture » est-elle gratuite ?

Oui — le texte complet de « Groupes de capture » 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 « Groupes de capture » ?

Extraire les parties correspondantes 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 2 sur 4.

Combien de temps prend la leçon « Groupes de capture » ?

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