Bjarne, en su libro The C++ Programming Language, propuso un método mnemotécnico:Lea una declaración de derecha a izquierda.。

char * const cp; ( * 读成 pointer to ) 
cp is a const pointer to char 

const char * p; 
p is a pointer to const char; 

char const * p; 

Ídem, porque en C++ no existe el operador const*, por lo que const solo puede pertenecer al tipo anterior.

El estándar de C++ estipula que poner la palabra clave const antes del tipo o antes del nombre de la variable es equivalente.

const int n=5;    //same as below
int const m=10;

const int *p;    //same as below  const (int) * p
int const *q;    // (int) const *p


char ** p1; 
//    pointer to    pointer to    char 
const char **p2;
//    pointer to    pointer to const char 
char * const * p3;
//    pointer to const pointer to    char 
const char * const * p4;
//    pointer to const pointer to const char 
char ** const p5;
// const pointer to    pointer to    char 
const char ** const p6;
// const pointer to    pointer to const char 
char * const * const p7;
// const pointer to const pointer to    char 
const char * const * const p8;
// const pointer to const pointer to const char

Dicho esto, podemos ver una pregunta de una prueba escrita anterior de Google:

const char *p="hello";       
foo(&p);  // 函数foo(const char **pp)下面说法正确的是[]
  • A. La función foo() no puede cambiar el contenido de la cadena a la que apunta p.
  • B. La función foo() no puede hacer que el puntero p apunte a la dirección generada por malloc.
  • C. La función foo() puede hacer que p apunte a una nueva constante de cadena.
  • D. La función foo() puede asignarle a p el valor NULL.

En cuanto a la respuesta de esta pregunta, las opiniones están divididas. Para la pregunta anterior, podemos probar con el siguiente programa:

#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
void foo(const char **pp)
{
//    *pp=NULL;
//    *pp="Hello world!";
        *pp = (char *) malloc(10);
        snprintf(*pp, 10, "hi google!");
//       (*pp)[1] = 'x';
}
int
main()
{
    const char *p="hello";
    printf("before foo %s/n",p);
    foo(&p);
    printf("after foo %s/n",p);
    p[1] = 'x';
    return;
}

La conclusión es la siguiente:

 
  1. En la función foo, se puede hacer que p, en la función main, apunte a una nueva constante de cadena.
  2. En la función foo, se puede hacer que p en la función main apunte a NULL.
  3. En la función foo, se puede hacer que p en la función main apunte a un bloque de memoria generado por malloc, y se puede liberar en main con free, pero habrá una advertencia. Pero tenga en cuenta que, incluso si en foo se hace que p apunte a un bloque de memoria generado por malloc, aún no se puede usar una sentencia como p
  4. En foo, no se puede usar una sentencia como (*pp)

Por lo tanto, parece que gcc simplemente lo restringe según el significado literal de const. Es decir, para un puntero como const char*p, sin importar si p realmente apunta a memoria de malloc o a memoria constante, no se puede usar una sentencia como p