C++ Academy · Lezione

Durata degli oggetti

Quando gli oggetti vengono creati e distrutti

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.

Quando nascono gli oggetti

La durata di un oggetto inizia dopo che è stata allocata la memoria che lo ospita e il suo costruttore ha terminato l'esecuzione. Da quel momento l'oggetto è completamente utilizzabile.

#include <iostream>

struct Widget {
    Widget() { std::cout << "born\n"; }
};

int main() {
    Widget w;   // constructor runs here
}

Quando muoiono gli oggetti

La durata termina quando viene eseguito il distruttore. Per un oggetto nello stack, ciò avviene in corrispondenza della graffa di chiusura del suo ambito.

#include <iostream>

struct Widget {
    ~Widget() { std::cout << "dies\n"; }
};

int main() {
    Widget w;
    std::cout << "alive\n";
}   // ~Widget runs here

Ordine di costruzione e distruzione

Gli oggetti vengono distrutti nell'ordine inverso rispetto alla costruzione. L'ultimo creato è il primo a essere eliminato.

#include <iostream>

struct Tag {
    int id;
    Tag(int i) : id(i) { std::cout << "make " << id << "\n"; }
    ~Tag() { std::cout << "drop " << id << "\n"; }
};

int main() {
    Tag a(1);
    Tag b(2);   // dropped before a
}

Durata automatica (stack)

Gli oggetti automatici vivono per tutta la durata del blocco che li contiene. È il modello di durata più comune e sicuro.

Durata dinamica (heap)

Gli oggetti nell'heap creati con new rimangono in vita finché non viene chiamato delete: la loro durata è controllata da lei, non dall'ambito.

#include <iostream>

struct Widget {
    ~Widget() { std::cout << "dies\n"; }
};

int main() {
    Widget* w = new Widget();
    std::cout << "still alive\n";
    delete w;   // destructor runs here
}

Durata statica

Gli oggetti con memoria static vivono per l'intera durata del programma. Una variabile static locale a una funzione viene costruita una sola volta, al primo utilizzo.

#include <iostream>

int next() {
    static int counter = 0;   // built once
    return ++counter;
}

int main() {
    std::cout << next() << next() << next() << "\n";
}

Oggetti temporanei

Un oggetto temporaneo creato in un'espressione di solito muore al termine dell'espressione completa, cioè al punto e virgola.

#include <iostream>
#include <string>

int main() {
    std::cout << (std::string("a") + "b") << "\n";
}   // temporary string dies after this line

I membri vengono costruiti prima del corpo

Gli oggetti membro di una classe vengono costruiti prima dell'esecuzione del corpo del costruttore dell'oggetto che li contiene e distrutti dopo il corpo del suo distruttore.

#include <iostream>
#include <string>

struct Engine { Engine() { std::cout << "engine\n"; } };
struct Car {
    Engine e;
    Car() { std::cout << "car\n"; }
};

int main() { Car c; }

Estensione della durata con un riferimento const

Associare un temporaneo a un const& ne estende la durata fino a farla coincidere con quella del riferimento: una comoda regola del C++.

#include <iostream>
#include <string>

int main() {
    const std::string& s = std::string("hi");
    std::cout << s << "\n";   // s still valid
}

Utilizzo dopo la fine della durata

Accedere a un oggetto dopo la fine della sua durata produce un comportamento indefinito: è il classico bug di dangling reference o use-after-free.

La durata è alla base di RAII

Poiché i distruttori vengono eseguiti in modo deterministico al termine della durata, il C++ collega la pulizia delle risorse alla durata dell'oggetto: è il fondamento di RAII, che verrà approfondito nel corso successivo.

Verifica rapida

Verifichi la sua comprensione della durata degli oggetti.

Riepilogo

Ha imparato che la durata di un oggetto inizia dopo la costruzione e termina con la distruzione. Gli oggetti automatici seguono l'ambito, quelli dinamici seguono new/delete e gli oggetti statici durano per l'intero programma. La distruzione avviene in ordine inverso: è la base di RAII.

Domande Frequenti

La lezione «Durata degli oggetti» è gratuita?

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

Quando gli oggetti vengono creati e distrutti 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 «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