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

CKTIS / C++

Funciones miembro especiales con `= default` en C++

En C++23, `= default` pide al compilador la definición estándar de una función miembro especial. Con Pimpl importa dónde se define; la compatibilidad con C++23 puede variar según la implementación.

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

Sintaxis

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 pide al compilador que defina, según las reglas del lenguaje, un constructor predeterminado, un constructor de copia o de movimiento, un operador de asignación por copia o movimiento, o un destructor. No equivale a un cuerpo vacío {}: la función generada aplica las reglas de la operación a los subobjetos de las clases base y a los miembros de datos no estáticos.

Si = default aparece en la primera declaración, la función está declarada por el usuario, pero no es user-provided en el sentido de la norma. Puede ser trivial si cumple las demás condiciones, o quedar definida como eliminada si no está disponible una operación requerida sobre un subobjeto. Si = default aparece en una definición posterior, la función sí es user-provided y no es trivial. Si la definición generada tuviera que quedar eliminada, el programa estaría mal formado.

= delete es distinto: una sobrecarga eliminada sigue participando en la resolución de sobrecargas, pero seleccionarla es un error. No es una expresión delete p ni libera memoria. Un destructor declarado por el usuario, incluso con = default, impide la declaración implícita de las operaciones de movimiento. Por eso Widget declara ambas explícitamente y elimina las dos operaciones de copia.

Con Pimpl, la cabecera puede declarar Impl por adelantado y contener un std::unique_ptr<Impl>. Sin embargo, el eliminador predeterminado requiere que Impl sea un tipo completo: el destructor puede eliminar el objeto poseído y la asignación por movimiento puede eliminar el objeto anterior del destino. Declara las funciones en la cabecera y define el destructor y ambas operaciones de movimiento con = default en el archivo de implementación, después de definir Impl. Mover el puntero por sí solo no elimina el objeto, pero una excepción durante la construcción puede requerir destruir subobjetos. Por eso también se define allí el constructor de movimiento.

Ejemplos

#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

Un solo archivo reproduce la separación entre cabecera e implementación. La construcción seguida de la asignación por movimiento transfiere a `target` el objeto con `42`, en sustitución del objeto con `7`. Ambos punteros de origen quedan vacíos, por lo que `value()` devuelve `-1` para cada uno.

Lecciones relacionadas

  • C++ · Lección 11 · Avanzado · Versión: 3

Fuentes