Bjarne a donné une méthode mnémotechnique dans son The C++ Programming Language :Lire une déclaration de droite à gauche.。

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; 

Comme ci-dessus. Comme il n'existe pas d'opérateur const* en C++, const ne peut appartenir qu'au type qui le précède.

La norme C++ stipule que placer le mot-clé const avant le type ou avant le nom de la variable est équivalent.

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

À ce propos, nous pouvons examiner une ancienne question d'examen écrit de Google :

const char *p="hello";       
foo(&p);  // 函数foo(const char **pp)下面说法正确的是[]
  • A. La fonction foo() ne peut pas modifier le contenu de la chaîne pointée par p.
  • B. La fonction foo() ne peut pas faire pointer le pointeur p vers l'adresse générée par malloc.
  • C. La fonction foo() peut faire pointer p vers une nouvelle constante de chaîne.
  • D. La fonction foo() peut affecter NULL à p.

Quant à la réponse à cette question, les avis divergent. Concernant la question ci-dessus, nous pouvons utiliser le programme suivant pour tester :

#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;
}

Les conclusions sont les suivantes :

 
  1. Dans la fonction foo, on peut faire pointer le p de la fonction main vers une nouvelle constante de chaîne.
  2. Dans la fonction foo, on peut faire pointer le p de la fonction main vers NULL.
  3. Dans la fonction foo, on peut faire pointer p de la fonction main vers un bloc mémoire généré par malloc, et il peut être libéré avec free dans main, mais il y aura un avertissement. Cependant, notez que même si l'on fait pointer p vers un bloc mémoire généré par malloc dans foo, vous ne pouvez toujours pas utiliser une instruction comme p
  4. Dans foo, vous ne pouvez pas utiliser une instruction comme (*pp)

Par conséquent, il semble que gcc ne le restreigne que sur la base du sens littéral de const. C'est-à-dire que, pour un pointeur comme const char*p, peu importe que p pointe réellement plus tard vers de la mémoire issue de malloc ou vers de la mémoire constante, vous ne pouvez pas utiliser une instruction comme p