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.

`int pVar = &nVar` isn't legal - you're converting an integer to a pointer to integer. I suspect this is a typo, but you may wisht o correct it. — Nik Bougalis, Mar 05 '13 at 19:06
There are no assignments in that code, and any book that refers to these initializations as such shouldn't be suitable for reading. — chris, Mar 05 '13 at 19:06
Actually it is like that in the book. I don't know if it is a typo but does the question still make sense if I were to correct that? — Iowa15, Mar 05 '13 at 19:07
it might be a typo in the book, it definitely should be `int * pVar = &nVar`; you should correct it just so as not to confuse other visitors later — Stephen Lin, Mar 05 '13 at 19:09

score 3 · Accepted Answer · 2013-03-05T19:20:46.507

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).

score 2 · Answer 2 · edited May 23 '17 at 12:03

It's just saying you can't create a non-const pointer from one that was const (at least, not without a const_cast).

The idea behind const is to have objects that cannot be modified by accident. Getting rid of const through a simple assignment would be quite dangerous, and would allow things like this:

void function(int* m) {
    *m = 20;
}

int main() {
    const int x = 10;
    //Oops! x isn't constant inside function any more, and is now 20!
    function(&x); 
}

Also, please check out The Definitive C++ Book and Guide List, it has lots of great references (C++ for dummies doesn't quite make the cut).

score 2 · Answer 3 · answered Mar 05 '13 at 19:08

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.

score 1 · Answer 4 · answered Mar 05 '13 at 19:07

1

Mixing const and non-const is illegal. The reason being, if you tell the compiler that one location's value is const and then use another pointer to modify that value, you have violated the const contract you made with the first element.

answered Mar 05 '13 at 19:07

Michael Dorgan

12,453
3
31
61

score 1 · Answer 5 · answered Mar 05 '13 at 19:08

pcVar stays the same but pVar2 points to a non-const, const can be added but not taken away. The compiler does not look at the original nVar being non-const, only the attempt to assign a const to a non const. Otherwise you could get around the const and change the value.

score 1 · Answer 6 · answered Mar 05 '13 at 19:10

int * pVar = &nVar;
*pVar = 4 //is legal

const int* pcVar = pVar; // this is legal
*pcVar = 3 // this is not legal, we said the value was const thus it can not be changed

int* pVar2 = pcVar;      // this is not legal because...
*pVar2 = 3 -> *pcVar = 3

score 1 · Answer 7 · answered Mar 05 '13 at 19:11

1

The second line int pVar = &nVar; is error. g++ compiler says. error: invalid conversion from ‘int*’ to ‘int’

answered Mar 05 '13 at 19:11

Bijaya Bidari

331
2
12

C++ pointer to constant error

7 Answers7