此问题已在此处有答案：

What is the modern, correct way to do type punning in C++?（2个答案）
23天前关闭
假设我正在开发一个名为libModern的库。这个库使用一个遗留的C库libLegacy作为实现策略。libLegacy的接口看起来像这样：

typedef uint32_t LegacyFlags;
struct LegacyFoo {
    uint32_t x;
    uint32_t y;
    LegacyFlags flags;
    // more data
};
struct LegacyBar {
    LegacyFoo foo;
    float a;
    // more data
};
void legacy_input(LegacyBar const* s); // Does something with s
void legacy_output(LegacyBar* s); // Stores data in s

libModern不应该将libLegacy的类型暴露给它的用户，原因有很多，其中包括：

• libLegacy是一个不应该泄露的实现细节。libModern的未来版本可能会选择使用另一个库而不是libLegacy。
• libLegacy使用难以使用、容易误用的类型，这些类型不应该成为任何面向用户的API的一部分。

处理这种情况的教科书方法是pimpl习语：libModern将提供一个 Package 器类型，该类型内部有一个指向遗留数据的指针。然而，这在这里是不可能的，因为libModern不能分配动态内存。一般来说，它的目标是不增加很多开销。
因此，libModern定义了自己的类型，这些类型与遗留类型的布局兼容，但具有更好的接口。在这个例子中，它使用了一个强enum而不是普通的uint32_t作为标志：

enum class ModernFlags : std::uint32_t
{
    first_flag = 0,
    second_flag = 1,
};
struct ModernFoo {
    std::uint32_t x;
    std::uint32_t y;
    ModernFlags flags;
    // More data
};
struct ModernBar {
    ModernFoo foo;
    float a;
    // more data
};

现在的问题是：libModern如何在没有太多开销的情况下在传统类型和现代类型之间进行转换？我知道三个选择：

1. reinterpret_cast。这是未定义的行为，但实际上会产生完美的组装。我想避免这种情况，因为我不能依赖这个明天仍然工作或另一个编译器。
2. std::memcpy。在简单的情况下，这会生成相同的最佳程序集，但在任何非平凡的情况下，这都会增加显著的开销。
3. C++20的std::bit_cast。在我的测试中，它最多只能产生与memcpy完全相同的代码。在某些情况下，情况更糟。
   这是与libLegacy接口的3种方式的比较：
   1.与legacy_input()接口
   1.使用reinterpret_cast：

void input_ub(ModernBar const& s) noexcept {
    legacy_input(reinterpret_cast<LegacyBar const*>(&s));
}

组件：

input_ub(ModernBar const&):
        jmp     legacy_input

这是完美的codegen，但它调用了UB。
1.使用memcpy：

void input_memcpy(ModernBar const& s) noexcept {
    LegacyBar ls;
    std::memcpy(&ls, &s, sizeof(ls));
    legacy_input(&ls);
}

组件：

input_memcpy(ModernBar const&):
        sub     rsp, 24
        movdqu  xmm0, XMMWORD PTR [rdi]
        mov     rdi, rsp
        movaps  XMMWORD PTR [rsp], xmm0
        call    legacy_input
        add     rsp, 24
        ret

严重恶化。
1.使用bit_cast：

void input_bit_cast(ModernBar const& s) noexcept {
    LegacyBar ls = std::bit_cast<LegacyBar>(s);
    legacy_input(&ls);
}

装配：

input_bit_cast(ModernBar const&):
        sub     rsp, 40
        movdqu  xmm0, XMMWORD PTR [rdi]
        mov     rdi, rsp
        movaps  XMMWORD PTR [rsp+16], xmm0
        mov     rax, QWORD PTR [rsp+16]
        mov     QWORD PTR [rsp], rax
        mov     rax, QWORD PTR [rsp+24]
        mov     QWORD PTR [rsp+8], rax
        call    legacy_input
        add     rsp, 40
        ret

我不知道这里发生了什么。
1.与legacy_output（）接口
1.使用reinterpret_cast：

auto output_ub() noexcept -> ModernBar {
    ModernBar s;
    legacy_output(reinterpret_cast<LegacyBar*>(&s));
    return s;
}

组件：

output_ub():
        sub     rsp, 56
        lea     rdi, [rsp+16]
        call    legacy_output
        mov     rax, QWORD PTR [rsp+16]
        mov     rdx, QWORD PTR [rsp+24]
        add     rsp, 56
        ret

1.使用memcpy：

auto output_memcpy() noexcept -> ModernBar {
    LegacyBar ls;
    legacy_output(&ls);
    ModernBar s;
    std::memcpy(&s, &ls, sizeof(ls));
    return s;
}

组装：

output_memcpy():
        sub     rsp, 56
        lea     rdi, [rsp+16]
        call    legacy_output
        mov     rax, QWORD PTR [rsp+16]
        mov     rdx, QWORD PTR [rsp+24]
        add     rsp, 56
        ret

1.使用bit_cast：

auto output_bit_cast() noexcept -> ModernBar {
    LegacyBar ls;
    legacy_output(&ls);
    return std::bit_cast<ModernBar>(ls);
}

装配：

output_bit_cast():
        sub     rsp, 72
        lea     rdi, [rsp+16]
        call    legacy_output
        movdqa  xmm0, XMMWORD PTR [rsp+16]
        movaps  XMMWORD PTR [rsp+48], xmm0
        mov     rax, QWORD PTR [rsp+48]
        mov     QWORD PTR [rsp+32], rax
        mov     rax, QWORD PTR [rsp+56]
        mov     QWORD PTR [rsp+40], rax
        mov     rax, QWORD PTR [rsp+32]
        mov     rdx, QWORD PTR [rsp+40]
        add     rsp, 72
        ret

Here您可以在浏览器资源管理器上找到完整的示例。
我还注意到，根据结构体的确切定义（即，成员的顺序、数量和类型）。但是UB版本的代码始终更好，或者至少和其他两个版本一样好。
现在我的问题是：
1.为什么代码生成器变化如此之大？这让我怀疑我是否错过了什么重要的东西。
1.有没有什么我可以做的，以指导编译器生成更好的代码，而不调用UB？
1.是否有其他符合标准的方法可以生成更好的代码？