三级指针：
#include<stdio.h>
char  *c[ ] = { "ENTER" , "NEW" , "POINT" , "FIRST"};
char  **cp[ ] = { c+3 , c+2 , c+1 , c };
char  ***cpp = cp;
main ( )
{
    printf ( "%s#" ,  **++cpp );
    printf ( "%s#" ,  *--*++cpp);
    printf ( "%s#" ,  *cpp[-2]+3);
    printf ( "%s#" ,  cpp[ -1] [ -1] + 1 );
}
char  *c[ ] = { "ENTER" , "NEW" , "POINT" , "FIRST" };
这个肯定能理解，就是定义几个字符串，然后将其放入一个数组中，因为数组内放的是字符串，所以数组类型必须为char*。
我们在定义一个字符串的时候，经常是这么写char* str = "hello world";
那么我们要定义多个字符串的时候，就可以利用数组了，像上边那样。
char  **cp[ ] = { c+3 , c+2 , c+1 , c };
这是二重指针。因为前边定义的c是数组类型，也就是一种常量指针(地址)，所以c+3,c+2,c+1,c都是指向数组c每个元素的地址。现在要将数组元素的地址放在数组中，那么该用什么数据类型呢？存放一个变量(也可以是字符串)地址时，需要的是指针，那么存放一个地址的地址，就需要一个二重指针(因为只有指针可以存放地址，这里是存放一个地址的地址，所以要用二重指针)。
char  ***cpp = cp;
cp本来就是一个常量指针，再加上他的类型是char**，所以它就是一个三级指针。这里cpp的类型是char***，也是三级指针，所以将cp直接赋值给cpp也就没有问题啦(类型相同的嘛(都是三级指针))。
printf ( "%s#" ,  **++cpp );
++的优先级高，所以先执行++cpp，也就是得到数组cp的第二个元素地址。
两个**我们分开看，先看*++cpp，这是取得数组cp第二个元素的值c+2。也就是说      *（地址）就指向了该地址所存储的内容（该内容为一个变量或另一个变量的地址（即指针），或为存放一个变量地址的地址（指针的指针）…..）
在看**++cpp，相当于*(c + 2)，所以这里得到的是数组c第三个元素的首地址，也就是"POINT"字符串的首地址，所以这里输出POINT#    ，并且，该语句执行后导致cpp当前的指向发生了变化。
printf ( "%s#" ,  *--*++cpp );
由优先级和执行顺序的关系得知，这里会先执行++cpp，因为前一个输出语句已经导致cpp加1了，所以现在cpp再加1，那么会得到数组cp的第三个元素地址，即++cpp指向cp+2。再执行*++cpp，这时取得数组cp第三个元素的值c+1。
然后再执行--*++cpp，相当于--(c+1)，也就是c，然后再执行*c，所以取得是数组c的第一个元素的首地址，所以输出结果为ENTER#    。该语句执行后同样会导致cpp当前的指向发生变化。
printf ( "%s#" ,  *cpp[-2] + 3 );
数组下标优先，所以会先执行cpp[-2]，也就是*(cpp-2);因为前两输出语句导致cpp加了2，所以现在-2后，又使cpp-2的地址为数组cp的首地址，所以得到数组cp第一个元素c+3。再执行*(cpp[-2])，也就是*(c+3)，这就得到了数组c的第四个元素的首地址，也就是字符串"FIRST"的首地址，然后这个地址再加3，所以得到字符串ST的首地址，因此输出结果为ST#    。该语句执行后cpp当前的指向未发生变化。
printf ( "%s#" , cpp[ -1 ] [ -1 ] + 1 );
先执行cpp[-1]，相当于*(cpp-1)。因为前面两个输出语句导致cpp被加了2，它目前指向数组cp的第三个元素，所以cpp-1相当于数组cp第二个元素c+2，然后再执行cpp[-1][-1]，相当于(c+2)[-1]，也就是*(c+2-1) = *(c+1)，所以得到数组c的第二个元素的首地址，也就是字符串"NEW"的首地址，然后在这个地址上加1，就得到字符串EW的首地址，所以输出结果为EW#    。该语句执行后cpp当前的指向同样未发生变化。
程序如下：
#define  NL  99
main()
{
  int    i , j , k , n ;
  float  ***data;
   data=(float  ***)malloc((NL)*sizeof(float  **));
  for(i=0;i <NL;i++)
  {     
        data[i]=(float**)malloc((NL)*sizeof(float*));
      printf( "%d  is  ok!\n ",i);
        for(j=0;j <NL;j++)
           {
              data[i][j]=(float*)malloc((NL)*sizeof(float));
              for(k=0;k <NL;k++)
                {
                  data[i][j][k]=2.002; 
                  }
            }
      }
  printf( "%f\n ", data[0][0][12]); 
  printf( "%d\n ",&data[0][1][1]-&data[0][0][0]);
}
    为什么当NL取小于100的数的时候给出的两个地址相减的结果是正确的，当NL大于100的时候结果是比正确的多加1？ 是编译器的问题？ 还是内存边界的问题？要怎么才能让它在大于100的时候也输出正确结果？
这个data[i][j][k]不是完全连续存储的数组，它的存贮单元的位置取决于malloc(), 比如data[0][0][0]和data[0][0][1]就可能存在地址不连续。所以计算地址偏移量就存在变数。如果预先分配大小为：NL*NL*NL*sizeof（float）的一块内存，然后再利用下面三个嵌套的for语句将***data 与其一一对应起来就可以实现连续存储。
程序如下：
#define  NL  3
main()
{
        int  i,j,k;           
        float  ***data;   
        float  *total=(float*)malloc(NL*NL*NL*sizeof(float));
        int  x=0;
        data=(float  ***)malloc((NL)*sizeof(float  **));
        for(i=0;i <NL;i++)
        {     
                data[i]=(float**)malloc((NL)*sizeof(float*));             
                printf( "%d  is  ok!\n ",i);
                for(j=0;j <NL;j++)
                {
                        //data[i][j]=(float*)malloc((NL)*sizeof(float)); 字符串常量怎么定
                        x=i*NL*NL+j*NL;
                        data[i][j]=&total[x];
                        for(k=0;k <NL;k++)
                        {
                                data[i][j][k]=2.002f; 
                          }
                  }
          }
        printf( "\n%f\n ",data[NL-1][NL-1][NL-1]);
        printf( "%d\n ",&data[0][1][0]-&data[0][0][0]);
        return  0;
}
我上面搞错了 我的那种算法当NL是奇数的时候是正确的，NL取偶数的时候就别原来多加了1 这是为什么呢？而且只是在当最后一维循环完的地方才会出现多加1的情况，像&data[0][1][10]-&data[0][1][1]就 就没有任何的问题，这是malloc分配的空间的问题？还是内存地址的问题？
不清楚你这样计算偏移量有什么用途，但我认为这个同malloc有关，有关它分配内存的算法。&data[0][1][10]-&data[0][1][1]//这段内存是malloc一次分配的,是连续的. &data[0][2][10]-&data[0][1][1]//这是在循环中,两次malloc分配之间的,内存可能是不连续的.不能这样减. 连续内存的例子,上面给了一个,第二次贴出那个.

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。