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

CKTIS / C++

Modelo de objetos y composición en C++

Un objeto tiene un tipo, almacenamiento y duración; puede contener subobjetos miembro y de clase base. La composición conecta objetos mediante miembros, mientras que la herencia permite una interfaz común. El lenguaje determina el orden de inicialización y destrucción.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

struct Base { virtual ~Base() = default; virtual int value() const = 0; };
struct Part { int n; };
struct Whole : Base {
    Part part;
    explicit Whole(int n) : part{n} {}
    ~Whole() override = default;
    int value() const override { return part.n; }
};
// Explicit destructor call: p->~Whole();

Un objeto ocupa almacenamiento y tiene una duración. Un objeto completo no es un subobjeto de otro objeto. En el ejemplo, Whole contiene un subobjeto de clase base Base y un miembro Part part. El miembro representa la composición («tiene una parte»), mientras que la base representa la herencia. El mero hecho de tener un puntero a otro objeto no convierte a ese objeto en subobjeto del propietario del puntero.

Una lista de inicialización de miembros, como : part{n}, inicializa el miembro antes de que se ejecute el cuerpo del constructor; no es una asignación. Las bases virtuales se inicializan primero, y solo las inicializa el constructor de la clase más derivada. Después se inicializan las bases directas no virtuales y, a continuación, los miembros en orden de declaración. El cuerpo del constructor se ejecuta al final. Cambiar el orden de las entradas de la lista no modifica ese orden.

Una declaración de destructor tiene la forma ~Part();; un destructor no recibe argumentos ni tiene tipo de retorno. Después de su cuerpo, los miembros y las bases se destruyen en el orden inverso al de finalización de su construcción. Un destructor virtual, como virtual ~Base(), permite destruir correctamente un objeto derivado mediante delete sobre un puntero a la base. Con una desasignación ordinaria, la ausencia de un destructor así provoca comportamiento indefinido.

Una función virtual pura, virtual int value() const = 0;, utiliza el especificador de pureza = 0, no una asignación. Base es abstracta: no se pueden crear objetos completos de esa clase. Whole::value() proporciona la implementación. Un destructor también puede ser virtual puro, pero sigue necesitando una definición cuando se crean objetos derivados.

Una llamada explícita al destructor, como p->~Whole();, termina la duración del objeto, pero no libera el almacenamiento por sí misma. No la uses con un objeto local ordinario: una destrucción automática posterior sin reconstruir correctamente el objeto provoca comportamiento indefinido. El ejemplo utiliza destrucción automática. El ámbito es C++23; la URL del estándar proporcionada contiene un borrador en evolución, no el texto definitivo de C++23. Una opción del compilador en el repositorio no acredita el entorno de producción.

Ejemplos

#include <iostream>

struct Part {
    int n;
    explicit Part(int x) : n{x} { std::cout << "Part+\n"; }
    ~Part() { std::cout << "Part-\n"; }
};

struct Base {
    virtual ~Base() { std::cout << "Base-\n"; }
    virtual int value() const = 0;
};

struct Whole : Base {
    Part part;
    explicit Whole(int n) : part{n} { std::cout << "Whole+\n"; }
    ~Whole() override { std::cout << "Whole-\n"; }
    int value() const override { return part.n; }
};

int main() {
    Whole object{7};
    const Base& view = object;
    std::cout << view.value() << '\n';
}

Resultado

Part+
Whole+
7
Whole-
Part-
Base-

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes