Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Copia disabilitata (`= delete`) e distruttore virtuale predefinito (`= default`)

Disabilita separatamente la costruzione e l’assegnazione per copia e lascia al compilatore la definizione di un distruttore virtuale per distruggere oggetti tramite un puntatore alla base.

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

Sintassi

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

Base(const Base&) = delete; impedisce di costruire un nuovo oggetto Base per copia, mentre Base& operator=(const Base&) = delete; impedisce di assegnare per copia a un oggetto esistente. Entrambe le funzioni continuano a partecipare alla risoluzione dell’overload. Usare direttamente una delle due funzioni eliminate nell’esempio rende il programma mal formato e richiede un messaggio diagnostico. Se invece, durante la sostituzione degli argomenti del template, la selezione di una funzione eliminata rende non valido un requisito dipendente, l’espressione requires può dare come risultato false senza alcun messaggio diagnostico. = delete non libera memoria.

In virtual ~Base() = default;, virtual abilita il dispatch dinamico e = default chiede al compilatore di fornire la normale definizione del distruttore. Il distruttore continua a distruggere i sotto-oggetti membri e delle classi base; = default non significa che non faccia nulla e non equivale a = 0. Se un membro ha un distruttore eliminato, anche il distruttore predefinito della classe può essere definito come eliminato.

Con il normale delete p su un singolo oggetto, se Base* p punta a un Derived creato con new, il dispatch dinamico fa eseguire prima ~Derived() e poi ~Base(). Senza un distruttore virtuale nella classe base, in questo caso il comportamento sarebbe indefinito. Questa regola non consente di usare delete[] su un array di oggetti derivati tramite un puntatore alla base.

Il costruttore di copia eliminato rimane dichiarato dall’utente, quindi l’esempio aggiunge esplicitamente Base() = default;. Le operazioni di copia e il distruttore dichiarati impediscono inoltre la dichiarazione implicita del costruttore e dell’operatore di assegnazione per spostamento di Base. Disabilitare la copia non basta quindi a ottenere un tipo che supporta solo lo spostamento. Le regole sono descritte per ISO C++23; il supporto può variare a seconda dell’implementazione.

Esempi

#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;
}

Risultato

Derived destroyed

Le istruzioni `static_assert` verificano che entrambe le operazioni di copia non siano disponibili. `delete p` esegue il distruttore di `Derived`, che stampa `Derived destroyed`, poi quello di `Base`, che non stampa nulla. Togli il commento da `Base a, b;` e prova `Base c(a);` e `b = a;` separatamente: ciascuna istruzione deve provocare un errore di compilazione.

Lezioni correlate

  • C++ · Lezione 55 · Intermedio · Versione: 2

Fonti