CKTIS / C++
Objectmodel en compositie in C++
Een object heeft een type, opslagruimte en levensduur; het kan member- en basisklasse-subobjecten bevatten. Compositie verbindt objecten via members, terwijl overerving een gedeelde interface mogelijk maakt. De taal bepaalt de volgorde van initialisatie en vernietiging.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
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();Een object neemt opslagruimte in en heeft een levensduur. Een volledig object is geen subobject van een ander object. In het voorbeeld bevat Whole een basisklasse-subobject Base en een member Part part. De member staat voor compositie („heeft een onderdeel”), terwijl de basis voor overerving staat. Alleen een pointer naar een ander object hebben, maakt dat object niet tot een subobject van de eigenaar van de pointer.
Een member-initialisatielijst, zoals : part{n}, initialiseert de member voordat de constructorbody wordt uitgevoerd; het is geen toewijzing. Virtuele basisklassen worden als eerste geïnitialiseerd, en alleen door de constructor van de meest afgeleide klasse. Daarna volgen de directe niet-virtuele basisklassen en vervolgens de members in declaratievolgorde. De constructorbody wordt als laatste uitgevoerd. De volgorde van de vermeldingen in de lijst veranderen, verandert die volgorde niet.
Een destructordeclaratie heeft de vorm ~Part();; een destructor neemt geen argumenten en heeft geen returntype. Na de body worden members en basisklassen vernietigd in de omgekeerde volgorde waarin hun constructie is voltooid. Een virtuele destructor, zoals virtual ~Base(), maakt het mogelijk een afgeleid object correct te vernietigen met delete op een pointer naar de basis. Bij gewone deallocatie leidt het ontbreken van zo’n destructor tot ongedefinieerd gedrag.
Een pure virtuele functie, virtual int value() const = 0;, gebruikt de = 0 pure-specifier, geen toewijzing. Base is abstract: er kunnen geen volledige objecten van die klasse worden gemaakt. Whole::value() levert de implementatie. Een destructor kan ook puur virtueel zijn, maar heeft nog steeds een definitie nodig wanneer afgeleide objecten worden gemaakt.
Een expliciete destructoraanroep, zoals p->~Whole();, beëindigt de levensduur van het object, maar maakt de opslagruimte niet zelf vrij. Gebruik dit niet voor een gewoon lokaal object: latere automatische vernietiging zonder het object correct opnieuw te creëren leidt tot ongedefinieerd gedrag. Het voorbeeld gebruikt automatische vernietiging. Het toepassingsgebied is C++23; de opgegeven standaard-URL bevat een voortschrijdend concept, niet de vastgestelde C++23-tekst. Een compileroptie in de repository garandeert niets over de productieomgeving.
Voorbeelden
#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';
}
Resultaat
Part+ Whole+ 7 Whole- Part- Base-
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.