使用union解决编译器警告：解引用类型双关指针违反严格别名规则

原代码触发编译器警告：

dereferencing type-punned pointer will break strict-aliasing rules

原代码如下：

#include <endian.h>

template <typename T>                                                 
inline T HostToLittleEndian(T val) {                                              
  switch (sizeof(val)) {                                                   
    case 1:                                                                
      return val;                                                          
    case 2: {                                                              
      uint16_t r = htole16(*reinterpret_cast<uint16_t*>(&val));                 
      return *reinterpret_cast<T*>(&r);                                    
    }                                                                       
    case 4: {                                                              
      uint32_t r = htole32(*reinterpret_cast<uint32_t*>(&val));                 
      return *reinterpret_cast<T*>(&r);                                    
    }                                                                       
    case 8: {                                                              
      uint64_t r = htole64(*reinterpret_cast<uint64_t*>(&val));                 
      return *reinterpret_cast<T*>(&r);                                    
    }                                                                       
    default:                                                               
      static_assert(sizeof(val) <= 8, "Value is 64-bits or less.");         
  }                                                                         
}                                                                           

我用union重构后解决了警告，但会产生一次val的额外拷贝。我觉得这个拷贝无法避免，想问是不是真的如此？有没有更优的实现方案？

重构后的代码：

template <typename T>
inline T HostToLittleEndian(T val) {
  union {
    T value;
    uint64_t u64;
    uint32_t u32;
    uint16_t u16;
    uint8_t u8;
  } data;
  data.value = val;
  
  switch (sizeof(val)) {
    case 1:
      break;
    case 2:
      data.u16 = htole16(data.u16);
      break;
    case 4:
      data.u32 = htole32(data.u32);
      break;
    case 8:
      data.u64 = htole64(data.u64);
      break;
    default:
      static_assert(sizeof(val) <= 8, "Value is 64-bits or less.");
  }
  return data.value;   
}

注：T可以是整数类型或浮点类型。

首先明确：针对你的场景，这份union实现里的拷贝几乎可以忽略，甚至编译器大概率会优化掉它。

为什么拷贝可能被优化？ #

现代编译器（比如GCC、Clang、MSVC）在处理inline函数和简单union操作时，会进行激进的优化：

• 函数参数val本身是传值进来的，在栈上已经有一份副本；
• union的赋值data.value = val和后续的返回data.value，编译器可以直接把val的栈空间当作union的存储区，不需要额外拷贝；
• 加上inline关键字，编译器更倾向于把函数逻辑展开到调用点，进一步消除不必要的内存操作。

更优的替代方案 #

如果确实想彻底避免理论上的拷贝，可以考虑以下两种思路：

1. 使用std::bit_cast（C++20及以上）

C++20引入的std::bit_cast是标准认可的类型安全的位转换方式，完全符合严格别名规则，且不需要union：

#include <endian.h>
#include <bit>

template <typename T>                                                 
inline T HostToLittleEndian(T val) {                                              
  static_assert(sizeof(T) <= 8, "Value is 64-bits or less.");
  switch (sizeof(val)) {                                                   
    case 1:                                                                
      return val;                                                          
    case 2: {                                                              
      auto tmp = std::bit_cast<uint16_t>(val);
      tmp = htole16(tmp);
      return std::bit_cast<T>(tmp);                                    
    }                                                                       
    case 4: {                                                              
      auto tmp = std::bit_cast<uint32_t>(val);
      tmp = htole32(tmp);
      return std::bit_cast<T>(tmp);                                    
    }                                                                       
    case 8: {                                                              
      auto tmp = std::bit_cast<uint64_t>(val);
      tmp = htole64(tmp);
      return std::bit_cast<T>(tmp);                                    
    }                                                                       
  }                                                                         
}                                                                           

std::bit_cast直接在编译期保证类型大小相同，不会有运行时拷贝开销，是C++20+场景下最规范的做法。

2. 手动字节交换（兼容C++11及更早）

如果不能用C++20，可以手动实现字节交换逻辑，完全绕开类型转换的问题：

#include <algorithm> // 用于std::swap

template <typename T>                                                 
inline T HostToLittleEndian(T val) {                                              
  static_assert(sizeof(T) <= 8, "Value is 64-bits or less.");
  if constexpr (sizeof(T) == 1) {
    return val;
  } else if constexpr (sizeof(T) == 2) {
    uint8_t* bytes = reinterpret_cast<uint8_t*>(&val);
    if (__BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__) {
      std::swap(bytes[0], bytes[1]);
    }
  } else if constexpr (sizeof(T) == 4) {
    uint8_t* bytes = reinterpret_cast<uint8_t*>(&val);
    if (__BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__) {
      std::swap(bytes[0], bytes[3]);
      std::swap(bytes[1], bytes[2]);
    }
  } else if constexpr (sizeof(T) == 8) {
    uint8_t* bytes = reinterpret_cast<uint8_t*>(&val);
    if (__BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__) {
      std::swap(bytes[0], bytes[7]);
      std::swap(bytes[1], bytes[6]);
      std::swap(bytes[2], bytes[5]);
      std::swap(bytes[3], bytes[4]);
    }
  }
  return val;
}

这里用if constexpr（C++17）或者普通分支，直接操作字节数组，修改原参数的字节顺序（因为参数是传值的，修改的是副本，不影响外部），完全没有额外拷贝，也符合严格别名规则（char/uint8_t可以别名任意类型）。

总结 #

• 你当前的union实现里的拷贝几乎不会有实际性能影响，编译器会优化掉；
• 如果追求最规范或零拷贝，优先用C++20的std::bit_cast；
• 旧标准下可以手动字节交换，同样能避免拷贝和严格别名问题。

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