C++ pointer to constant error

Question

In a book I'm reading about C++ (C++ for Dummies) there is a section that says the following:

int nVar = 10;
int* pVar = &nVar;
const int* pcVar = pVar; // this is legal
int* pVar2 = pcVar;      // this is not

The book then goes on to explain:

The assignment pcVar = pVar; is okay -- this is adding the const restriction. The final assignment in the snippet is not allowed since it attempts to remove the const-ness of pcVar

My question is why is the last line not "legal". I don't understand how that impedes on the "const-ness" of pcVar. Thanks.

Answer 1

const int *pcVar = pVar;
int *pVar2 = pcVar;

If pcVar is const int *, that implies that the int it points to may be const. (It isn't in this case, but it may be.) So if you assign pVar2, which is a non-const int *, it still allows the int it points to to be modified.

So if pcVar actually pointed to a const int, and you assign an int * to its address, then that int * pointer (pVar2 in this case) will allow you, by dereferencing, to modify it, and that's illegal (it's a constraint violation, so it invokes undefined behavior).

Answer 2

All the compiler knows is that pcVar is a const int*. That is, it points to a const int. Just because you made it point at a non-const int doesn't matter. For all the compiler knows, the pointer value could have changed at some point to point at a truly const int. Therefore, the compiler won't let you convert from a const int* back to a int* because it would be lying about the constness of the object it was pointing at.

For a simpler example, consider:

const int x;
const int* pc = x;
int* p = pc; // Illegal

Here, x truly is a const int. If you could do that third line, you could then access the const int object through p (by doing *pc) and modify it. That would be bad - x is const for a reason.

However, in the example you gave, since you know that the original object was non-const, you could use const_cast to force the compiler into trusting you:

int* pVar2 = const_cast<int*>(pcVar); 

Note that this is only valid if you know for certain that the object is non-const.