Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

`= default` — funciones definidas explícitamente por defecto en C++

`= default` pide al compilador la definición estándar de una función que admite esta sintaxis. La propiedad de recursos, PImpl y los destructores virtuales ilustran su utilidad.

Versión: ISO C++23; implementation support may vary

Sintaxis

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;

En C++23, = default; es una definición explícita por defecto, no una asignación ni una etiqueta default: de switch. Se aplica a funciones miembro especiales (desde C++11) y a operadores de comparación admitidos (desde C++20), como bool operator==(const T&) const = default;. No se puede usar con una función cualquiera ni con argumentos predeterminados. La compatibilidad puede variar según la implementación.

Una función con = default en su primera declaración la declara el usuario, pero no la proporciona (user-provided). Una definición posterior como T::~T() = default; sí es user-provided, lo que puede afectar a su trivialidad. Si un miembro o una base impide la operación requerida, la función puede quedar definida como eliminada. Si eso sucede al usar = default después de la primera declaración, el programa está mal formado.

En const T&, & declara una referencia a lvalue; en T&&, && declara una referencia a rvalue. Son tipos de parámetros habituales para copia y movimiento. = delete prohíbe expresamente usar una función: si la resolución de sobrecarga la selecciona, la llamada está mal formada. No es una expresión delete, que sirve para destruir un objeto y liberar su memoria. Un tipo que contiene un std::future puede mover el identificador del estado compartido, pero no puede copiarlo miembro a miembro.

Con PImpl, declara Impl sin definirlo en la cabecera y almacena un std::unique_ptr<Impl>. El eliminador predeterminado necesita que Impl sea un tipo completo, así que define el destructor fuera de la clase, después de la definición de Impl. Un destructor declarado por el usuario impide la declaración implícita de ambas operaciones de movimiento; si las necesitas, decláralas y defínelas allí también con = default. La asignación por movimiento puede eliminar el Impl anterior del destino. std::unique_ptr no se puede copiar y la lista de inicialización del constructor inicializa el miembro propietario.

En una interfaz polimórfica de estrategia, = 0 marca una función virtual pura. En cambio, virtual ~Strategy() = default; define un destructor virtual público para que un objeto derivado se destruya correctamente a través de std::unique_ptr<Strategy>. El código llamante inyecta la estrategia mediante el constructor. Un registro de fábricas puede asociar nombres con fábricas de estrategias ya compiladas y enlazadas al programa, sin cargar bibliotecas dinámicas.

Ejemplos

#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` inyecta `Double` y el constructor de movimiento definido por defecto transfiere la propiedad de `Impl` de `original` a `owner`. La llamada virtual a `Double::apply(21)` produce `42`. El ejemplo no copia el objeto ni llama a `run()` sobre el objeto de origen tras el movimiento.

Lecciones relacionadas

  • C++ · Lección 45 · Avanzado · Versión: 3
  • C++ · Lección 57 · Avanzado · Versión: 3
  • C++ · Lección 59 · Avanzado · Versión: 3

Fuentes