注意
这摘自我的“严格的混叠规则是什么，我们为什么要关心？” 写上去。
什么是严格的别名？
在C和C ++中，别名与允许我们通过哪些表达式类型访问存储的值有关。在C和C ++中，标准均指定允许使用哪种表达式类型作为别名的别名。允许编译器和优化器假定我们严格遵循别名规则，因此，术语“ 严格别名规则”。如果我们尝试使用不允许的类型访问值，则将其分类为未定义行为（UB）。一旦我们具有不确定的行为，所有的赌注都将关闭，我们的程序结果将不再可靠。
不幸的是，在严格违反别名的情况下，我们通常会获得预期的结果，从而可能会出现带有新优化的编译器未来版本破坏我们认为有效的代码的可能性。这是不希望的，并且了解严格的别名规则以及如何避免违反它们是一个值得的目标。
要了解有关我们为何关心的更多信息，我们将讨论在违反严格的别名规则，类型修剪时会出现的问题，因为类型修剪中使用的常见技术通常会违反严格的别名规则以及如何正确键入pun。
初步例子
让我们看一些示例，然后我们可以确切讨论标准所说的内容，研究其他示例，然后看看如何避免严格的混叠并捕获我们错过的违规行为。这是一个不足为奇的示例（实时示例）：
int x = 10;
int *ip = &x;
std::cout << *ip << "\n";
*ip = 12;
std::cout << x << "\n";
我们有一个INT *指向占用内存由INT这是一个有效的别名。优化器必须假定通过ip进行分配可以更新x占用的值。
下一个示例显示了导致未定义行为的别名（实时示例）：
int foo( float *f, int *i ) {
*i = 1;
*f = 0.f;
return *i;
}
int main() {
int x = 0;
std::cout << x << "\n"; // Expect 0
x = foo(reinterpret_cast<float*>(&x), &x);
std::cout << x << "\n"; // Expect 0?
}
在函数foo中，我们使用int *和float *，在此示例中，我们调用foo并将两个参数设置为指向相同的内存位置，该内存位置在此示例中包含int。注意，reinterpret_cast告诉编译器将表达式视为具有其模板参数指定的类型。在这种情况下，我们告诉它将表达式＆x视为具有float *类型。我们可以天真地期待第二的结果COUT是0，但与优化使用支持-02 GCC和铛产生如下结果：
0
1
因为我们已经调用了未定义的行为，所以这可能不是预期的，但却是完全有效的。甲浮子不能有效别名一个INT对象。因此，优化器可以假定在解引用i时存储的常数1将是返回值，因为通过f进行的存储不能有效地影响int对象。将代码插入Compiler Explorer可以显示这正是正在发生的情况（实时示例）：
foo(float*, int*): # @foo(float*, int*)
mov dword ptr [rsi], 1
mov dword ptr [rdi], 0
mov eax, 1
ret
使用基于类型的别名分析（TBAA）的优化器假定将返回1，并将常数直接移到带有返回值的寄存器eax中。TBAA使用关于允许使用哪种类型的别名的语言规则来优化负载和存储。在这种情况下，TBAA知道float不能别名和int并优化了i的负载。
现在，到规则书
该标准确切说明允许和禁止我们做什么？标准语言不是很简单，因此我将为每一项尝试提供代码示例以说明其含义。
C11标准怎么说？
在C11标准说，在节以下6.5表达式第7段：
一个对象只能通过具有以下类型之一的左值表达式访问其存储值：88）
—与该对象的有效类型兼容的类型，
int x = 1;
int *p = &x;
printf("%d\n", *p); // *p gives us an lvalue expression of type int which is compatible with int
—与对象的有效类型兼容的类型的限定版本，
int x = 1;
const int *p = &x;
printf("%d\n", *p); // *p gives us an lvalue expression of type const int which is compatible with int
—一种类型，它是与对象的有效类型相对应的有符号或无符号类型，
int x = 1;
unsigned int *p = (unsigned int*)&x;
printf("%u\n", *p ); // *p gives us an lvalue expression of type unsigned int which corresponds to
// the effective type of the object
gcc / clang有一个扩展，并且即使它们不是兼容类型，也允许将unsigned int *分配给int *。
—是与对象的有效类型的限定版本相对应的有符号或无符号类型的类型，
int x = 1;
const unsigned int *p = (const unsigned int*)&x;
printf("%u\n", *p ); // *p gives us an lvalue expression of type const unsigned int which is a unsigned type
// that corresponds with to a qualified verison of the effective type of the object
—集合或联合类型，其成员中包括上述类型之一（递归地包括子集合或包含的联合的成员），或
struct foo {
int x;
};
void foobar( struct foo *fp, int *ip ); // struct foo is an aggregate that includes int among its members so it can
// can alias with *ip
foo f;
foobar( &f, &f.x );
—字符类型。
int x = 65;
char *p = (char *)&x;
printf("%c\n", *p ); // *p gives us an lvalue expression of type char which is a character type.
// The results are not portable due to endianness issues.
C ++ 17草案标准怎么说
[basic.lval]第11段中的C ++ 17标准草案说：
如果程序尝试通过以下类型之一以外的glvalue访问对象的存储值，则行为未定义：63
（11.1）—对象的动态类型，
void *p = malloc( sizeof(int) ); // We have allocated storage but not started the lifetime of an object
int *ip = new (p) int{0}; // Placement new changes the dynamic type of the object to int
std::cout << *ip << "\n"; // *ip gives us a glvalue expression of type int which matches the dynamic type
// of the allocated object
（11.2）—对象的动态类型的cv限定版本，
int x = 1;
const int *cip = &x;
std::cout << *cip << "\n"; // *cip gives us a glvalue expression of type const int which is a cv-qualified
// version of the dynamic type of x
（11.3）—与对象的动态类型类似的类型（定义见7.5），
（11.4）—一种类型，是与对象的动态类型相对应的有符号或无符号类型，
// Both si and ui are signed or unsigned types corresponding to each others dynamic types
// We can see from this godbolt(https://godbolt.org/g/KowGXB) the optimizer assumes aliasing.
signed int foo( signed int &si, unsigned int &ui ) {
si = 1;
ui = 2;
return si;
}
（11.5）—一种类型，是与对象的动态类型的CV限定版本相对应的有符号或无符号类型，
signed int foo( const signed int &si1, int &si2); // Hard to show this one assumes aliasing
（11.6）—聚合或联合类型，在其元素或非静态数据成员（包括递归地包括子聚合或所包含的联合的元素或非静态数据成员）中包括上述类型之一，
struct foo {
int x;
};
// Compiler Explorer example(https://godbolt.org/g/z2wJTC) shows aliasing assumption
int foobar( foo &fp, int &ip ) {
fp.x = 1;
ip = 2;
return fp.x;
}
foo f;
foobar( f, f.x );
（11.7）—一种类型，它是对象的动态类型的（可能具有cv限定的）基类类型，
struct foo { int x ; };
struct bar : public foo {};
int foobar( foo &f, bar &b ) {
f.x = 1;
b.x = 2;
return f.x;
}
（11.8）— char，unsigned char或std :: byte类型。
int foo( std::byte &b, uint32_t &ui ) {
b = static_cast<std::byte>('a');
ui = 0xFFFFFFFF;
return std::to_integer<int>( b ); // b gives us a glvalue expression of type std::byte which can alias
// an object of type uint32_t
}
值得一提的是，上面的列表中未包括带符号的char，这与C表示字符类型的显着区别。
什么是Type Punning
我们到了这一点，我们可能想知道，为什么要别名呢？答案通常是键入pun，通常所使用的方法违反严格的别名规则。
有时我们想绕过类型系统，并将对象解释为其他类型。这称为type punning，用于将内存段重新解释为另一种类型。对于需要访问对象的基础表示形式以进行查看，传输或操作的任务，类型修剪非常有用。我们发现使用的类型修剪的典型领域是编译器，序列化，网络代码等。
传统上，这是通过获取对象的地址，将其转换为我们要重新解释为该类型的指针，然后访问该值或换句话说通过别名来实现的。例如：
int x = 1 ;
// In C
float *fp = (float*)&x ; // Not a valid aliasing
// In C++
float *fp = reinterpret_cast<float*>(&x) ; // Not a valid aliasing
printf( "%f\n", *fp ) ;
如前所述，这不是有效的别名，因此我们正在调用未定义的行为。但是传统上，编译器没有利用严格的别名规则，这种类型的代码通常只能工作，不幸的是，开发人员已经习惯了这种方式。一种类型为punning的常见替代方法是通过联合，该联合在C中有效，但在C ++中为未定义行为（请参见实时示例）：
union u1
{
int n;
float f;
} ;
union u1 u;
u.f = 1.0f;
printf( "%d\n”, u.n ); // UB in C++ n is not the active member
这在C ++中无效，并且某些人认为联合的目的仅仅是实现变体类型，并且觉得使用联合进行类型修剪是一种滥用。
我们如何正确键入Pun？
在C和C ++中进行类型修剪的标准方法是memcpy。这看起来似乎有点费劲，但是优化器应该认识到使用memcpy进行类型修剪并对其进行优化，并生成一个寄存器来记录移动。例如，如果我们知道int64_t与double大小相同：
static_assert( sizeof( double ) == sizeof( int64_t ) ); // C++17 does not require a message
我们可以使用memcpy：
void func1( double d ) {
std::int64_t n;
std::memcpy(&n, &d, sizeof d);
//...
在足够的优化级别上，任何体面的现代编译器都会生成与前面提到的用于punning类型的reinterpret_cast方法或union方法相同的代码。检查生成的代码，我们看到它仅使用了mov（实时Compiler Explorer示例）。
C ++ 20和bit_cast
在C ++ 20中，我们可能会获得bit_cast（在proposal的链接中可用的实现），该类型提供了一种简单安全的方法来进行pun-pun操作，并可以在constexpr上下文中使用。
以下是如何使用bit_cast将pun 无符号int类型为pun 进行浮动的示例（请现场观看）：
std::cout << bit_cast<float>(0x447a0000) << "\n" ; //assuming sizeof(float) == sizeof(unsigned int)
如果To和From类型的大小不同，则需要我们使用中间struct15。我们将使用一个包含sizeof（unsigned int）字符数组的结构（假定4字节unsigned int）作为From类型，而unsigned int作为To类型。
struct uint_chars {
unsigned char arr[sizeof( unsigned int )] = {} ; // Assume sizeof( unsigned int ) == 4
};
// Assume len is a multiple of 4
int bar( unsigned char *p, size_t len ) {
int result = 0;
for( size_t index = 0; index < len; index += sizeof(unsigned int) ) {
uint_chars f;
std::memcpy( f.arr, &p[index], sizeof(unsigned int));
unsigned int result = bit_cast<unsigned int>(f);
result += foo( result );
}
return result ;
}
不幸的是，我们需要这种中间类型，但这是bit_cast的当前约束。
捕捉严格的混叠违规
我们没有很多很好的工具来捕获C ++中的严格别名，我们拥有的工具将捕获某些情况下的严格别名冲突以及某些情况下的装入和存储未对齐。
使用标志-fstrict-aliasing和-Wstrict-aliasing的 gcc 可以捕获某些情况，尽管并非没有假阳性/阴性。例如，以下情况将在gcc中生成警告（实时查看）：
int a = 1;
short j;
float f = 1.f; // Originally not initialized but tis-kernel caught
// it was being accessed w/ an indeterminate value below
printf("%i\n", j = *(reinterpret_cast<short*>(&a)));
printf("%i\n", j = *(reinterpret_cast<int*>(&f)));
尽管它不会捕获这种额外的情况（请现场直播）：
int *p;
p=&a;
printf("%i\n", j = *(reinterpret_cast<short*>(p)));
尽管clang允许使用这些标志，但显然并没有实际实现警告。
我们提供给我们的另一个工具是ASan，它可以捕获未对齐的负载和存储。尽管这些不是直接的严格混叠违例，但是它们是严格混叠违例的常见结果。例如，以下情况在使用-fsanitize = address与clang 一起构建时会生成运行时错误
int *x = new int[2]; // 8 bytes: [0,7].
int *u = (int*)((char*)x + 6); // regardless of alignment of x this will not be an aligned address
*u = 1; // Access to range [6-9]
printf( "%d\n", *u ); // Access to range [6-9]
我将推荐的最后一个工具是C ++特定的，而不是严格的工具，而是编码实践，不允许C样式转换。gcc和clang都将使用-Wold-style-cast为C样式转换生成诊断。这将强制所有未定义类型的双关语使用reinterpret_cast，通常rerefly_cast应该是进行更仔细代码审查的标志。在您的代码库中搜索reinterpret_cast来执行审核也更加容易。
对于C，我们已经涵盖了所有工具，并且我们还拥有tis解释器，这是一个静态分析器，可以对程序的大部分C语言进行详尽的分析。给定较早示例的C版本，其中使用-fstrict-aliasing会遗漏一种情况（现场直播）
int a = 1;
short j;
float f = 1.0 ;
printf("%i\n", j = *((short*)&a));
printf("%i\n", j = *((int*)&f));
int *p;
p=&a;
printf("%i\n", j = *((short*)p));
tis-interpeter可以捕获全部三个，以下示例将tis-kernal用作tis-解释器（为简洁起见，对输出进行了编辑）：
./bin/tis-kernel -sa example1.c
...
example1.c:9:[sa] warning: The pointer (short *)(& a) has type short *. It violates strict aliasing
rules by accessing a cell with effective type int.
...
example1.c:10:[sa] warning: The pointer (int *)(& f) has type int *. It violates strict aliasing rules by
accessing a cell with effective type float.
Callstack: main
...
example1.c:15:[sa] warning: The pointer (short *)p has type short *. It violates strict aliasing rules by
accessing a cell with effective type int.
最后是目前正在开发中的TySan。该清理程序在影子内存段中添加类型检查信息，并检查访问是否违反别名规则。该工具可能应该能够捕获所有混叠违规行为，但可能会有较大的运行时开销。
c和标记这个问题c++faq。