C++ attribute: no_unique_address (since C++20)

Permite que este miembro de datos se superponga con otros miembros de datos no estáticos o subobjetos de clase base de su clase.

Sintaxis

Explicación

Se aplica al nombre que se declara en la declaración de un miembro de datos no estático que no es un campo de bits.

Hace que este subobjeto miembro sea potencialmente-superpuesto , es decir, permite que este miembro se superponga con otros miembros de datos no estáticos o subobjetos de clase base de su clase. Esto significa que si el miembro tiene un tipo de clase vacío (por ejemplo, un asignador sin estado), el compilador puede optimizarlo para que no ocupe espacio, al igual que si fuera una base vacía . Si el miembro no está vacío, cualquier relleno final en él también puede reutilizarse para almacenar otros miembros de datos.

Notas

[ [ no_unique_address ] ] es ignorado por MSVC incluso en modo C++20; en su lugar, [ [ msvc :: no_unique_address ] ] es proporcionado.

Ejemplo

#include <boost/type_index.hpp>
#include <iostream>
struct Empty {}; // El tamaño de cualquier objeto de tipo clase vacía es al menos 1
static_assert(sizeof(Empty) >= 1);
struct X
{
    int i;
    Empty e; // Se necesita al menos un byte más para dar a 'e' una dirección única
};
static_assert(sizeof(X) >= sizeof(int) + 1);
struct Y
{
    int i;
    [[no_unique_address]] Empty e; // Miembro vacío optimizado
};
static_assert(sizeof(Y) >= sizeof(int));
struct Z
{
    char c;
    // e1 y e2 no pueden compartir la misma dirección porque tienen el
    // mismo tipo, aunque estén marcados con [[no_unique_address]].
    // Sin embargo, cualquiera puede compartir dirección con 'c'.
    [[no_unique_address]] Empty e1, e2;
};
static_assert(sizeof(Z) >= 2);
struct W
{
    char c[2];
    // e1 y e2 no pueden tener la misma dirección, pero uno de
    // ellos puede compartir con c[0] y el otro con c[1]:
    [[no_unique_address]] Empty e1, e2;
};
static_assert(sizeof(W) >= 2);
template <typename T>
void print_size_of()
{
    using boost::typeindex::type_id;
    std::cout << "sizeof(" << type_id<T>() << ") == " << sizeof(T) << '\n';
}
int main()
{
    print_size_of<Empty>();
    print_size_of<int>();
    print_size_of<X>();
    print_size_of<Y>();
    print_size_of<Z>();
    print_size_of<W>();
}

sizeof(Empty) == 1
sizeof(int) == 4
sizeof(X) == 8
sizeof(Y) == 4
sizeof(Z) == 2
sizeof(W) == 3

Referencias