What is the Strict Aliasing Rule in C++?

A plain pointer cast in C++ can cause undefined behavior, which results in crashes or wrong output. Strict aliasing is a rule followed by compilers that most unknowingly violate, resulting in unpredictable behavior. If you have ever used reinterpret_cast or type casting, you may be vulnerable! By allowing the safe alternatives such as std::memcpy, std::bit_cast, unsigned char*, and unions to exist. This article explains what strict aliasing is, why it’s dangerous, and how to code safely and efficiently.

Table of Contents:

• What is Strict Aliasing in C++?
• Working of Strict Aliasing in C++
• How Compiler Optimizes the Strict Aliasing
• Safe Alternatives to Avoid Strict Aliasing in C++
  • Using std::memcpy To Avoid Strict Aliasing
  • Using std::bit_cast To Avoid Strict Aliasing
  • Using unsigned char* To Avoid Strict Aliasing
  • Using Union Type Punning To Avoid Strict Aliasing
  • Summary of Exceptions
• Detecting Strict Aliasing Violations
  • Ways to Detect the Violations
• Conclusion

What is Strict Aliasing in C++?

The Strict Aliasing Rule is an optimization rule in C++ (and C) that allows the compiler to assume that pointers of different types do not point to the same memory. This enables aggressive code optimization by the compiler. If you violate it, it may lead to “undefined behavior”, and your program can crash and give you wrong results.

Working of Strict Aliasing in C++

In C++, strict aliasing specifies that pointers to different types are assumed not to alias, i.e., they do not point to the same memory location. Optimizing the code becomes easy, but it may lead to undefined behavior.

For example, if we store the 42 in an int* then store it in 3.14f into a float* pointing to the same location,  we might violate the compiler’s expectations about memory access and thus the compiler won’t reload the int’s value while printing it, assuming the float write hasn’t affected it. This may even sometimes lead to incorrect output or a crash. If it is necessary to convert to a pointer to an incompatible type, use std::memcpy or std::bit_cast (since C++20) instead of casting between incompatible types to avoid breaking strict aliasing.

Let’s check a program and see how strict aliasing works

Example:

Output:

In this example, int* and float* overlap, but the compiler doesn’t have the information to know that they overlap, which causes it to optimize out the *ip = 42; line and could yield bad results. For safely accessing memory across types, use std::memcpy or std::bit_cast (C++20). As a side effect, this helps prevent undefined behavior, as well as improving performance.

How Compiler Optimizes the Strict Aliasing

The compiler assumes that different types never alias unless you explicitly allow it to. This means:

• It reorders the loads/stores based on type information.
• It eliminates unnecessary memory reads since it assumes that the memory has not changed.
• It keeps values in registers instead of loading them again from memory.

Safe Alternatives to Avoid Strict Aliasingin C++

There are some safe alternatives to avoid strict aliasing by using std::memcpy, std::bit_cast, and unsigned char*.

1. Using std::memcpy To Avoid Strict Aliasing

std::memcpy is a safe way to access the same memory with different types without breaking strict aliasing. With memcpy, you’re copying the memory byte by byte, allowing the compiler to treat it properly, instead of directly casting a pointer over (which leads to Undefined Behaviour). This also makes sure that no incorrect optimizations take place while the original data still exists.

Example:

Output:

In the above code, we use std::memcpy to avoid the direct casting of float*  to an int* to copy the raw memory of float* to an int. To avoid the undefined behavior, this makes sure that the

2. Using std::bit_cast To Avoid Strict Aliasing

std::bit_cast (added in C++20) allows a reinterpretation of memory without breaking the strict aliasing rule. It copies the source data bitwise into a new type by itself, preventing the compiler from optimizing this away. Unlike pointer casting (reinterpret_cast), std::bit_cast does not create undefined behavior as it preserves the full bit pattern of the original data.

Example:

Note: The above code doesn’t support normal compilers, it only works in C++ 20 compilers.

In the above code, std::bit_cast(f) safely reinterprets the float as an int without violating strict aliasing. This function ensures that the conversion is done at the binary level and does not get optimized away by the compiler, which can lead to undefined behavior.

3. Using unsigned char* To Avoid Strict Aliasing

In C++, the strict aliasing rule, without violating strict aliasing rules, an unsigned char* can access the raw memory of any object, which also made it easy for binary data manipulation, serialization, and debugging.

Example:

Output:

In the above code, we declare the struct data with an int and float and assign the unsigned char* to the struct data for reading its raw memory as bytes. Here, we print each byte in hexadecimal to make sure of how the data is stored. This approach is useful for debugging, serialization, and analyzing the low-level memory.

4. Using Union Type Punning To Avoid Strict Aliasing

In C++, this is another safe method to access the same memory as different types without causing undefined behavior. In the union type punning method, the different members of a union share the same memory without violating the strict aliasing rule.

Example:

Output:

A union has memory sharing for other types, without violating strict aliasing, by allowing type punning. Putting 3.14f in d.f and reading it out as d.i produces an unexpected integer value because it reads out the binary form of the float.

Summary of Exceptions

Detecting Strict Aliasing Violations

Strict aliasing violations can be silently undefined behavior instead of a compiler error, and flags can help in locating potential trouble spots. In GCC and Clang, -fstrict-aliasing enables strict aliasing optimizations, and -Wstrict-aliasing emits warnings on code that violates strict aliasing rules.

Running the following code along with these flags can make you able to capture if you are facing the aliasing issue or not:

Example:

Output:

1078523331 is the result of reading the binary representation of 3.14f interpreted as an int. This is why the behavior is the opposite of what we expect because reinterpret_cast does not modify the bit representation of objects, and objects do not alias, so the compiler optimizes according to a completely different rule, breaking all strict aliasing rules. Here, it depends on how the float value 3.14f is stored in memory and then fetched from memory as an int.

Ways to Detect the Violations

Compile with GCC or CLANG using:

g++ -std=c++17 -O2 -Wall -Wstrict-aliasing test.cpp

The compiler diagnoses strict aliasing violations at compile-time, emitting warnings or leading to undefined behavior at runtime. Use std::memcpy or std::bit_cast (C++20) instead to avoid this issue.

Conclusion

Strict aliasing is a great C++ optimization rule, as it leads to efficient memory access, but it also causes undefined behavior if the rule is violated. Type-punning using different types inappropriately violates strict aliasing and could generate any kind of compiler optimization (but this is an edge-case, as it is referred to a portability problem), however safe type-punning can be guaranteed using a few grown-ups, eg std::memcpy, std::bit_cast (C++20) or unsigned char* which are legal bypass for strict aliasing. On the other hand, flagging violations with compiler flags, e.g., -Wstrict-aliasing, can help debug problems. Because the more correct a programming model is, the more performant it is, strict aliasing is key to low-level programming, embedded systems, and performance-critical programs using best practices.

FAQs on What is the strict aliasing rule in C++