In order: Yes. GCC will assume that the pointers cannot alias. For instance, if you assign through one then read from the other, GCC may, as an optimisation, reorder the read and write – I have seen this happen in production code, and it is not pleasant to debug. Several. You could use a union … Read more
The standard may fail to say properly that this is allowed, but it’s almost certainly supposed to be, and to the best of my knowledge, all implementations will treat this as defined behaviour. In order to facilitate the copying into an actual char[N] object, the bytes making up the f object can be accessed as … Read more
The disrepancy is issued by -fstrict-aliasing optimization option. Its behavior and possible traps are described in GCC documentation: Pay special attention to code like this: union a_union { int i; double d; }; int f() { union a_union t; t.d = 3.0; return t.i; } The practice of reading from a different union member than … Read more
No horror story of my own, but here are some quotes from Linus Torvalds (sorry if these are already in one of the linked references in the question): http://lkml.org/lkml/2003/2/26/158: Date Wed, 26 Feb 2003 09:22:15 -0800 Subject Re: Invalid compilation without -fno-strict-aliasing From Jean Tourrilhes <> On Wed, Feb 26, 2003 at 04:38:10PM +0100, Horst … Read more
Why can’t the C Compiler optimize the first line away, under the assumption, that two pointers to the same variable would be illegal/UB? Because you haven’t instructed the C compiler to do so — that it is allowed to make that assumption. C has a type qualifier for exactly this called restrict which roughly means: … Read more
Ok, let’s get truly pedantic. After reading this, this and this, I’m pretty confident that I understand the intention behind both Standards. So, doing reinterpret_cast from std::uint8_t* to char* and then dereferencing the resulting pointer is safe and portable and is explicitly permitted by [basic.lval]. However, doing reinterpret_cast from char* to std::uint8_t* and then dereferencing … Read more
At first glance, I thought the compiler could generate equivalent assembly for both versions with optimization flags activated. When I checked it, I was surprised to see the result: Source unoptimized.cpp note: this code is not meant to be executed. struct bitmap_t { long long width; } bitmap; int main(int argc, char** argv) { for … Read more
Pointer aliasing seems to be the problem, ironically between this and this->target. The compiler is taking into account the rather obscene possibility that you initialized: this->target = &this In that case, writing to this->target[0] would alter the contents of this (and thus, this->target). The memory aliasing problem is not restricted to the above. In principle, … Read more
A typical situation where you encounter strict aliasing problems is when overlaying a struct (like a device/network msg) onto a buffer of the word size of your system (like a pointer to uint32_ts or uint16_ts). When you overlay a struct onto such a buffer, or a buffer onto such a struct through pointer casting you … Read more