What if the storage address and content both have the same value?

Answer 1

It means your program has undefined behaviour.

In weakly-typed languages such as C it is very easy to assign a pointer to itself but in strongly-typed languages such as C++, the type system prevents it. However, we can use a C-style cast to circumvent the type system.

Consider the following example:

#include<iostream>

int main()

{

// Declare a pointer variable.

int* p;

// Assign the pointer's address to itself using a C-style cast.

p = (int*)&p;

// Print the address of the pointer.

std::cout << "Pointer address:\t0x" << &p << std::endl;

// Print the pointer's value.

std::cout << "Pointer value:\t\t0x" << p << std::endl;

// Print the dereferenced value.

std::cout << "Dereferenced value:\t" << *p << std::endl;

// Assign a value to the address being pointed at.

*p = 42;

}

The exact address of the pointer will vary, but the output may be something like the following:

Pointer address: 0x0072FB48

Pointer value: 0x0072FB48

Dereferenced value: 7535432

The first two lines of output prove the pointer really does point to itself (the storage address and its content have the same value). The third line also proves that the pointer can be correctly dereferenced (7535432 is the decimal equivalent of 0x0072FB48).

Everything appears to work normally, but the final line of code has actually violated the type system:

*p = 42;

Think about what we're doing here. We're assigning the value 42 to the address pointed to by p. But p points to itself, thus p now holds the value 42 and is therefore pointing at memory address 42 (0x0000002A). That's clearly not what we intended but, by undermining the type safety, such errors are only inevitable. Even if memory address 42 belongs to our program, a 4-byte integer would be expected to be aligned on a 4-byte boundary but 42 is clearly not a 4-byte boundary.

Our program doesn't actually make any attempt to access address 42, so no errors will be reported. However, if this code were part of a much larger program we'd be in a whole world of hurt because it may not be immediately obvious that a problem exists until we try to dereference that pointer, which may be a long time after we assigned the value. That's a time-bomb waiting to go off!

There's also the problem of what happens when the type being pointed at is larger than that of the pointer itself. If we attempt to assign a value that will not fit inside a pointer then we'd end up overwriting memory that doesn't actually belong to the pointer.

Either way we introduce undefined behaviour. Even if our program appears to work as intended (as in the example above), it makes no sense to deliberately undermine a system that is intended to prevent such problems arising in the first place.