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

CKTIS / C++

`= default` — funções explicitamente definidas por omissão em C++

`= default` pede ao compilador que forneça a definição padrão de uma função elegível. A propriedade de recursos, PImpl e os destrutores virtuais mostram a sua utilidade.

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

Sintaxe

struct T {
    T() = default;
    T(const T&) = default;
    T(T&&) = default;
    T& operator=(const T&) = default;
    T& operator=(T&&) = default;
    ~T();
    bool operator==(const T&) const = default;
};
T::~T() = default;

Em C++23, = default; é uma definição explícita por omissão, não uma atribuição nem uma etiqueta default: de switch. Aplica-se a funções membro especiais (desde C++11) e a operadores de comparação elegíveis (desde C++20), como bool operator==(const T&) const = default;. Não se aplica a uma função qualquer e não admite argumentos por omissão. O suporte pode variar consoante a implementação.

Uma função com = default na primeira declaração é declarada pelo utilizador, mas não fornecida pelo utilizador (user-provided). Uma definição posterior como T::~T() = default; é user-provided, o que pode afetar o seu carácter trivial. Se um membro ou uma classe base impedir a operação pretendida, a função pode ser definida como eliminada. Se isso acontecer ao usar = default após a primeira declaração, o programa fica malformado.

Em const T&, & declara uma referência para lvalue; em T&&, && declara uma referência para rvalue. São tipos de parâmetros típicos para cópia e movimento. = delete proíbe explicitamente o uso de uma função: se a resolução de sobrecarga a selecionar, a chamada fica malformada. Não é uma expressão delete, que serve para destruir um objeto e libertar a sua memória. Um tipo que contém um std::future pode mover o identificador do estado partilhado, mas não pode copiá-lo membro a membro.

Com PImpl, declara Impl sem o definir no ficheiro de cabeçalho e guarda um std::unique_ptr<Impl>. O eliminador por omissão exige que Impl seja um tipo completo, pelo que deves definir o destrutor fora da classe, depois da definição de Impl. Um destrutor declarado pelo utilizador impede a declaração implícita das duas operações de movimento; se forem necessárias, declara-as e define-as também nesse ponto com = default. A atribuição por movimento pode eliminar o Impl anterior do destino. std::unique_ptr não é copiável e a lista de inicialização do construtor inicializa o membro proprietário.

Numa interface polimórfica de estratégia, = 0 assinala uma função virtual pura. Já virtual ~Strategy() = default; define um destrutor virtual público que permite destruir corretamente um objeto derivado através de std::unique_ptr<Strategy>. O código chamador injeta a estratégia através do construtor. Um registo de fábricas pode associar nomes a fábricas de estratégias já compiladas e ligadas ao programa, sem carregar bibliotecas dinâmicas.

Exemplos

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

struct Strategy {
    virtual ~Strategy() = default;
    virtual int apply(int value) const = 0;
};

struct Double final : Strategy {
    int apply(int value) const override { return 2 * value; }
};

class Task {
public:
    explicit Task(std::unique_ptr<Strategy> strategy);
    ~Task();
    Task(Task&&) noexcept;
    Task& operator=(Task&&) noexcept;
    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;
    int run() const;

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

struct Task::Impl {
    explicit Impl(std::unique_ptr<Strategy> s) : strategy(std::move(s)) {}
    std::unique_ptr<Strategy> strategy;
};

Task::Task(std::unique_ptr<Strategy> s)
    : impl_(std::make_unique<Impl>(std::move(s))) {}
Task::~Task() = default;
Task::Task(Task&&) noexcept = default;
Task& Task::operator=(Task&&) noexcept = default;

int Task::run() const {
    if (!impl_ || !impl_->strategy) {
        throw std::logic_error("no strategy");
    }
    return impl_->strategy->apply(21);
}

int main() {
    Task original(std::make_unique<Double>());
    Task owner(std::move(original));
    std::cout << owner.run() << '\n';
}

Resultado

42

`main` injeta `Double` e o construtor de movimento definido por omissão transfere a propriedade de `Impl` de `original` para `owner`. A chamada virtual a `Double::apply(21)` produz `42`. O exemplo não copia o objeto nem chama `run()` sobre o objeto de origem após o movimento.

Lições relacionadas

  • C++ · Lição 45 · Avançado · Versão: 3
  • C++ · Lição 57 · Avançado · Versão: 3
  • C++ · Lição 59 · Avançado · Versão: 3

Fontes