C++ Academy · Lezione

Gruppi di cattura

Estrarre le parti corrispondenti

Gruppi di cattura è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Che cos'è un gruppo di cattura?

Le parentesi in un pattern creano un gruppo di cattura, memorizzando la parte di testo a cui corrispondono, così potrete estrarla in seguito.

(\\d+) cattura una sequenza di cifre.
I risultati vengono memorizzati in 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;
}

Il risultato smatch

std::smatch memorizza i risultati del matching. L'indice [0] rappresenta l'intera corrispondenza, mentre [1], [2], ... rappresentano i gruppi di cattura nell'ordine.

#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;
}

Più gruppi

Potete catturare più parti contemporaneamente, ad esempio suddividendo una data in anno, mese e giorno.

#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()

Ogni gruppo offre str() per il testo, position() per l'offset e length() per la lunghezza all'interno dell'input.

#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;
}

Prefisso e suffisso

L'oggetto match espone anche prefix() (il testo prima della corrispondenza) e suffix() (il testo successivo).

#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;
}

Gruppi non catturanti

Utilizzate (?:...) per raggruppare senza catturare. In questo modo i gruppi numerati restano significativi quando vi serve il raggruppamento solo per i quantificatori o l'alternanza.

#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;
}

Verificare se un gruppo ha trovato una corrispondenza

Un gruppo opzionale potrebbe non partecipare a una corrispondenza. Verificate matched sul sottomatch per sapere se ha catturato qualcosa.

#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;
}

Iterare su tutte le corrispondenze

std::sregex_iterator attraversa ogni corrispondenza in una stringa, fornendovi anche ciascun gruppo.

#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;
}

Contare le corrispondenze

Combinate l'iteratore con std::distance per contare quante volte compare un pattern.

#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;
}

Estrarre coppie chiave-valore

Due gruppi per ogni corrispondenza consentono di analizzare testo strutturato semplice, come i token 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;
}

Memorizzare le catture

Copiate un sottomatch catturato in una std::string con str(), così i dati rimarranno validi anche dopo la distruzione dell'oggetto match.

#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;
}

Verifica rapida

Verificate la vostra comprensione dell'indicizzazione dei gruppi di cattura.

Riepilogo

Avete imparato a estrarre dati con i gruppi di cattura:

le parentesi catturano; (?:...) raggruppa senza catturare
smatch[0] rappresenta l'intera corrispondenza, mentre [1]+ rappresenta i gruppi
str(), position(), length(), prefix(), suffix()
sregex_iterator attraversa ogni corrispondenza

Ora trasformerete il testo utilizzando la ricerca e la sostituzione.

Domande Frequenti

La lezione «Gruppi di cattura» è gratuita?

Sì — il testo completo di «Gruppi di cattura» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Gruppi di cattura»?

Estrarre le parti corrispondenti Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Gruppi di cattura»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy