Optimización de base vacía

Permite que el tamaño de un subobjeto base vacío sea cero.

[editar] Explicación

El tamaño de cualquier objeto o subobjeto miembro (a menos que se use el atributo [[no_unique_address]] -- véase abajo) (desde C++20) se requiere que sea al menos 1, incluso si el tipo es un tipo de clase vacío (es decir, una clase o estructura que no tiene datos miembro no estáticos), para poder garantizar que las direcciones de distintos objetos del mismo tipo siempre sean distintas.

Sin embargo, los subobjetos de la clase base no están constreñidos a esto, y pueden optimizarse completamente desde el diseño del objeto:

#include <cassert>
 
struct Base {}; // clase vacía
 
struct Derivada1 : Base 
{
    int i;
};
 
int main()
{
    // el tamaño de cualquier objeto del tipo de clase vacío es al menos 1
    assert(sizeof(Base) >= 1);
 
    // se aplica la optimización de base vacía
    assert(sizeof(Derivada1) == sizeof(int));
}

Se prohíbe la optimización de base vacía si una de las clases base vacías es también el tipo o la base del tipo del primer dato miembro no estático, ya que se requiere que los dos subobjetos base del mismo tipo tengan direcciones diferentes dentro de la representación del objeto del tipo más derivado.

Un ejemplo típico de tal situación es la implementación sencilla de std::reverse_iterator (derivado de la base vacía std::iterator), que mantiene el iterador subyacente (también derivado de std::iterator) como su primer dato miembro no estático.

#include <cassert>
 
struct Base {}; // clase vacía
 
struct Derivada1 : Base 
{
    int i;
};
 
struct Derivada2 : Base 
{
    Base c; // Base, ocupa 1 byte, seguido del relleno para i
    int i;
};
 
struct Derivada3 : Base 
{
    Derivada1 c; // derivada de Base, ocupa sizeof(int) bytes
    int i;
};
 
int main()
{
    // optimización de base vacía no se aplica,
    // la base ocupa 1 byte, el miembro Base ocupa 1 byte
    // seguido de 2 bytes de relleno
    // para satisfacer los requerimientos de alineación de int
    assert(sizeof(Derivada2) == 2*sizeof(int));
 
    // optimización de base vacía no se aplica,
    // la base toma al menos 1 byte más el relleno 
    // para satisfacer el requerimiento de alineación del primer miembro
    // (cuya alineación es la misma que int)
    assert(sizeof(Derivada3) == 3*sizeof(int));
}

#include <cassert>
 
struct Vacia {}; // clase vacía
 
struct X 
{
    int i;
    [[no_unique_address]] Vacia v;
};
 
int main()
{
    // el tamaño de cualquier objeto de una clase vacía es al menos 1
    assert(sizeof(Vacia) >= 1);
 
    // miembro vacío se optimiza
    assert(sizeof(X) == sizeof(int));
}

[editar] Notas

La optimización de base vacía se usa comúnmente por las clases de la biblioteca estándar conscientes de asignadores (std::vector, std::function, std::shared_ptr, etc.) para evitar ocupar almacenamiento adicional para el miembro asignador si el asignador no mantiene estado. Esto se consigue almacenando uno de los datos miembro requeridos (p. ej., begin, end, o un puntero de capacidad para el vector) en una manera equivalente a boost::compressed_pair con el asignador.

[editar] Véase también

• Atributo no_unique_address

[editar] Referencias

[editar] Enlaces externos

• More C++ Idioms/Empty Base Optimization