KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Verwijderde kopieerfuncties (`= delete`) en een standaard gedefinieerde virtuele destructor (`= default`)

Schakel kopieerconstructie en kopieertoewijzing afzonderlijk uit en laat de compiler een virtuele destructor definiëren voor correcte vernietiging via een basisklassepointer.

Versie: ISO C++23; implementation support may vary

Syntax

struct Base {
    Base() = default;
    Base(const Base&) = delete;
    Base& operator=(const Base&) = delete;
    virtual ~Base() = default;
};

Base(const Base&) = delete; voorkomt dat je een nieuw Base-object maakt door te kopiëren. Base& operator=(const Base&) = delete; voorkomt kopieertoewijzing aan een bestaand object. Beide functies doen nog mee aan overloadresolutie. Als je een van beide verwijderde functies rechtstreeks in het voorbeeld gebruikt, is het programma ongeldig en moet de compiler een diagnose geven. Als bij het invullen van templateargumenten een verwijderde functie wordt geselecteerd en daardoor een afhankelijke eis ongeldig wordt, kan de requires-expressie daarentegen false opleveren zonder diagnose. = delete geeft geen geheugen vrij.

In virtual ~Base() = default; zorgt virtual voor dynamische aanroep en vraagt = default de compiler om de gebruikelijke destructordefinitie te leveren. Die vernietigt nog steeds members en basisklassesubobjecten; = default betekent niet dat de destructor niets doet en is niet hetzelfde als = 0. Als een member een verwijderde destructor heeft, kan de standaard gedefinieerde destructor van de klasse zelf als verwijderd worden gedefinieerd.

Bij een gewone delete p voor één object, waarbij Base* p wijst naar een met new gemaakte Derived, zorgt de dynamische aanroep ervoor dat eerst ~Derived() draait en daarna ~Base(). Zonder virtuele destructor in de basisklasse zou het gedrag in dit geval ongedefinieerd zijn. Deze regel maakt het niet veilig om delete[] te gebruiken op een array van afgeleide objecten via een basisklassepointer.

De verwijderde kopieerconstructor telt nog steeds als door de programmeur gedeclareerd. Daarom voegt het voorbeeld expliciet Base() = default; toe. De gedeclareerde kopieeroperaties en destructor verhinderen ook dat de move-constructor en move-toewijzingsoperator van Base impliciet worden gedeclareerd. Kopiëren uitschakelen levert dus niet vanzelf een type op dat alleen verplaatsbaar is. De regels zijn beschreven voor ISO C++23; de ondersteuning kan per implementatie verschillen.

Voorbeelden

#include <iostream>
#include <type_traits>

struct Base {
    Base() = default;
    Base(const Base&) = delete;
    Base& operator=(const Base&) = delete;
    virtual ~Base() = default;
};

struct Derived final : Base {
    ~Derived() override {
        std::cout << "Derived destroyed\n";
    }
};

static_assert(!std::is_copy_constructible_v<Base>);
static_assert(!std::is_copy_assignable_v<Base>);

int main() {
    Base* p = new Derived;
    delete p;

    // Base a, b;
    // Base c(a);
    // b = a;
}

Resultaat

Derived destroyed

De `static_assert`-instructies controleren dat beide kopieeroperaties niet beschikbaar zijn. `delete p` voert de destructor van `Derived` uit, die `Derived destroyed` afdrukt, en daarna die van `Base`, die niets afdrukt. Haal `Base a, b;` uit het commentaar en test `Base c(a);` en `b = a;` afzonderlijk: beide moeten elk een compilatiefout opleveren.

Gerelateerde lessen

  • C++ · Les 55 · Gemiddeld · Versie: 2

Bronnen