C++ Academy · Lezione

Algoritmi per stringhe

Cercare e suddividere in modo efficiente

Algoritmi per stringhe è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Cercare con find

find restituisce l'indice di una sottostringa oppure npos se non è presente, operando direttamente su una view senza effettuare copie.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "key=value";
    auto pos = sv.find('=');
    std::cout << pos << "\n"; // 3
}

Verificare npos

Confronti sempre il risultato di una ricerca con std::string_view::npos prima di utilizzarlo come indice.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "abc";
    if (sv.find('z') == std::string_view::npos)
        std::cout << "not found\n";
}

Verificare prefissi e suffissi

starts_with e ends_with (C++20) rendono evidente l'intento ed evitano confronti manuali tra sottostringhe.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "report.pdf";
    std::cout << sv.starts_with("report") << "\n";
    std::cout << sv.ends_with(".pdf") << "\n";
}

Estrarre un campo

Combini find con substr per dividere una coppia chiave/valore senza allocare nuove stringhe.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "name=Ada";
    auto eq = sv.find('=');
    std::cout << sv.substr(0, eq) << " : " << sv.substr(eq + 1) << "\n";
}

Dividere usando un delimitatore

Può scorrere i token cercando ripetutamente il delimitatore e creando sottoview; ogni token è semplicemente una view.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "a,b,c";
    size_t start = 0, pos;
    while ((pos = sv.find(',', start)) != std::string_view::npos) {
        std::cout << sv.substr(start, pos - start) << "\n";
        start = pos + 1;
    }
    std::cout << sv.substr(start) << "\n";
}

Cercare dalla fine

rfind esegue la ricerca all'indietro ed è utile per ottenere l'estensione di un file o l'ultimo separatore.

#include <iostream>
#include <string_view>
int main() {
    std::string_view path = "/usr/local/bin";
    auto slash = path.rfind('/');
    std::cout << path.substr(slash + 1) << "\n"; // bin
}

Rimuovere gli spazi bianchi

Usi find_first_not_of e find_last_not_of insieme a remove_prefix/remove_suffix per rimuovere gli spazi, senza effettuare copie.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "  hi  ";
    sv.remove_prefix(sv.find_first_not_of(" "));
    sv.remove_suffix(sv.size() - 1 - sv.find_last_not_of(" "));
    std::cout << "[" << sv << "]\n"; // [hi]
}

Confrontare le view

Le view supportano == e compare per il confronto lessicografico, confrontando i caratteri e non i puntatori.

#include <iostream>
#include <string_view>
int main() {
    std::string_view a = "apple", b = "apple";
    std::cout << (a == b) << "\n"; // 1
}

Contare le occorrenze

Un ciclo con find che avanza oltre ogni corrispondenza consente di contare quante volte compare un carattere o una sottostringa.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "mississippi";
    int count = 0;
    for (size_t p = sv.find('s'); p != std::string_view::npos; p = sv.find('s', p + 1)) ++count;
    std::cout << count << "\n"; // 4
}

Algoritmi senza allocazioni

Tutte queste operazioni lavorano sullo stesso buffer sottostante. I token e i risultati ottenuti rimuovendo gli spazi sono sottoview; non avviene alcuna allocazione sull'heap finché non si costruisce una std::string.

Attenzione ai cicli di vita

Le sottoview prodotte da questi algoritmi condividono il ciclo di vita del buffer originale. Non permetta che sopravvivano alla stringa sorgente.

Verifica rapida

Verifichi la propria comprensione degli algoritmi per string_view.

Riepilogo

Ha imparato gli algoritmi per stringhe applicati alle view:

find/rfind restituiscono posizioni oppure npos.
starts_with/ends_with verificano prefissi e suffissi.
La suddivisione, la rimozione degli spazi e la tokenizzazione producono sottoview senza allocazioni.
Le sottoview condividono il ciclo di vita della sorgente: presti attenzione alle view pendenti.

Domande Frequenti

La lezione «Algoritmi per stringhe» è gratuita?

Sì — il testo completo di «Algoritmi per stringhe» è 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 «Algoritmi per stringhe»?

Cercare e suddividere in modo efficiente 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 4 di 4.

Quanto tempo richiede la lezione «Algoritmi per stringhe»?

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