C++中如何合规实现不同第三方库同布局类型的类型双关（替代union）

你说的没错，用union做这种跨成员的类型双关确实是C++标准里的未定义行为——除非你自始至终只读写union里最后赋值的那个成员。针对你这种两个第三方库布局完全一致的四元结构体场景，我给你几个符合标准的靠谱方案：

1. 用std::memcpy（全C++版本兼容） #

std::memcpy是最稳妥的跨版本方案，标准明确允许把一个可平凡复制类型的对象字节复制到另一个同大小的可平凡复制类型中。你的两个四元结构体都是标准布局，成员都是double，完全满足条件，而且编译器会对这种固定大小的复制做优化，根本不用担心性能问题。

修改你的示例代码如下：

#include <cstring> // 别忘了包含头文件

struct libAQuaternion { double x, y, z, w; };
void libAFunc(libAQuaternion &p) { p.x = p.y = p.z = p.w = 1.; }

struct libBQuaternion { double x, y, z, w; };
void libBFunc(libBQuaternion &p) { p.x = p.y = p.z = p.w = 2.; }

int main() {
    libAQuaternion qA;
    libAFunc(qA);
    
    // 把qA的字节直接复制到qB里
    libBQuaternion qB;
    std::memcpy(&qB, &qA, sizeof(qB));
    
    libBFunc(qB);
    
    // 要是需要再转回libAQuaternion，同样用memcpy就行
    std::memcpy(&qA, &qB, sizeof(qA));
}

2. 用std::bit_cast（C++20及以上） #

C++20专门加了std::bit_cast来处理类型双关的场景，它会在编译期检查源类型和目标类型是否大小相同、是否都是可平凡复制的，比memcpy更安全，代码也更简洁。

示例代码：

#include <bit> // 包含对应的头文件

struct libAQuaternion { double x, y, z, w; };
void libAFunc(libAQuaternion &p) { p.x = p.y = p.z = p.w = 1.; }

struct libBQuaternion { double x, y, z, w; };
void libBFunc(libBQuaternion &p) { p.x = p.y = p.z = p.w = 2.; }

int main() {
    libAQuaternion qA;
    libAFunc(qA);
    
    // 直接把qA转换成libBQuaternion类型
    libBQuaternion qB = std::bit_cast<libBQuaternion>(qA);
    
    libBFunc(qB);
    
    // 转回libAQuaternion也一样简单
    qA = std::bit_cast<libAQuaternion>(qB);
}

3. 指针转换+std::launder（谨慎使用） #

如果你的场景必须直接用指针传递（不想复制对象），可以结合reinterpret_cast和std::launder，但这要求两个类型必须是布局兼容的标准布局类型，而且要严格遵守规则。std::launder的作用是告诉编译器：这块内存里的对象类型已经变了，别再用旧类型的优化逻辑处理了。

示例代码：

#include <new> // 包含std::launder的头文件

struct libAQuaternion { double x, y, z, w; };
void libAFunc(libAQuaternion &p) { p.x = p.y = p.z = p.w = 1.; }

struct libBQuaternion { double x, y, z, w; };
void libBFunc(libBQuaternion &p) { p.x = p.y = p.z = p.w = 2.; }

int main() {
    libAQuaternion qA;
    libAFunc(qA);
    
    // 把qA的存储重新解释成libBQuaternion类型
    libBQuaternion* qB = std::launder(reinterpret_cast<libBQuaternion*>(&qA));
    libBFunc(*qB);
    
    // 再转回libAQuaternion
    libAQuaternion* qA_ptr = std::launder(reinterpret_cast<libAQuaternion*>(qB));
    // 现在可以安全访问*qA_ptr了
}

这种方式不用复制对象，但风险比前两种高，要是类型布局有任何不一致（哪怕是你不知道的细节），就会出问题，所以除非有硬性性能需求，不然更推荐前两种复制方案。

为啥原来的union方案不行？ #

C++标准里对union的规则很明确：你只能访问最后写入的那个成员。要是你先写了myQuat.a，然后去读myQuat.b，这就是未定义行为——编译器可能会把b的访问当成未初始化内存，或者做一些奇怪的优化，导致程序行为完全不可预测。

内容的提问来源于stack exchange，提问作者Michael Mahn