C++ Academy · Lezione

Insidie e durata degli oggetti

Evitare viste pendenti

Lezione 3 di 413 passaggi

Insidie e durata degli oggetti è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Le view non possiedono i dati

Una string_view punta soltanto a caratteri posseduti altrove. Se quell'area di memoria scompare, la view rimane pendente e accedervi produce un comportamento indefinito.

View pendente da un temporaneo

Associare una view a una std::string temporanea è pericoloso: il temporaneo viene distrutto al termine dell'istruzione, lasciando la view puntata a memoria già liberata.

#include <string>
#include <string_view>
std::string make() { return "temp"; }
int main() {
    std::string_view sv = make(); // dangles immediately
    // using sv here is undefined behavior
    (void)sv;
}

Non restituisca una view locale

Non restituisca mai una view che punta all'interno di una stringa locale: la variabile locale viene distrutta quando la funzione restituisce il controllo.

#include <string>
#include <string_view>
std::string_view bad() {
    std::string local = "oops";
    return local; // local dies, view dangles
}
int main() { (void)bad(); }

Sicuro: view di una stringa ancora valida

Una view è sicura finché la sorgente rimane valida più a lungo della view. In questo caso la stringa resta in vita per tutta la durata della funzione.

#include <iostream>
#include <string>
#include <string_view>
int main() {
    std::string s = "alive";
    std::string_view sv = s;
    std::cout << sv << "\n"; // safe
}

Non termina con il carattere nullo

Non è garantito che i dati di una view terminino con \0. Passare sv.data() a una funzione C che si aspetta una stringa C può causare una lettura oltre la fine.

Usi size(), non strlen

Si affidi sempre a sv.size() per ottenere la lunghezza, invece che alle funzioni per stringhe C, perché una view può essere una sezione di un buffer più grande.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = std::string_view("hello world").substr(0, 5);
    std::cout << sv.size() << "\n"; // 5, not 11
}

Modificare la sorgente

Se la stringa sottostante viene riallocata, ad esempio perché push_back ne aumenta la capacità, le view esistenti al suo interno diventano non valide.

Memorizzare view nei membri

Presti attenzione quando memorizza una string_view come membro di una classe: deve garantire che i dati referenziati rimangano validi più a lungo dell'oggetto. In caso di dubbio, memorizzi invece una std::string.

I parametri sono generalmente sicuri

Usare string_view come parametro di una funzione è il caso sicuro e idiomatico: l'argomento rimane valido per tutta la durata della chiamata.

#include <iostream>
#include <string_view>
size_t len(std::string_view sv) { return sv.size(); }
int main() {
    std::cout << len("temporary is fine here") << "\n";
}

Copi quando devi conservare

Se deve conservare il testo oltre la durata di vita della sorgente, lo copi in una std::string. La copia è il prezzo della proprietà dei dati.

#include <string>
#include <string_view>
std::string keep(std::string_view sv) {
    return std::string(sv); // owns a copy
}
int main() { (void)keep("persist"); }

Regola pratica

Preferisca string_view per i parametri e le variabili locali di breve durata. Eviti di usarla come tipo restituito o come membro di lunga durata, a meno che sia chiaro che i dati resteranno validi più a lungo.

Verifica rapida

Verifichi la propria comprensione della durata di vita delle view.

Rispondi nella lezione interattiva

Riepilogo

Ha imparato i problemi e i cicli di vita delle view:

Le view non possiedono i dati; la sorgente deve rimanere valida più a lungo della view.
Eviti le view di temporanei e variabili locali.
Non è garantito che le view terminino con il carattere nullo; usi size().
Copi in una std::string quando deve conservare il testo.

Gratis per iniziare

Impara C++ con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 51
Lezioni: 203

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Insidie e durata degli oggetti» è gratuita?

Sì — il testo completo di «Insidie e durata degli oggetti» è 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 «Insidie e durata degli oggetti»?

Evitare viste pendenti 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 3 di 4.

Quanto tempo richiede la lezione «Insidie e durata degli oggetti»?

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