Pointers assignment

Question

What is the meaning of

*(int *)0 = 0;

It does compile successfully

Answer 1

Its a compilation error. You cant modify a non-lvalue.

Answer 2

there is no valid lvalue in that operation so it shouldn't compile.

the left hand side of an assignment must be... err... assignable

Answer 3

It has no meaning. That's an error. It's parsed as this

(((int)0) = 0)

Thus, trying to assign to an rvalue. In this case, the right side is a cast of 0 to int (it's an int already, anyway). The result of a cast to something not a reference is always an rvalue. And you try to assign 0 to that. What Rvalues miss is an object identity. The following would work:

int a;
(int&)a = 0;

Of course, you could equally well write it as the following

int a = 0;

Update: Question was badly formatted. The actual code was this

*(int*)0 = 0

Well, now it is an lvalue. But a fundamental invariant is broken. The Standard says

An lvalue refers to an object or function

The lvalue you assign to is neither an object nor a function. The Standard even explicitly says that dereferencing a null-pointer ((int*)0 creates such a null pointer) is undefined behavior. A program usually will crash on an attempt to write to such a dereferenced "object". "Usually", because the act of dereferencing is already declared undefined by C++.

---

Also, note that the above is not the same as the below:

int n = 0;
*(int*)n = 0;

While the above writes to something where certainly no object is located, this one will write to something that results from reinterpreting n to a pointer. The mapping to the pointer value is implementation defined, but most compilers will just create a pointer referring to address zero here. Some systems may keep data on that location, so this one may have more chances to stay alive - depending on your system. This one is not undefined behavior necessarily, but depends on the compiler and runtime-environment it is invoked in.

If you understand the difference between the above dereference of a null pointer (only constant expressions valued 0 converted to pointers yield null pointers!) and the below dereference of a reinterpreted zero value integer, i think you have learned something important.

Answer 4

It will usually cause an access violation at runtime. The following is done: first 0 is cast to an int * and that yields a null pointer. Then a value 0 is written to that address (null address) - that causes undefined behaviour, usually an access violation.

Effectively it is this code:

int* address = reinterpret_cast<int*>( 0 );
*address = 0;

Answer 5

It puts a zero on address zero. On some systems you can do this. Most MMU-based systems will not allow this in run-time. I once saw an embedded OS writing to address 0 when performing time(NULL).