PAYATHON 2026

通过 type punning 的 struct 成员赋值数组是否属于 UB?

技术老齐

结论

这段程序具有 undefined behavior(未定义行为),既不是 implementation-defined behavior,也不是 well-defined behavior。

reinterpret_cast<s&>(a) 不会在 a 的存储位置创建 s 对象,a 的实际类型仍是 int[2]。执行下面的语句时:

aref = bref;

程序通过 s 类型的引用访问并修改这块存储区域,违反了 C++ 关于对象类型、对象生命周期和类型可访问性的规则。即使编译器没有警告,程序也输出了 10, 20,这种写法仍然不合法。

问题出在哪里

下面的定义表示 s 有一个数组成员:

struct s {
    int sa[2];
};

这不代表任意独立的 int[2] 对象都能当作 s 对象使用。原程序实际创建的对象只有:

int a[2];
int b[2];

这两块存储中从未构造过 s 对象。

reinterpret_cast 只生成一个类型为 s& 的引用。它不会创建 s 对象或启动其生命周期,也不会让数组变成 s::sa 子对象。内存布局相似,同样不能让两种类型互相替代。

执行 aref = bref 时,编译器会按照 s 的复制赋值规则处理两端,包括逐个赋值数组成员。然而,两端实际都不存在 s 对象,所以 C++ 对象模型并不保证这种访问有效。

首成员布局规则也不能使它合法

标准布局类型的对象与它的首个非静态数据成员之间可能具有 pointer-interconvertible 关系,但类对象和成员对象必须真实存在。例如:

struct s {
    int sa[2];
};

s obj{{1, 2}};

这里的 obj 和 obj.sa 确实是对象与子对象的关系。

原程序中的 a 只是独立数组,不是某个 s 对象的成员。即使 s 与其数组成员通常具有相同的起始地址,大小也可能相同,这些布局特征也不会自动创建对象或子对象关系。

common initial sequence 等规则同样不适用,不能用来把任意数组重新解释成包含该数组的结构体。

推荐的数组复制方式

必须使用原生数组时,可以直接调用 std::copy:

#include <algorithm>
#include <iostream>
#include <iterator>

int main() {
    int a[2] = {1, 2};
    int b[2] = {10, 20};

    std::copy(std::begin(b), std::end(b), std::begin(a));

    std::cout << a[0] << ", " << a[1] << '\n';
}

也可以逐个为元素赋值:

#include <cstddef>
#include <iostream>

int main() {
    int a[2] = {1, 2};
    int b[2] = {10, 20};

    for (std::size_t i = 0; i < 2; ++i) {
        a[i] = b[i];
    }

    std::cout << a[0] << ", " << a[1] << '\n';
}

这两种写法都按照元素本身的赋值语义工作,编译器也容易对其进行优化。

更合适的类型:std::array

如果希望数组具有普通值类型的赋值语义,可以使用 std::array:

#include <array>
#include <iostream>

int main() {
    std::array<int, 2> a{{1, 2}};
    std::array<int, 2> b{{10, 20}};

    a = b;

    std::cout << a[0] << ", " << a[1] << '\n';
}

std::array 支持复制赋值、迭代器和比较等操作,内部仍保存固定长度的连续元素。新代码通常更适合使用它,而不是原生数组。

如果业务需要结构体,应直接创建真正的结构体对象:

#include <iostream>

struct s {
    int sa[2];
};

int main() {
    s a{{1, 2}};
    s b{{10, 20}};

    a = b;

    std::cout << a.sa[0] << ", " << a.sa[1] << '\n';
}

这里的 a 和 b 都是实际存在的 s 对象,可以合法地进行结构体赋值。

关于 memcpy

对于 int 这类 trivially copyable 类型,在大小正确且源与目标不重叠的情况下,也可以使用 std::memcpy:

#include <cstring>

int a[2] = {1, 2};
int b[2] = {10, 20};

std::memcpy(a, b, sizeof a);

memcpy 复制的是对象表示,不会调用元素的赋值运算,因此不能作为适用于任意元素类型的数组赋值方案。数组中可能包含非平凡类型时,应使用 std::copy、循环或 std::array 的赋值运算符。如果源和目标可能重叠,还需要考虑复制方向,或者改用 std::memmove。

实际使用建议

不要使用原程序中的 type punning 写法。它不符合 C++ 规则,也没有可移植性优势。开启优化后,类型别名分析还可能导致意外结果。

保留原生数组时可以使用 std::copy。能够调整数据类型时,优先考虑 std::array。只有为 trivially copyable 类型复制原始字节,并且满足相应条件时,才使用 std::memcpy。这些写法的意图更清楚,编译器通常也能将其优化为高效的复制操作。

备注:内容仅供参考。