为什么不能在之后设置 const 指针？

Question

I know this is probably a trivial question. What is the logic behind not being able to set a const pointer after its declaration? It's not as if allocating memory will change the starting address which is what the const refers to. So why can't this...

int* const p;
p = new int [10];

... be done... which also prohibits the passing of a const pointer into a function?

Answer 1

This is the entire purpose of const .

const stands for "constant", and means the object cannot be assigned to.

If you want the pointer to be a variable, don't make it const .

I suspect you were expecting your assignment to be allowed because it was the first ever assignment to that object. You were wrong! This is the purpose of initialisation , which you are not presently using.

I'm guessing you meant to write:

int* const p = new int[10];

---

But I worry that you have more fundamental misconceptions here. For example:

It's not as if allocating memory will change the starting address

Yes, it absolutely, completely will.

When your p comes into existence, it has an unspecified value. Its value is not a "starting address" that you can use.

Then you assign to it (though you ought to have initialised instead). It takes on the value equals to the pointer returned by new . That pointer has no relationship to anything previous in your code.

Answer 2

Allocating memory does change the address. For instance if we have

int * foo;
foo = new int[bar];

foo is uninitialized and has a garbage value. Then foo = new int[bar]; assigns to foo a new address that is the start of a block of bar int s.

Now when you have

int* const p;

The pointer is const so we cannot change it after it is initialized.

Answer 3

Short version

The way you are defining the pointer means that it is const for itself, so you cannot reassign it and you have actually to assign it along with its declaration .

Here more details about the const keyword, even though it is not specifically oriented to the use with the pointers.

Please even note that the following code should not compile for you are not assigning a value to the const pointer p :

int main() {
    int * const p;
}

The same is true for the following one:

int main() {
    int const i;
}

It doesn't depend on the fact that you are dealing with a pointer, instead it's how the const keyword actually works and should/can be used.

---

More details about const and pointers

Anyway, I didn't see your whole code and it looks to me that your intent is not to have a const pointer, instead in your case it could help having a pointer to const (but it mainly depends on your problem, so I can be wrong). How to define them depends on your purposes, of course.

You can either define it as a const pointer or a pointer to a const value, the means of which are slightly different (of course, you can also define a pointer as a const pointer to a const value, that is an easily deducible consequence of the others above mentioned).

The first one indicates that the pointer itself cannot be reassigned, thus you have to assign it during the declaration and that's all. The second one instead define a pointer that is reassignable, but you can assign it only addresses of const variables of the given type (or better, even if they are defined as non const, they will be treated as const when accessed through that pointer, with all the limitations of the case).

It follows a brief example of the types of const pointer and pointer to const above mentioned:

int main() {
    int i;
    // pointer to const int
    int const *icp;
    // const pointer to int
    int * const cip = &i;
    // const pointer to const int
    int const * const cicp = &i;
    // this one can be reassigned, of course
    icp = &i;
}

Note also that int const and const int are interchangeable, so the declarations below are equivalent:

int const *p;
const int *p;

Obviously, this is not an exhaustive list. I've only tried to give you more details about how the const keyword can be used while defining a pointer and which are the intended means of those declarations.

Answer 4

int* const p;

declares p to be a pointer which cannot be changed, ie you cannot change where it points to once it is initialized. However, you can change the values it points to since the object type it points to is int .

int* const p = new int [10];
p = new int[20]; // Not OK
p[0] = 100;      // OK

Contrast that with

int const* p = new int [10];
p = new int[20]; // OK. You can change where the pointer points to.
p[0] = 100;      // Not OK. You cannot change the value of what p points to.