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
- WG21 N4950 — Working Draft, Standard for Programming Language C++ (C++23)
- Explicitly-defaulted functions [dcl.fct.def.default]
- Deleted definitions [dcl.fct.def.delete]
- Constructors [class.ctor]
- Copy/move assignment operator [class.copy.assign]
- Defaulted comparison operator functions [class.compare.default]
- Class template future [futures.unique.future]
- Default deleter [unique.ptr.dltr.dflt]
- GotW #7b Solution: Minimizing Compile-Time Dependencies, Part 2
- Abstract classes [class.abstract]
- Delete expressions [expr.delete]