C++ Struct Aliasing

C++ Strict Aliasing

C++ 中的 Strict Aliasing(严格别名规则)是编译器优化代码时的重要依据。它的核心规则和避坑指南如下:

  • 在 C++ 中,Struct Aliasing 属于严格别名规则(Strict Aliasing Rule)的一部分。核心原则非常明确:编译器假设不同类型的指针/引用永远不会指向同一块内存地址。
  • 如果违反这一假设并通过不同类型的指针去读写内存,属于未定义行为(Undefined Behavior, UB),编译器在开启优化(如 -O2 / -O3)时可能会直接乱序、内联或消除读写操作。

例外

C++ 标准规定,通过泛型指针访问某个对象 T 的动态类型时,仅在少数兼容情况下合法:

  • 完全相同类型(或仅有 const / volatile 修饰符差异);

  • 字符类型指针:char*、unsigned char*、std::byte*(它们是合法的通用内存检查器);

  • 聚合/类类型的特殊例外:

    • 可以通过包含该类型的结构体/联合体成员来访问(如访问 struct S { int a; } 内部的 int);

      如果一个结构体包含了某个类型的成员,编译器允许以下两种访问方式视为合法的别名重叠:

      1. 通过外层聚合体访问内部元素。
      2. 通过具体元素类型的指针访问该聚合体中对应的内存。
      struct Header {
          int id;
          float version;
      };
      
      void process(Header* h, int* id_ptr) {
          h->id = 10;
          *id_ptr = 20; // 合法!编译器必须意识到 id_ptr 可能会指向 h->id
          // 如果 id_ptr 真的指向 h->id,这里读取 h->id 时,编译器不能假设它依然是 10
      }
      

      如果严格别名规则不做此妥协,编译器就会认为 Header* 和 int* 没有任何关系,从而在优化时把写入 id_ptr 和读取 h->id 的顺序搞乱,导致程序读到脏数据。

    • 共同初始序列(Common Initial Sequence):在同一个 union 内,如果两个标准布局结构体(Standard-layout struct)开头的成员类型和顺序一致,读取其中一个的公共初始成员是合法的。

除此之外,任何将 StructA* 强转为 StructB* 并解引用的行为,哪怕两个结构体的成员一模一样,也是 UB。

例如,下面的 case 是不合法的:

struct Point2D { float x, y; };
struct Vector2D { float u, v; };

void update(Point2D* pt, Vector2D* vec) {
    pt->x = 1.0f;
    vec->u = 2.0f;
    // 编译器认为 pt 和 vec 指向不同对象,
    // 可能假设 pt->x 依然是 1.0f 并直接消除后续对 pt->x 的重复读取,
    // 哪怕调用时传入的是同一块内存:update((Point2D*)&v, &v);
}
// 典型的 UB 骚操作
float f = 3.14f;
uint32_t i = *(uint32_t*)&f; // 违反严格别名规则,产生未定义优化

正确的类型双关(Type Punning)做法

如果你确实需要把一个结构体的内存当成另一个结构体来用,千万别用指针直接硬转。 正确的做法是:

  • 传统做法:使用 std::memcpy 拷贝字节。
  • 现代 C++:使用 C++20 的 std::bit_cast。 不用担心性能,现代编译器非常聪明,在底层往往会把这种操作优化成零成本,连实际的内存拷贝都不会发生。

std::bit_cast 简直就是现代 C++ 玩弄底层内存的“合法外挂”。

简单来说,它是 C++20 专门引入用来做类型双关(Type Punning)的标准库函数。你要是想把一块内存里的二进制位,原封不动地当成另一种类型来读,用它就对了。

它主要有以下 3 个核心特点:

1. 完美避开 Strict Aliasing 的 UB 坑 就像之前讨论结构体强转时提到的,如果用 reinterpret_cast 或者 C 风格强转去跨类型读内存,编译器一开优化(比如 -O2)就会触发未定义行为,把你代码搞炸。而 std::bit_cast 就是官方给的免死金牌,编译器看到它就会乖乖按照你的意图去读位元,绝不乱优化。

2. 真正的零成本抽象 过去为了安全避坑,标准做法是用 std::memcpy 把字节拷过去。虽然现代编译器通常也能把小段的 memcpy 优化掉,但写起来太啰嗦。std::bit_cast 在底层本质上等同于 memcpy,但在开启编译优化后,它连一条汇编指令都不会多生成,完全是 零开销。

3. 严格的硬性门槛 为了防止你瞎转,编译器对 bit_cast 有两个死规定:

  • 大小必须绝对一致: sizeof(To) == sizeof(From),差一个字节都会编译报错。
  • 必须是平凡可拷贝(Trivially Copyable): 转换的两种类型必须是简单的内存块(比如基础类型、简单的 Struct),不能包含复杂的构造函数、析构函数或虚函数。

经典用法示例(比如查看浮点数的底层二进制表示):

#include <bit>
#include <iostream>
#include <cstdint>

int main() {
    float f = 3.14f;
    
    // 以前:UB 玩法 (危险)
    // uint32_t bad_bits = *reinterpret_cast<uint32_t*>(&f); 
    
    // 现在:C++20 合法外挂 (安全且零成本)
    uint32_t good_bits = std::bit_cast<uint32_t>(f);
    
    std::cout << std::hex << good_bits << "\n"; // 输出 4048f5c3
    return 0;
}

参考资料

https://zhuanlan.zhihu.com/p/595286568

https://zhuanlan.zhihu.com/p/2051610384352781677

posted @ 2026-09-05 14:46  光風霽月  阅读(20)  评论(0)    收藏  举报