多维指针

有人问我二三维指针的事，讲了一大堆，总结了以下代码：

void TestPointer()
{
        // 优先级 [] 高于 *，()高于[]
        int i,j,k;
        // 指针和数组
        // 看是指针还是数组要看他的名字(不带[]也不带*)能否直接对其进行内存分配
        // 因为数组是确定的分配好内存地址的,而指针则是用于指向地址的
        // 所以为指针分配内存或赋值时,应该理解为指向数组地址或其他地址

        // 读法：由低优先级向高优先级读
        // *Array0[10]:指针——数组
        // int **Array1[2]：指针——指针——数组（二维指针数组）
        // *(*pPointer4)[2]：指针——数组——指针(指向指针数组的指针)
        // (*pPointer3)[30][20]：数组——数组——指针（指向二维数组的指针）

        // 1、数组和指针数组 
        int Array[10];    // Array是数组，有10个元素,元素的类型是int型
        int *Array0[10];    // Array0是指针数组，有10个元素,元素的类型是int型指针
        for( i=0; i<10; i++ )
        {
                Array0 = new int[i+1];    // Array0是int型的指针
                delete[] Array0;
        }
        int **Array1[2];    // 一个指向指针的指针的数组(二维指针数组)，拥有两个元素
        // 每一个元素都是int ** 型(指向指针的指针) ,但 Array1 终究也是个数组，
        Array1[0]=new int *[10];    // int *[10]为指针数组，见下面一条
        Array1[1]=new int *[10];
        delete [] Array1[0];
        delete [] Array1[1];

        // 2、指向数组的指针
        int *pPointer0=new int[10];    // pPointer0是指针,赋值号右边但申请的是一个数组,只不过用指针指向它

        // 指向“指针数组”的“指向指针的指针”
        // 定义一个数组,有10个元素,元素的类型是int*
        // 用指向指针的指针指向该指针数组, pPointer1[]表示数组中的每个元素(int *)
        // 为指针数组中每个元素申请空间，并为申请到的空间中的元素赋值
        int **pPointer1=new int*[10];
        for( i=0; i<10; i++ )
        {
                // *(pPointer1+i) = new int[i+1]; 也可
                pPointer1 = new int[i+1];
                for( j=0; j<i+1; j++ )
                {
                        // *(*(pPointer1+i)+j) = 1;
                        pPointer1[j] = 1;
                }
                delete[] pPointer1;
        }
        delete [] pPointer1;

        // 指向二维数组的指针，
        // 该二维数组最低维数的元素数量为8个,类型为int
        int (*pPointer2)[8];
        // 理解 (*pPointer2)[8]:
        // (*pPointer2)说明它是一个指针，
        // (*pPointer2)[8]说明p2一次跳过8个元素，
        //         即pPointer2指向一个二维数组，且最低维为8，该数组元素不是指针
        pPointer2= new int[10][8];
        for( i=0; i<10; i++ )
        {
                for( j=0; j<8; j++ )
                {
                        pPointer2[j] = 20;
                }
        }
        delete []pPointer2;  // 删除（释放）二维数组

        // 指向三维数组的指针，该三维数组低两维的元素数量为[30]，[20],类型为int
        int (*pPointer3)[30][20];    // 这个数组低两维必须是确定的
        pPointer3=new int[1][30][20];
        delete []pPointer3;  //删除（释放）三维数组

        // 指向二维指针数组的指针
        // 声明一个3*2的二维数组，元素是指针，
        // 用一个指针的指针pPointer4指向该数组首地址
        // pPointer4[j]是该二维数组的每个元素，（i<=3 j<=2）
        int *(*pPointer4)[2] = new int *[3][2];
        // 对*(*pPointer4)[2]的理解：
        // (*pPointer4)说明pPointer4是指针，
        // (*pPointer4)[2]说明这个指针写成pPointer4时,一次跳两个元素，即pPointer4指向的数组最低维=2
        // *(*pPointer4)[2]说明每个元素都是指针
        for( i=0; i<3; i++ )
        {
                for( j=0; j<2; j++ )
                {
                        pPointer4[j] = new int [5];
                        for( k=0; k<5; k++ )
                        {
                                pPointer4[j][k] = 5;
                        }
                        delete[] pPointer4[j];
                }
        }
        delete[] pPointer4;
}