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

CKTIS / C++

Funções membro especiais com `= default` em C++

Em C++23, `= default` pede ao compilador a definição padrão de uma função membro especial. Com Pimpl, o local da definição é importante; o suporte para C++23 pode variar consoante a implementação.

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

Sintaxe

struct S {
    S() = default;
    S(const S&) = default;
    S(S&&) = default;
    S& operator=(const S&) = default;
    S& operator=(S&&) = default;
    ~S();
};

S::~S() = default;

= default pede ao compilador que defina, segundo as regras da linguagem, um construtor predefinido, um construtor de cópia ou de movimento, um operador de atribuição por cópia ou por movimento ou um destrutor. Não é um corpo vazio {}: a função gerada aplica as regras da operação aos subobjetos das classes base e aos membros de dados não estáticos.

Se = default constar da primeira declaração, a função é declarada pelo utilizador, mas não é user-provided no sentido da norma. Pode ser trivial se as restantes condições forem cumpridas, ou ser definida como eliminada se uma operação necessária sobre um subobjeto não estiver disponível. Se = default só aparecer numa definição posterior, a função é user-provided e não é trivial. Se a definição gerada tivesse de ser eliminada, o programa estaria malformado.

= delete é diferente: uma sobrecarga eliminada continua a participar na resolução de sobrecargas, mas selecioná-la é um erro. Não é uma expressão delete p e não liberta memória. Um destrutor declarado pelo utilizador, mesmo com = default, impede a declaração implícita das operações de movimento. Por isso, Widget declara ambas explicitamente e elimina as duas operações de cópia.

Com Pimpl, o ficheiro de cabeçalho pode declarar antecipadamente Impl e conter um std::unique_ptr<Impl>. O eliminador predefinido exige, porém, que Impl seja um tipo completo: o destrutor pode eliminar o objeto detido e a atribuição por movimento pode eliminar o objeto anterior do destino. Declare as funções no cabeçalho e defina o destrutor e as duas operações de movimento com = default no ficheiro de implementação, após a definição de Impl. Mover o ponteiro, por si só, não elimina o objeto; contudo, uma exceção durante a construção pode exigir a destruição de subobjetos. Por isso, o construtor de movimento também fica nesse ficheiro.

Exemplos

#include <iostream>
#include <memory>
#include <utility>

class Widget {
public:
    explicit Widget(int value);
    ~Widget();

    Widget(const Widget&) = delete;
    Widget& operator=(const Widget&) = delete;

    Widget(Widget&&) noexcept;
    Widget& operator=(Widget&&) noexcept;

    int value() const noexcept;

private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};

struct Widget::Impl {
    int value;
};

Widget::Widget(int value) : impl_(std::make_unique<Impl>(Impl{value})) {}
Widget::~Widget() = default;
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;

int Widget::value() const noexcept {
    return impl_ ? impl_->value : -1;
}

int main() {
    Widget source(42);
    Widget intermediate(std::move(source));
    Widget target(7);
    target = std::move(intermediate);

    std::cout << target.value() << '\n'
              << source.value() << '\n'
              << intermediate.value() << '\n';
}

Resultado

42
-1
-1

Um único ficheiro reproduz a separação entre o cabeçalho e a implementação. A construção e a subsequente atribuição por movimento transferem para `target` o objeto com `42`, substituindo o objeto com `7`. Os dois ponteiros de origem ficam vazios, pelo que `value()` devolve `-1` para cada um.

Lições relacionadas

  • C++ · Lição 11 · Avançado · Versão: 3

Fontes