Conceptually, dereferencing a pointer then taking the address of the result is a no-op, you get back what you put in. There's no requirement for dereferencing a null pointer to segfault, only an expectation of many modern commodity-system programmers. Some systems allow you to dereference NULL and just return a bunch of zeros there. It's allowed by C and C++.

The real question is, how does anyone compile without "-Wall -Werror" in 2015? Ignoring your compiler when it tells you your code is wrong is negligence.

It's not dereferencing NULL that causes the segfault, its the actual reading or writing of the memory at the invalid address. So, ignoring undefined behavior etc, "* ptr;" doesn't actually generate a load or store since its not really doing anything, but "x = * ptr;" or "* ptr = x;" would. You can also see similar behavior when calling a non-virtual member function on a NULL pointer, the crash doesn't occur until the function actually tries to access some data on "this".

This is all with the caveat that the actual behavior depends on the system and compiler as many others have pointed out.

In C++, dereferencing a pointer doesn't give you a value: it gives you a "reference". While a compiler is possibly allowed to do so, I would be shocked to the point of saying "this compiler doesn't work" at a compiler that actually went out of its way, even with optimizations turned off (as this isn't an optimization issue), to access the memory at the address of the pointer in any way if the reference was never actually used.