通过 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。这些写法的意图更清楚,编译器通常也能将其优化为高效的复制操作。
备注:内容仅供参考。
