C++20中无UB的字节数组转平凡类型方案正确性及最优实现问询

我需要将从文件中获取的字节切片转换为满足以下平凡性特性的目标类型To：

• std::is_trivially_copyable_v<To>
• std::is_trivially_constructible_v<To>（甚至仅满足std::is_constructible_v<To>）

这是一个经典常见问题，但在遵循严格别名规则并考虑对齐时，实现方式并不直观。我编写了两种可能的实现方案：

方案一 #

template<class To, class TByte>
requires ((std::is_same_v<TByte, char> || std::is_same_v<TByte, unsigned char> || std::is_same_v<TByte, std::byte>) 
&& std::is_trivially_copyable_v<To>)
To from_bytes(const TByte* inp){
    alignas(To) TByte buf[sizeof(To)];
    To* res = new (buf) To;
    std::memcpy(res, inp, sizeof(To));
    return *res;
}

方案二 #

template<class To, class TByte>
requires (std::is_same_v<TByte, char> || std::is_same_v<TByte, unsigned char> || std::is_same_v<TByte, std::byte>)
To from_bytes2(const TByte* inp){
    using TArr=TByte[sizeof(To)];
    return std::bit_cast<To>(*reinterpret_cast<const TArr*>(inp));
}

问题 #

1. 根据C++20标准，上述任一方案是否存在未定义行为（UB）或其他不良影响？
2. 我认为这些方案在C++20中并非完全符合惯用写法，那么该问题的经典最优实现方式是什么？

问题1：方案的未定义行为与缺陷分析 #

方案一的问题 #

方案一没有违反严格别名规则，但存在逻辑冗余和潜在风险：

1. 不必要的构造调用：new (buf) To会触发To的默认构造，但后续立刻用std::memcpy覆盖整个对象内存。如果To的默认构造有副作用，会被直接覆盖；如果To不支持无参构造（仅满足带参的std::is_constructible_v），代码会直接编译失败。
2. 冗余开销：即使To是平凡可构造的，这步构造完全多余，会带来不必要的性能开销。

整体来说，方案一不算UB，但设计不够严谨。

方案二的问题 #

方案二存在明确的未定义行为：

1. 严格别名规则违反：reinterpret_cast<const TArr*>(inp)后解引用，相当于断言inp指向的是一个合法的TArr类型对象，但实际上它只是一堆连续字节，并非标准意义上的TArr对象，直接违反严格别名规则。
2. 对齐违规风险：如果inp指向的内存对齐度低于To的要求，std::bit_cast生成的To对象会处于不对齐的内存中，这是标准明确禁止的UB。

问题2：C++20的经典最优实现 #

在C++20中，最安全、惯用的实现方式是结合对齐临时内存与std::memcpy，同时用std::launder处理对象生命周期的编译器认知问题，具体实现如下：

template<class To, class TByte>
requires (std::is_same_v<TByte, char> || std::is_same_v<TByte, unsigned char> || std::is_same_v<TByte, std::byte>)
&& std::is_trivially_copyable_v<To>
To from_bytes(const TByte* inp) {
    // 创建满足To对齐要求的临时内存
    alignas(To) std::byte buf[sizeof(To)];
    // memcpy不受严格别名限制，安全拷贝字节
    std::memcpy(buf, inp, sizeof(To));
    // 告知编译器：buf内存上现在有合法的To对象，避免优化错误
    return *std::launder(reinterpret_cast<To*>(buf));
}

核心优势 #

• 对齐安全：alignas(To)确保临时内存满足To的对齐要求，规避对齐违规风险；
• 严格别名兼容：std::memcpy是标准允许的跨类型字节拷贝方式，完全不违反严格别名规则；
• 生命周期合法：std::launder解决了编译器对“内存上已存在合法To对象”的认知问题，避免优化导致的错误；
• 通用性强：无论To是否支持默认构造，只要满足平凡可拷贝特性就能正常工作。

如果能保证输入内存已经满足To的对齐要求，也可以用std::bit_cast实现，但需要确保源内存对应合法的对象类型，比如：

template<class To, class TByte>
requires (std::is_same_v<TByte, char> || std::is_same_v<TByte, unsigned char> || std::is_same_v<TByte, std::byte>)
&& std::is_trivially_copyable_v<To>
To from_bytes_aligned(const TByte* inp) {
    static_assert(sizeof(To) == sizeof(TByte) * sizeof(To), "Type size mismatch");
    return std::bit_cast<To>(*reinterpret_cast<const std::array<TByte, sizeof(To)>*>(inp));
}

不过这种方式依赖于对齐前提，通用性不如memcpy方案，因此前者仍是多数场景下的首选。

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