CKTIS / C++
Modello degli oggetti e composizione in C++
Un oggetto ha un tipo, memoria e una durata; può contenere sotto-oggetti membro e di classe base. La composizione collega gli oggetti tramite membri, mentre l’ereditarietà consente un’interfaccia condivisa. Il linguaggio stabilisce l’ordine di inizializzazione e distruzione.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
struct Base { virtual ~Base() = default; virtual int value() const = 0; };
struct Part { int n; };
struct Whole : Base {
Part part;
explicit Whole(int n) : part{n} {}
~Whole() override = default;
int value() const override { return part.n; }
};
// Explicit destructor call: p->~Whole();Un oggetto occupa memoria e ha una durata. Un oggetto completo non è un sotto-oggetto di un altro oggetto. Nell’esempio, Whole contiene un sotto-oggetto della classe base Base e un membro Part part. Il membro rappresenta la composizione («ha una parte»), mentre la base rappresenta l’ereditarietà. Il semplice fatto di avere un puntatore a un altro oggetto non rende quell’oggetto un sotto-oggetto del proprietario del puntatore.
Una lista di inizializzazione dei membri, come : part{n}, inizializza il membro prima che venga eseguito il corpo del costruttore; non è un’assegnazione. Le basi virtuali vengono inizializzate per prime, esclusivamente dal costruttore della classe più derivata. Seguono le basi dirette non virtuali e poi i membri nell’ordine di dichiarazione. Il corpo del costruttore viene eseguito per ultimo. Riordinare le voci della lista non cambia quest’ordine.
Una dichiarazione di distruttore ha la forma ~Part();; un distruttore non accetta argomenti e non ha tipo di ritorno. Dopo il suo corpo, i membri e le basi vengono distrutti nell’ordine inverso rispetto al completamento della loro costruzione. Un distruttore virtuale, come virtual ~Base(), consente la corretta distruzione di un oggetto derivato tramite delete su un puntatore alla base. In caso di deallocazione ordinaria, l’assenza di un distruttore simile causa comportamento indefinito.
Una funzione virtuale pura, virtual int value() const = 0;, usa lo specificatore di purezza = 0, non un’assegnazione. Base è astratta: non si possono creare oggetti completi di questa classe. Whole::value() fornisce l’implementazione. Anche un distruttore può essere virtuale puro, ma richiede comunque una definizione quando vengono creati oggetti derivati.
Una chiamata esplicita al distruttore, come p->~Whole();, termina la durata dell’oggetto, ma non libera da sola la memoria. Non usarla con un normale oggetto locale: una successiva distruzione automatica senza ricreare correttamente l’oggetto causa comportamento indefinito. L’esempio usa la distruzione automatica. L’ambito è C++23; l’URL dello standard fornito ospita una bozza in evoluzione, non il testo definitivo di C++23. Un’opzione del compilatore nel repository non certifica l’ambiente di produzione.
Esempi
#include <iostream>
struct Part {
int n;
explicit Part(int x) : n{x} { std::cout << "Part+\n"; }
~Part() { std::cout << "Part-\n"; }
};
struct Base {
virtual ~Base() { std::cout << "Base-\n"; }
virtual int value() const = 0;
};
struct Whole : Base {
Part part;
explicit Whole(int n) : part{n} { std::cout << "Whole+\n"; }
~Whole() override { std::cout << "Whole-\n"; }
int value() const override { return part.n; }
};
int main() {
Whole object{7};
const Base& view = object;
std::cout << view.value() << '\n';
}
Risultato
Part+ Whole+ 7 Whole- Part- Base-
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.