指针数组&数组指针

    (1)int *ptr;//指针所指向的类型是int

    (2)char *ptr;//指针所指向的的类型是char

    (3)int **ptr;//指针所指向的的类型是int* （也就是一个int * 型指针）

    (4)int(*ptr)[3];//指针所指向的的类型是int()[3] //二维指针的声明

1. 指针数组：一个数组里存放的都是同一个类型的指针——一个数组，存放指针。

    比如 int * a[10];它里边放了１０个int * 型变量，由于它是一个数组，已经在栈区分配了１０个(int * )的空间，也就是３２位机上是４０个byte,每个空间都可以存放一个int型变量的地址，这个时候你可以为这个数组的每一个元素初始化，在，或者单独做个循环去初始化它。

    例：

    int * a[2]={ new int(3),new int(4) };

    在栈区里声明一个int * 数组，它的每一个元素都在堆区里申请了一个无名变量，并初始化他们为３和４，注意此种声明方式具有缺陷，VC下会报错

    例：

        int * a[2]={new int[3],new int[3]};

        delete a[0];

        delete a[1];

    但是不建议这么写，可能会造成歧义，不是好的风格，并且在VC中会报错，应该写成：

        int * a[2]；

        a[0]= new int[3];

        a[1]= new int[3];

        delete a[0];

        delete a[1];

    这样申请内存的风格感觉比较符合大家的习惯；由于是数组，所以就不可以delete a;编译会出警告.delete a[1];

    注意：这里是一个数组，不能delete [];

2. 数组指针：一个指向一维或者多维数组的指针——一个指针，指向数组。

    int * b=new int[10];　指向一维数组的指针b;

    注意：这个时候释放空间一定要delete [] ,否则会造成内存泄露，b就成为了空悬指针.

    int (*b2)[10]=new int[10][10];

    注意：这里的b2指向了一个二维int型数组的首地址.b2等效于二维数组名，但没有指出其边界，即最高维的元素数量，但是它的最低维数的元素数量必须要指定！就像指向字符的指针，即等效一个字符串,不要把指向字符的指针说成指向字符串的指针。这与数组的嵌套定义相一致。

    int (*b3) [30] [20]; //三级指针――>指向三维数组的指针；

    int (*b2) [20]; //二级指针；

    b3=new int [1] [30] [20];

    b2=new int [30] [20];

    两个数组都是由600个整数组成，前者是只有一个元素的三维数组，每个元素为30行20列的二维数组，而另一个是有30个元素的二维数组，每个元素为20个元素的一维数组。

删除这两个动态数组可用下式：

    delete [] b3; //删除（释放）三维数组；

    delete [] b2; //删除（释放）二维数组；

    再次重申：这里的b2的类型是int (*) ，这样表示一个指向二维数组的指针。

    b3表示一个指向（指向二维数组的指针）的指针，也就是三级指针.

3. 二级指针的指针

    int (**p)[2]=new (int(*)[3])[2];

    p[0]=new int[2][2];

    p[1]=new int[2][2];

    p[2]=new int[2][2];

    delete [] p[0];

    delete [] p[1];

    delete [] p[2];

    delete [] p;

    注意:此地方的指针类型为int (*),碰到这种问题就把外边的[2]先去掉，然后回头先把int ** p＝new int(*)[n]申请出来，然后再把外边的［２］附加上去；

    p代表了一个指向二级指针的指针，在它申请空间的时候要注意指针的类型，那就是int (*)代表二级指针，而int (**)顾名思义就是代表指向二级指针的指针了。既然是指针要在堆里申请空间，那首先要定义它的范围：（int(*)[n]）[2]，n 个这样的二级指针，其中的每一个二级指针的最低维是２个元素.（因为要确定一个二级指针的话，它的最低维数是必须指定的，上边已经提到）。然后我们又分别为p[0],p[1],p[2]…在堆里分配了空间，尤其要注意的是：在释放内存的时候一定要为p[0],p[1],p[2],单独delete[] ,否则又会造成内存泄露，在delete[]p 的时候一定先delete p[0]; delete p[1]，然后再把给p申请的空间释放掉 delete [] p ……这样会防止内存泄露。

4. 指针的指针

    int **cc=new (int*)[10];

    声明一个１０个元素的数组，数组每个元素都是一个int *指针，每个元素还可以单独申请空间，因为cc的类型是int*型的指针，所以你要在堆里申请的话就要用int *来申请；

    例：

    int ** a= new int * [2];　　//申请两个int * 型的空间

    a[1]=new int[3];　//a[1]申请了３个int 型空间,a[1]指向了此空间首地址处

    a[0]=new int[4];　//a[0]申请了４个int 型空间，a[0] 指向了此空间的首地址处

    int * b;

    a[0][0]=0;

    a[0][1]=1;

    b=a[0];

    delete [] a[0]; //一定要先释放a[0]，a[1]的空间，否则会造成内存泄露.

    delete [] a[1];

    delete [] a;

    b++;

    cout<<*b<<endl; //随机数

    注意：因为a 是在堆里申请的无名变量数组，所以在delete 的时候要用delete []来释放内存，但是a的每一个元素又单独申请了空间，所以在delete [] a之前要先delete [] 掉a[0],a[1],否则又会造成内存泄露.

5. 二维指针数组——二维指针，指向一个指针数组：

    int *(*c)[3]=new int *[3][3]；

    c是个二级指针,只不过指向了一个二维int *型的数组而已，也就是二维指针数组。

    例子：

    int *(*b)[10]=new int*[2][10];//

    b[0][0]=new int[100];

    b[0][1]=new int[100];

    *b[0][0]=1;

    cout <<*b[0][0]<<endl; //打印结果为１

    delete [] b[0][0];

    delete [] b[0][1];

    delete [] b;

    cout<<*b[0][0]<<endl; //打印随机数

6.二维数组指针——本身为数组，存储二级指针：

    int **d[2]; //表示一个拥有两个元素数组，每一个元素都是int ** 型，这个指向指针的指针，d不管怎样变终究也是个数组

　　　d[0]=new int *[10];

　　　d[1]=new int *[10];

      delete [] d[0];

      delete [] d[1];

7. 函数指针　

    int a();//这个一个函数的声明；

    int (*b)();//这是一个函数指针的声明；

    左边圆括弧中的星号是函数指针声明的关键。另外两个元素是函数的返回类型（void）和由边圆括弧中的入口参数（本例中参数是空）。注意本例中还没有创建指针变量，只是声明了变量类型。目前可以用这个变量类型来创建类型定义名及用sizeof表达式获得函数指针的大小：

    unsigned psize = sizeof (int (*) ()); //获得函数指针的大小

    typedef int (*PFUNC) ();// 为函数指针声明类型定义

    PFUNC是一个函数指针，它指向的函数没有输入参数，返回int。使用这个类型定义名可以隐藏复杂的函数指针语法；