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

Question

我在c++20 中玩[[no_unique_address]]。

在cppreference 的示例中，我们有一个空类型Empty 和类型Z

struct Empty {}; // empty class

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

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

但是，我真的很想拥有大小为1 的Z。这让我开始思考，如何将 Empty 包装在一些带有额外模板参数的包装类中，该模板参数强制执行不同类型的 e1 和 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;
};

很遗憾，sizeof(Z1)==2。有没有一个技巧可以让Z1 的大小变成一个？

我正在使用 gcc version 9.2.1 和 clang version 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

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

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

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

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

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

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

确实，仔细想想，试图通过嵌套来隐藏空类型仍然违反了唯一标识规则。考虑您的Wrapper 和Z1 案例。给定一个z1，它是Z1 的一个实例，很明显z1.e1 和z1.e2 是具有不同类型的不同对象。但是，z1.e1 不嵌套在 z1.e2 中，反之亦然。虽然它们有不同的类型，但(Empty&)z1.e1 和(Empty&)z1.e2 是不不同的类型。但它们确实指向不同的对象。

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

无论你如何尝试，你想要的在 C++ 中都是不可能的。

Answer 2

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

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(Empty<Empty<A,A>,A>{})==2 其中 A 是一个完全空的结构。

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

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<Empty<A, char>, A> 之类的东西。

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; };
};