主页 / coding / 问题 / 77930010
Accepted
Chameleon
Asked: 2024-02-03 05:48:45 +0800 CST

与“[[no_unique_address]]”斗争

  • 772

我在 g++ 13.2 中得到了奇怪的sizeof()结果。[[no_unique_address]]

#include <iostream>

using namespace std;

template<bool T>
struct B
{
    struct Dummy {};

    int *a; // swap position with <below placemark>
    // In this position, results are "16" and "40".
    
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> y;
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> x;
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> h;
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> w;
    
    // <below placemark>
    // In this position, results are "8" and "40".
    
};

int main()
{
    cout << sizeof(B<true>) << "\n";
    cout << sizeof(B<false>) << "\n";
}

结果是

16
40

但如果你改变int *a;到线条之后的位置[[no_unique_address]]，你会得到

8
40

另外，只有一行[[no_unique_address]]，并且前面有成员指针变量，结果是正确的：

8
16

我阅读了相关文档[[no_unique_address]]，但没有具体的内容。

为什么会出现这种情况？

c++

2 个回答

  1. Best Answer

    令人不满意的答案是，这[[no_unique_address]]只是向编译器提示它可能会重叠结构中的成员，它不保证任何特定的布局。（来自标准：“对象大小为零的情况是实现定义的”）。

    有几种方法可以限制编译器分配字段偏移量的方式。一是场偏移必须是非递减的。另一个是相同类型的字段必须具有不同的偏移量（否则，指向不同字段的指针将无法区分——这对于指向不同类型字段的指针来说不是问题，因为严格的别名规则禁止这些比较）。

    这意味着，如果您定义了一个具有 4 个虚拟结构的结构，该结构仍将占用 4 个字节，因为必须为这些字段分配不同的偏移量。

    这具体意味着，虽然编译器可以分配a和y相同的偏移量，但它必须分配和x不同的偏移量。这可以如下所示：hw

    struct B
{
    struct Dummy {};
    int &a;
    [[no_unique_address]] Dummy y;
    [[no_unique_address]] Dummy x;
    [[no_unique_address]] Dummy h;
    [[no_unique_address]] Dummy w;
};

int main()
{
    cout << "size: " << sizeof(B) << "\n";
    cout << "offset a: " << offsetof(B, a) << "\n";
    cout << "offset y: " << offsetof(B, y) << "\n";
    cout << "offset x: " << offsetof(B, x) << "\n";
    cout << "offset h: " << offsetof(B, h) << "\n";
    cout << "offset w: " << offsetof(B, w) << "\n";
}

    印刷：

    size: 16
offset a: 0
offset y: 0
offset x: 8
offset h: 9
offset w: 10

    显然，编译器决定 的x偏移量不得与a or y重叠。我不清楚这是编译器的怪癖还是有充分的理由（值得注意的是 GCC 和 Clang 的行为方式相同）。总大小 16 是将大小从 11 字节向上舍入到 8 的倍数的结果。

    似乎有两种方法可以避免这种情况。一种是将空字段放在前面。另一个是确保它们具有不同的类型：

    struct B
{
    struct Dummy1 {};
    struct Dummy2 {};
    struct Dummy3 {};
    struct Dummy4 {};
    int &a;
    [[no_unique_address]] Dummy1 y;
    [[no_unique_address]] Dummy2 x;
    [[no_unique_address]] Dummy3 h;
    [[no_unique_address]] Dummy4 w;
};

int main()
{
    cout << "size: " << sizeof(B) << "\n";
    cout << "offset a: " << offsetof(B, a) << "\n";
    cout << "offset y: " <<offsetof(B, y) << "\n";
    cout << "offset x: " <<offsetof(B, x) << "\n";
    cout << "offset h: " <<offsetof(B, h) << "\n";
    cout << "offset w: " <<offsetof(B, w) << "\n";
}

    印刷：

    size: 8
offset a: 0
offset y: 0
offset x: 0
offset h: 0
offset w: 0

    我认为最简单的解决方案是将所有可能为空的字段放在结构的顶部。

    • 5

  2. T什么时候true:

    • sizeof(a)是 8。
    • sizeof(x)... 分别等于sizeof(Dummy)和 1。
    • x、y、h、w可以相互重叠，它们的总和大小可以为 1 到 4，令其为 1。
    • sizeof(B<true>)is sizeof(a)+ sizeof(x) ...+ pad(7) 是 8 + 1 + 7 是 16。

    当你移动a到底部时：

    • x, y, h,w允许与 重叠a。由于它们是空的，因此它们完全重叠a。
    • sizeof(B<true>)重叠(0) +sizeof(a)是 8。

    为什么第一种情况与类存储端的零大小没有真正重叠x,,,, 。考虑一个数组。member 允许与下一个类成员重叠，但不允许与 重叠。如果是8，就会重叠，这是不允许的。yhwB<true> arr[2][[no_unique_address]]arr[1].asizeof(B<true>)arr[1].aarr[0].w

    • 3

相关问题