Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

Cópia desativada (`= delete`) e destrutor virtual por omissão (`= default`)

Impeça separadamente a construção e a atribuição por cópia e deixe o compilador definir um destrutor virtual para destruir objetos através de um ponteiro para a classe base.

Versão: ISO C++23; implementation support may vary

Sintaxe

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

Base(const Base&) = delete; impede a construção por cópia de um novo objeto Base, enquanto Base& operator=(const Base&) = delete; impede a atribuição por cópia a um objeto existente. Ambas as funções continuam a participar na resolução de sobrecargas. A utilização direta de qualquer uma destas funções eliminadas no exemplo torna o programa mal formado e exige um diagnóstico. Já se a seleção de uma função eliminada durante a substituição dos argumentos do modelo invalidar um requisito dependente, a expressão requires pode resultar em false sem que seja emitido um diagnóstico. = delete não liberta memória.

Em virtual ~Base() = default;, virtual permite a ligação dinâmica e = default pede ao compilador que forneça a definição habitual do destrutor. Este continua a destruir os subobjetos membros e de classes base; = default não significa que não faça nada nem equivale a = 0. Se um membro tiver um destrutor eliminado, o próprio destrutor por omissão da classe pode ser definido como eliminado.

Num delete p normal aplicado a um único objeto, se Base* p apontar para um Derived criado com new, a ligação dinâmica garante que se executa primeiro ~Derived() e depois ~Base(). Sem um destrutor virtual na classe base, neste caso o comportamento seria indefinido. Esta regra não permite usar delete[] num array de objetos derivados através de um ponteiro para a classe base.

O construtor de cópia eliminado continua a ser declarado pelo programador, pelo que o exemplo acrescenta explicitamente Base() = default;. As operações de cópia e o destrutor declarados impedem também a declaração implícita do construtor e do operador de atribuição por movimento de Base. Impedir a cópia não basta, portanto, para obter um tipo que só admite movimento. As regras são descritas para ISO C++23; o suporte pode variar consoante a implementação.

Exemplos

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

Resultado

Derived destroyed

As instruções `static_assert` verificam que as duas operações de cópia estão indisponíveis. `delete p` executa o destrutor de `Derived`, que escreve `Derived destroyed`, e depois o de `Base`, que nada escreve. Retire o comentário de `Base a, b;` e teste `Base c(a);` e `b = a;` separadamente: cada instrução deve provocar um erro de compilação.

Lições relacionadas

  • C++ · Lição 55 · Intermédio · Versão: 2

Fontes