在 C++ 中，内存对齐并不是一个只出现在教科书里的概念。当我们把网络缓冲区中的数据强制转换为结构体指针，或者把一块从内存池里切出来的地址交给 SIMD 指令使用时，一旦地址不满足对齐要求，代码可能不会立刻崩溃，而是以难以排查的方式留下隐患。轻则造成非对齐访问的性能损失，重则在某些架构上直接抛出总线错误。要规避这些问题，首先需要写一个可靠的地址对齐判定函数。这个函数的核心只有一行：把指针转换为整数，再对目标对齐值取模。但真正用好它，还需要理解 alignof、指针运算以及类型布局之间的关系。

从地址取模开始，理解对齐判定

对齐的本质是要求对象的起始地址是其对齐值的整数倍。C++11 引入的 alignof 运算符可以直接返回一个类型在目标平台上的对齐要求，例如 alignof(int) 在主流 64 位 Linux 上是 4，alignof(double) 通常是 8。对于手动分配的内存，编译器并不会自动保证任意地址都符合这些要求，特别是当我们通过 char 数组、网络接收缓冲区或者自定义内存池获得原始内存时，需要对地址做显式判断。

判断函数最基本的实现如下。先包含 <cstdint> 与 <cassert>，然后把指针 reinterpret_cast 成 uintptr_t。uintptr_t 是一种无符号整数类型，它保证能够容纳指针值，并且从指针到整数、再从整数回到指针的转换不会丢失信息。拿到整数地址后，直接对 alignment 取模即可。如果余数为 0，说明地址正好落在对齐边界上。

#include <cstdint>
#include <cstddef>
#include <cassert>
// 通用版本：对任意非零对齐值有效
bool is_aligned(const void* ptr, std::size_t alignment) {
    assert(alignment != 0);
    return reinterpret_cast<std::uintptr_t>(ptr) % alignment == 0;
}

这个实现足够通用，但在频繁调用的热路径里，取模运算可能不是最优选择。由于大多数类型的对齐值都是 2 的幂，例如 1、2、4、8、16、32、64，我们可以改成按位与操作。c = a & (alignment - 1)，只要 c 等于 0，就代表 a 是 alignment 的整数倍。这个优化需要注意 alignment 必须是 2 的幂，否则结果错误。可以在调试版本加 assert 检查。

// 快速版本：仅适用于 2 的幂对齐值
bool is_aligned_pow2(const void* ptr, std::size_t alignment) {
    assert((alignment & (alignment - 1)) == 0);
    return (reinterpret_cast<std::uintptr_t>(ptr) & (alignment - 1)) == 0;
}

对于基于类型的场景，还可以用模板把判定函数封装起来，让调用方不必手动写 alignof(T)。这样在传入对象指针时，编译器会自动推导出该类型的对齐要求，减少漏写或写错的概率。

template <typename T>
bool is_object_aligned(const T* ptr) {
    return is_aligned(ptr, alignof(T));
}

alignof 与 alignas 如何影响判断目标

alignof 看起来和 sizeof 很像，但两者描述的是不同维度。sizeof 表示对象占用的字节数，而 alignof 表示该类型对象在内存中的起始地址需要满足的约束。一个结构体里即使只有一个 char 和一个 int，其大小也会被填充到 8 字节，对齐值仍然是 4。可以使用 alignas 提高某个变量或类型的对齐值，但不能用 alignas 把对齐值降到自然对齐以下。例如 alignas(64) char buffer[64]; 会让 buffer 的起始地址 64 字节对齐，这在缓存行敏感的场景中非常有用。

当我们编写判定函数时，不要把 alignof 的结果和 sizeof 混淆。判断一个地址是否适合放某个类型，要看地址是否满足 alignof(T)，而不是看剩余的字节数是否达到 sizeof(T)。例如某地址是 6，如果 int 的对齐值是 4，那么它不能直接放 int，即使后面有 100 个字节可用也不行。这个错误在手工拼接缓冲区时很常见。

C++ 还提供了 std::alignment_of<T>::value 来获取同样的信息，不过 alignof 关键字更直接，也不需要额外包含 <type_traits>。对于超对齐类型，普通 new 在 C++17 之前可能不会返回满足超对齐要求的地址，这一点需要特别注意。现在可以用对齐版本的 new 或 aligned_alloc 来获得足够对齐的内存。无论如何，分配完成后调用一次判定函数是低成本且有效的防御手段。

指针运算的隐性偏移与实战建议

C++ 中的指针加法并不是简单的地址加 1。int* p 执行 p + 1 时，地址实际增加的是 sizeof(int) 字节。这个特性让数组遍历变得自然，但也容易让人忽略它对齐的影响。假设 p 指向一个 4 字节对齐的 int 数组首元素，那么 p + 1、p + 2 仍然满足 4 字节对齐，因为 sizeof(int) 本身就是 4 的倍数。但如果把指针转成 char* 后逐字节偏移，或者从网络包中按协议字段逐字节解析，再强制转回 int*，就会破坏对齐。

下面这段代码展示了一个常见问题：原始缓冲区本身可能对齐，但偏移 1 个字节后，地址就不再满足 int 的对齐要求。

#include <cstdint>
#include <cstddef>
#include <iostream>
int main() {
    alignas(int) char raw[8] = {0};
    int* ip = reinterpret_cast<int*>(raw + 1);
    if (!is_aligned(ip, alignof(int))) {
        std::cout << "address is misaligned for int\n";
    }
    return 0;
}

在音视频、网络协议、文件格式解析中，原始数据几乎都是以 char 或 unsigned char 形式进入程序。直接按目标结构体进行 reinterpret_cast 是最快的方式，但前提是地址已经满足目标类型的对齐要求。更稳妥的做法是使用 memcpy 把数据复制到本地对齐的变量中，或者先判断地址，再走快速路径。编译器通常会优化 memcpy 为目标类型的加载指令，因此性能损失往往可以接受。以 x86 为例，未对齐访问虽然不会出错，但跨缓存行时会产生额外周期；在 ARM 某些配置下，未对齐访问可能导致硬件异常。这正是判定函数值得存在的原因。

另一个常见的实战场景是自定义内存池。如果池子以 char 数组为存储，每次分配固定大小对象，就需要让每个对象槽位的首地址满足 alignof(T)。可以使用一个向上取整函数把地址推进到下一个对齐边界。

#include <cstdint>
#include <cstddef>
// 将地址向上对齐到 alignment 的整数倍，alignment 必须为 2 的幂
std::uintptr_t align_up(std::uintptr_t addr, std::size_t alignment) {
    assert((alignment & (alignment - 1)) == 0);
    return (addr + alignment - 1) & ~(alignment - 1);
}

该函数依旧假设 alignment 是 2 的幂。对于非 2 的幂场景，使用取模版本更安全。最终在返回指针前，再用 is_aligned 做一次断言，可以在测试阶段迅速暴露分配器的对齐错误。判断地址对齐并不是复杂的算法，但它处于类型系统、硬件约束和性能优化三者的交叉点。把 uintptr_t 转换、alignof 关键字和指针偏移规则理解清楚，很多偶发的崩溃和难以复现的性能抖动都会迎刃而解。