What is the strict aliasing rule?

When it comes to programming in languages like C and C++, understanding the rules and guidelines is essential to ensure the reliability and correctness of our code. One of the concepts that often pops up in discussions about undefined behavior in C is the strict aliasing rule.

What is the strict aliasing rule?

The strict aliasing rule is a concept in C and C++ that governs how pointers of different types can be used to access the same memory location. According to the strict aliasing rule, two pointers of different types are not allowed to reference the same memory location and access the stored value without violating the rules of the programming language.

When this rule is violated, it leads to undefined behavior, which means that the program's behavior becomes unpredictable. The consequences of undefined behavior can be severe, ranging from unexpected crashes to incorrect output.

Understanding type punning

Type punning refers to the practice of accessing data of one type as if it were of another type. It allows programmers to interpret the binary representation of data in memory differently. This technique can be useful in some situations, but it also introduces potential pitfalls and is closely related to the strict aliasing rule.

For example, let's consider the following code:

            int main() {
                int i = 42;
                float* f_ptr = (float*)&i
                *f_ptr = 3.14;
                printf("%d\n", i);
                return 0;

In this code snippet, we create an integer variable i with a value of 42. Then, we create a pointer f_ptr of type float*, which we use to access the memory location of i by casting its address to a pointer of type float*. Finally, we assign the value 3.14 to the memory location pointed to by f_ptr and print the value of i.

According to the strict aliasing rule, accessing the memory location of i through f_ptr violates the rule since f_ptr is not of the same type as i. As a result, the behavior of this code is undefined, and the output can be different depending on the compiler, optimization settings, and platform.

It's important to note that using unions in C is an exception to the strict aliasing rule. Unions allow different types to share the same memory location, and, therefore, accessing the same memory location using different types is legal.

Why does the strict aliasing rule exist?

The strict aliasing rule exists to allow efficient optimizations in programming languages like C and C++. By restricting which pointers can access the same memory location, the compiler can make assumptions about the behavior of the code and optimize it accordingly.

When the strict aliasing rule is followed, the compiler can safely assume that two pointers of different types do not refer to the same memory location. This allows the compiler to make certain assumptions about the nature of the code and generate more efficient machine code. Violating the strict aliasing rule can prevent these optimizations from happening correctly, leading to potentially slower and less optimized code.

How to avoid strict aliasing violations

To avoid violating the strict aliasing rule, it is important to follow certain guidelines and best practices when writing C and C++ code. Here are some tips:

  • Use unions when you need to access the same memory location with different types.
  • Avoid casting pointers to unrelated types.
  • If you need to reinterpret the binary representation of data, consider using tools like offsetof or reinterpret_cast.
  • Avoid relying on undefined behavior and write code that is portable and well-defined.
  • Be aware of compiler-specific behavior and differences across different platforms.
  • Use compiler flags and optimizations to warn or error out on strict aliasing violations.


The strict aliasing rule is an important concept to understand in C and C++. By following this rule, we can ensure that our code is reliable, well-defined, and optimized. Violating the strict aliasing rule can lead to undefined behavior and unexpected results. By adhering to best practices and guidelines, we can avoid strict aliasing violations and write code that is portable and efficient.