关于C++标准中static_cast与reinterpret_cast内存对齐要求的技术咨询

Hey there, let’s break down your questions about C++ alignment rules and how they interact with static_cast and reinterpret_cast—this stuff can feel abstract, so we’ll use your examples to make it concrete.

1. Static_cast & Alignment (N4885 7.6.1.9) #

First, let’s restate the clause you’re confused about:

指向cv1 void的纯右值可转换为指向cv2 T的纯右值（T为对象类型，且cv2的const/volatile限定与cv1相同或更严格）。若原指针值对应的内存地址A不满足T的对齐要求，则结果指针值未指定。

What "meets T’s alignment requirement" means #

A memory address A meets the alignment requirement for type T if and only if A is an integer multiple of alignof(T)—the compiler’s required alignment boundary for T. For most systems:

• alignof(int) = 4
• alignof(double) = 8
• alignof(short) = 2

Your Example Analysis #

Let’s walk through your code snippets:

Example 1: Casting int* to double* via void*

int i = 12;
double *pd = static_cast<double *>(static_cast<void *>(&i));

The address of i (&i) is aligned to 4 bytes (since int requires 4-byte alignment). But double requires 8-byte alignment, so &i is not a multiple of 8. This violates the clause’s requirement, so pd’s value is 未指定 (unspecified). Any attempt to dereference pd is undefined behavior (UB)—don’t do this.

Example 2: Casting int* to short* via void*

short *ps = static_cast<short *>(static_cast<void *>(&i));

&i is aligned to 4 bytes, which is a multiple of alignof(short) (2). This meets the alignment requirement, so ps will hold the valid address of i. Dereferencing ps is technically allowed (though you’re reading the first 2 bytes of i—just be aware of type aliasing rules here).

Developer Takeaways & Pitfalls to Avoid #

• Always verify that the original address meets the target type’s alignment before casting a void* to a typed pointer.
• Avoid: Casting pointers from smaller-alignment types (like int*, 4-byte align) to larger-alignment types (like double*, 8-byte align) unless you’ve explicitly ensured the address is properly aligned (e.g., using alignas(double) to declare the variable).

2. Reinterpret_cast & Alignment (N4885 7.6.1.10 Note 7) #

Next, let’s tackle the reinterpret_cast note:

将指向T1类型对象的T1指针转换为指向T2的指针（T2为对象类型，且T2的对齐要求不严格于T1），再转换回原类型时，结果为原指针值。

What "T2’s alignment requirement is no stricter than T1" means #

"Stricter" here refers to a higher alignment boundary. So:

• If alignof(T2) <= alignof(T1), T2’s alignment requirement is no stricter than T1’s (T1 needs a more restrictive alignment, T2 is looser).
• Your static_assert(alignof(T1) >= alignof(T2)) check is exactly the right way to verify this condition.

Your Example Analysis #

Let’s apply this to your code:

Example 1: Casting int* to double* directly

int i = 34;
double *pd = reinterpret_cast<double *>(&i);

alignof(int) = 4, alignof(double) = 8—so double’s alignment requirement is stricter than int’s. This violates the note’s condition, so:

• The value of pd is unspecified.
• Casting pd back to int* is not guaranteed to return the original &i value.
• Dereferencing pd is UB.

Example 2: Casting int* to short* directly

short *ps = reinterpret_cast<short *>(&i);

alignof(int) =4 >= alignof(short)=2, so T2’s alignment is no stricter than T1’s. This means:

• ps holds a valid address.
• Casting ps back to int* will definitely return the original &i value.
• Again, be cautious with dereferencing: while alignment is fine, type aliasing rules restrict accessing an int via a short* (except for char/unsigned char pointers).

Developer Takeaways & Pitfalls to Avoid #

• Use reinterpret_cast between pointer types only if you need low-level memory access, and always check alignment with alignof if you plan to cast back to the original type.
• Avoid: Casting from lower-alignment types to higher-alignment types—this breaks the guarantee that casting back will give you the original pointer, and risks UB.

General Alignment Best Practices #

• Use alignof(T) to check a type’s alignment requirement at compile time.
• For manually allocated memory (e.g., malloc), use aligned_alloc if you need a specific alignment.
• Unaligned memory access isn’t just UB—it can also cause significant performance hits on modern CPUs, which are optimized for aligned access.

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