char ** a; const char ** b; char * const * c; const char * const * d; const char * const * const e;对

原文地址

char ** a;
const  char ** b;
char *  const * c;
const  char *  const * d;
const  char *  const *  const e;

——天哪，这都是什么东西？用5个小程序来解释一下。。或许你可以看得懂？
如果你急着和mm去约会，直接跳到文末，有比较简洁的说明。

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

void test1(){
     char **s; //s是数组的指针;
    s =  NULL;
    s =  new  char*[4];
     for ( int i = 0; i < 4; ++i){
        s[i] =  new  char[10];
        strcpy(s[i], "test");
    }
     for ( int i = 0; i < 4; ++i){
         printf("%s\n", s[i]);
    }
     for ( int i = 0; i < 4; ++i){
         delete[] s[i];
    }
     delete[] s;
}

void test2(){
     const  char **s; //s是指向字符串常量的指针
    s =  NULL;
     char b[4][10] = {"a","b","c","d"};
    s =  new  const  char*[4];
     for ( int i = 0; i < 4; ++i){
        s[i] = b[i]; // OK
        //s[i][0] = 'd'; //这句要报错,因为s[i]指向的是字符串常量
                    //即使b[i]字符串本不是常量(编译期间添加的属性)
    }
     for ( int i = 0; i < 4; ++i){
         printf("%s\n", s[i]);
    }
     delete[] s;
}

void test3(){
     char *  const * s; //s指向常量数组，数组的每一个元素是字符指针常量。
                //数组的元素不可改，但数组元素指向的字符串可修改    
    s =  NULL;// s不是常量
     char a[4][10] = {"aa", "bb", "cc", "dd"};
     char *  const(b[4]) = {a[0], a[1], a[2], a[3]};
    s = b;
     for ( int i = 0; i < 4; ++i){
        s[i][1] = 'd'; //OK
        //s[i] =  NULL; //报错，因为s[i]是常量
         printf("%s\n", s[i]);
    }
}

void test4(){
     const  char *  const * s; //s指向一个常量指针数组
    //数组的每一个元素是字符指针常量，指向字符串常量(绕口令阿这是。。。)
    s =  NULL;// s不是常量
     char a[4][10] = {"aa", "bb", "cc", "dd"};
     char *  const(b[4]) = {a[0], a[1], a[2], a[3]};
    s = b;
     for ( int i = 0; i < 4; ++i){
        //s[i][1] = 'd'; //报错，因为s[i][j]是常量
        //s[i] =  NULL; //报错，因为s[i]是常量
         printf("%s\n", s[i]);
    }
}

void test5(){
     char a[4][10] = {"aa", "bb", "cc", "dd"};
     const  char *  const(b[4]) = {a[0], a[1], a[2], a[3]};
     const  char *  const *  const s = b;
    //s是一个常量指针，指向一个常量指针数组
    //数组的每一个元素是字符指针常量，指向字符串常量(这才是绕口令！)
    //s =  NULL; //Error, s是常量
     for ( int i = 0; i < 4; ++i){
        //s[i][1] = 'd'; //报错，因为s[i][j]是常量
        //s[i] =  NULL; //报错，因为s[i]是常量
         printf("%s\n", s[i]);
    }
}

int main(){
    test5();
     return 0;
}

OK，其实有一种很简单的阅读方法：从右向左读定义，结果就是——

char ** s; 
s是一个指针1，指向一个指针2, 指针2指向 char

const  char ** s; 
s是一个指针1，指向一个指针2，指针2指向 char， char是常数

char *  const * s; 
s是一个指针1，指向一个常量1，常量1是个指针2，指针2指向 char

const  char *  const * s; 
s是一个指针1，指向一个常量1，常量1是个指针2，指针2指向 char， char是常数

const  char *  const *  const s; 
s是一个常量1，常量1是一个指针1，指针1指向一个常量2，常量2是个指针2，指针2指向 char， char是常数