为什么我们可以在 C++ 中增加指向常量数据的解引用指针？

Question

I was surprised that c++ allows incrementing dereferenced pointer to a constant data, which it should not allow through a pointer to a const data. Consider the code:

#include<iostream>
#include<climits>
using namespace std;

int main(){
    int x = 2;

    const int *xPtr2 = &x;
    *xPtr2++;
    cout << x << endl;

}

But still the value of x is 2. That means *xPtr2 was not actually incremented. I also tried *xPtr2 = 3, but this time it shows compilation error. Why is it so?

Answer 1

Here the precedence of ++ is more than that of *. Hence

*xPtr2++

is equivalent to

*(xPtr2++)

Since xPtr2 is not a constant pointer but a pointer to constant data, incrementing xPtr2 and dereferencing it is fine in this case (but not others) and hence no compilation error is caused.

Answer 2

The increment has a higher precedence than does dereferencing. So you are incrementing the pointer then dereferencing the incremented pointer. The pointer is not constant so it can be incremented.

Answer 3

The ++ operator has precedence over dereferencing. Basically you're dereferencing the pointer that has been incremented.

For the behavior you're trying to accomplish, you should wrap the pointer in parens.

(*xPtr2)++;

Same goes for assigning - you're trying to assign an int to a int * . It would work with parens.

(*xPtr2) = 3;

See your example in ideone .

Answer 4

You have mentioned

dereferencing pointer to constant data

So, lets consider the following code

#include <stdio.h>
int main() {
    const int foo = 0xdead;
    int* bar = (int*) &foo;
    *bar = 0xcafe;
    printf("const int foo = %#x", foo);
    return 0;
}

Output : const int foo = 0xcafe

In C, C++ const is just a compile time modifier for variables. This means that the compiler wants no modification to a const at compile time. At runtime there is no concept of const => all local variables are stored in stack, all static and global variables are stored in .data section. Thus you can dereference a const and modify it only at runtime