从char * *变量分配给char * const *变量-为什么允许它？

Question

I am surprised that the following behavior of C++ (Visual Studio 2012 compiler).

char * * PointerToPointerToChar = NULL;
char * const * PointerToConstPointerToChar = NULL;
char const * * PointerToPointerToConstChar = NULL;

PointerToPointerToConstChar = PointerToPointerToChar; // Assignment 1: Gives compiler error as I would expect
PointerToConstPointerToChar = PointerToPointerToChar; // Assignment 2: NO COMPILER ERROR ???

PointerToPointerToChar = PointerToPointerToConstChar; // Assignment 3: Gives compiler error as I would expect
PointerToPointerToChar = PointerToConstPointerToChar; // Assignment 4: Gives compiler error as I would expect

I understand the const keyword in C++, specifically how it's placement affects what is considered const (the entity to the left).

It seems like the compiler tries to protect the user of the RHS variable from a const-stripping alias at either level of indirection (assignments 3 and 4). But the LHS is only protected from a const-stripping alias at one level of indirection (assignment 1) and not the other level of indirection (assignment 2). In other words, given that the following is prevented by the compiler

PointerToPointerToConstChar = PointerToPointerToChar; // Assignment 1: Gives compiler error as I would expect
PointerToPointerToChar[0][0] = 'A'; // The user of the LHS variable was effectively lied to about the constness of the *characters* - second level of indirection

then why isn't the following also prevented by the compiler

PointerToConstPointerToChar = PointerToPointerToChar; // Assignment 2: NO COMPILER ERROR ???
PointerToPointerToChar[0] = NULL; // The user of the LHS variable was effectively lied to about the constness of the *pointers* - first level of indirection

Is this correct C++, and if so what is the rationale? It seems inconsistent. Thanks!

Answer 1

The type const* doesn't mean the value won't change, it means you can't change it using that pointer.

---

Because if you could do that, you could assign to the *PointerToPointerToConstChar any const char* - while PointerToPointerToChar relies on it being normal char* . If that was allowed:

PointerToPointerToConstChar = PointerToPointerToChar; // assume PointerToPointerToChar is pointing to a valid memory block
const char str[] = "Hello world!";
*PointerToPointerToConstChar = str;
(*PointerToPointerToChar)[0] = 'X'; // Oops, we just modified a const array

Answer 2

Assigning a char** to a char* const* is analogous to assigning a char* to a const char* . It makes perfect sense.

char array[] = "foo";
char* ptr1 = array;            // Can change array through ptr1
char const* ptr2 = ptr1;       // Can't change array through ptr2

Use of char** and char* const* complicates what can and what can't be changed a bit more.

char** ptrptr1 = &ptr1;

// Can change where ptr1 points to through ptrptr1
*ptrptr1 = <some other char*>; // OK

// Can change the value of what ptr1 points to through ptrptr1.
(*ptrptr1)[0] = 'x';           // OK

char* const* ptrptr2 = ptr1;

// Can't change where ptr1 points to through ptrptr2
*ptrptr2 = <some other char*>; // Not OK

// Can change the value of what ptr1 points to through ptrptr2.
// (*ptrptr2) is still of type 'char*'.
(*ptrptr2)[0] = 'x';           // OK

Answer 3

You have a Pointer to something that is const . The pointer is not const , just what it points to. You assign to that pointer a pointer to something that is not const . That is fine. The pointer is not const and the const in this case just tells us, that the object pointed to will not be changed through this pointer . It doesn't have to be const anywhere else.

char* c = someCharPointerSomewhere;
PointerToConstPointerToChar = PointerToPointerToChar;
*PointerToConstPointerToChar = c // const violation
*PointerToPointerToChar = c // this is fine
// now *PointerToConstPointerToChar will be c as well.

Then why can you not assign to a pointer to a pointer to const ? Well, the pointer to const is a different type than a pointer to non const . The implicit conversion we have above does not apply in this case. You could use this pointer to let the pointer it points to point to something, that actually is const . Then the original pointer would allow to modify the const value indirectly.

const char c = 'c';
PointerToPointerToConstChar = PointerToPointerToChar;
*PointerToPointerToConstChar = c;
**PointerToPointerToChar = 'a'; // const violation!

It is a bit confusing, when you just read the explanations, but take your time and think it through. It really is logically consistent that way.