[[no_unique_address]]和同一类型的两个成员值

Question

我在玩c20中的[[no_unique_address]]。

在cppreference的例子中，我们有一个空类型< code>Empty和类型< code>Z

struct Empty {}; // empty class

struct Z {
    char c;
    [[no_unique_address]] Empty e1, e2;
};

显然，< code>Z的大小必须至少为< code>2，因为< code>e1和< code>e2的类型相同。

但是，我真的希望< code>Z的大小为< code>1。这让我想到，如何用额外的模板参数将< code>Empty包装在某个包装类中，以强制执行不同类型的< code>e1和< code>e2。

template <typename T, int i>
struct Wrapper : public T{};

struct Z1 {
    char c;
    [[no_unique_address]] Wrapper<Empty,1> e1;
    [[no_unique_address]] Wrapper<Empty,2> e2;
};

不幸的是，大小（Z1）==2。有没有一个技巧可以使Z1的大小成为一个？

我正在使用gcc版本9.2.1和clang版本9.0.0进行测试。

在我的应用程序中，我有很多空类型的表单。

template <typename T, typename S>
struct Empty{
    [[no_unique_address]] T t;
    [[no_unique_address]] S s;
};

如果T和S也是空类型并且不同，则哪个是空类型！即使T和S是相同的类型，我也希望此类型为空。

Answer 1

据我所知，如果您想拥有两个成员，这是不可能的。但是当类型相同且为空时，您可以专门化并且只有一个成员：

template <typename T, typename S, typename = void>
struct Empty{
    [[no_unique_address]] T t;
    [[no_unique_address]] S s;

    constexpr T& get_t() noexcept { return t; };
    constexpr S& get_s() noexcept { return s; };
};

template<typename TS>
struct Empty<TS, TS, typename std::enable_if_t<std::is_empty_v<TS>>>{
    [[no_unique_address]] TS ts;

    constexpr TS& get_t() noexcept { return ts; };
    constexpr TS& get_s() noexcept { return ts; };
};

当然，使用成员的程序的其余部分需要更改，以处理只有一个成员的情况。在这种情况下使用哪个成员并不重要 - 毕竟，它是一个没有唯一地址的无状态对象。显示的成员函数应该使这变得简单。

不幸的是，sizeof（空

您可以引入更多专项来支持空对的递归压缩：

template<class TS>
struct Empty<Empty<TS, TS>, TS, typename std::enable_if_t<std::is_empty_v<TS>>>{
    [[no_unique_address]] Empty<TS, TS> ts;

    constexpr Empty<TS, TS>& get_t() noexcept { return ts; };
    constexpr TS&            get_s() noexcept { return ts.get_s(); };
};

template<class TS>
struct Empty<TS, Empty<TS, TS>, typename std::enable_if_t<std::is_empty_v<TS>>>{
    [[no_unique_address]] Empty<TS, TS> ts;

    constexpr TS&            get_t() noexcept { return ts.get_t(); };
    constexpr Empty<TS, TS>& get_s() noexcept { return ts; };
};

更重要的是，要压缩Empty之类的内容

template <typename T, typename S>
struct Empty<Empty<T, S>, S, typename std::enable_if_t<std::is_empty_v<S>>>{
     [[no_unique_address]] Empty<T, S> ts;

    constexpr Empty<T, S>& get_t() noexcept { return ts; };
    constexpr S&           get_s() noexcept { return ts.get_s(); };
};

template <typename T, typename S>
struct Empty<Empty<S, T>, S, typename std::enable_if_t<std::is_empty_v<S>>>{
     [[no_unique_address]] Empty<S, T> st;

    constexpr Empty<S, T>& get_t() noexcept { return st; };
    constexpr S&           get_s() noexcept { return st.get_t(); };
};


template <typename T, typename S>
struct Empty<T, Empty<T, S>, typename std::enable_if_t<std::is_empty_v<T>>>{
     [[no_unique_address]] Empty<T, S> ts;

    constexpr T&           get_t() noexcept { return ts.get_t(); };
    constexpr Empty<T, S>  get_s() noexcept { return ts; };
};

template <typename T, typename S>
struct Empty<T, Empty<S, T>, typename std::enable_if_t<std::is_empty_v<T>>>{
     [[no_unique_address]] Empty<S, T> st;

    constexpr T&           get_t() noexcept { return st.get_s(); };
    constexpr Empty<S, T>  get_s() noexcept { return st; };
};

Answer 2

如果T和S也是空类型并且不同，则哪个是空类型！即使T和S是相同的类型，我也希望此类型为空。

你不能得到那个。从技术上讲，即使< code>T和< code>S是不同的空类型，你甚至不能保证它一定是空的。记住:< code>no_unique_address是一个属性；它隐藏对象的能力完全依赖于实现。从标准的角度来看，您不能强制空对象的大小。

随着C 20实现的成熟，您应该假设[[no_unique_address]通常会遵循空基优化的规则。也就是说，只要两个相同类型的对象不是子对象，您就可以期待隐藏。但在这一点上，这有点运气。

至于T和S是同一类型的具体情况，这根本不可能。尽管名称“no_unique_address”的含义，但现实情况是，C要求在给定两个指向相同类型对象的指针时，这些指针要么指向同一对象，要么具有不同的地址。我称之为“唯一身份规则”，no_unique_address不会影响这一点。从 [介绍对象]/9：

如果一个对象嵌套在另一个对象中，或者如果至少一个对象是大小为零的子对象，并且它们的类型不同，那么具有重叠生存期的两个对象（不是位字段）可能具有相同的地址；否则，它们具有不同的地址并占用不相交的存储字节。

声明为 [[no_unique_address]] 的空类型的成员大小为零，但具有相同的类型使得这是不可能的。

实际上，仔细想想，试图通过嵌套隐藏空类型仍然违反了唯一标识规则。考虑您的< code >包装器和< code>Z1案例。给定一个< code>z1，它是< code>Z1的实例，显然< code>z1.e1和< code>z1.e2是不同类型的不同对象。但是，< code>z1.e1不会嵌套在< code>z1.e2中，反之亦然。虽然它们有不同的类型，< code >(空

根据唯一标识规则，它们必须具有不同的地址。因此，即使 e1 和 e2 在名义上是不同的类型，它们的内部也必须服从对同一包含对象中的其他子对象的唯一标识。递 归。

不管你怎么努力，你想要的在C语言中是不可能的。