先从简单的类型分析开始吧。
int p;    这是一个普通的整型变量
int *p;  首先从 P 处开始,先与*结合,所以说明 P 是一 个指针,然后再与 int 结合,说明指针所指向 的内容的类型为 int 型.所以 P 是一个返回整 型数据的指针.
int p[3]; 首先从 P 处开始,先与[]结合,说明 P 是一个数 组,然后与 int 结合,说明数组里的元素是整 型的,所以 P 是一个由整型数据组成的数组。
int *p[3]; 首先从 P 处开始，先与[]结合,因为其优先级比*高，所以 P 是一个数组,然后再与*结合。说明 数组里的元素是指针类型,然后再与 int 结合, 说明指针所指向的内容的类型是整型的,所以 P 是一个由返回整型数据的指针所组成的数组。
int (*p)[3]; 首先从 P 处开始,先与*结合,说明 P 是一个指针然后再与[]结合(与"()"这步可以忽略,只是为了改变优先级),说明指针所指向的内容是一个数组,然后再与 int 结合,说明数组里的元素是整型的。所以 P 是一个指向由整型数据组成的数组的指针
int **p; 首先从 P 开始,先与*结合,说是 P 是一个指针,然 后再与*结合,说明指针所指向的元素是指针,然后再与 int 结合,说明该指针所指向的元素是整 型数据.
int p(int);  从 P 处起,先与()结合,说明 P 是一个函数,然后进入 ()里分析,说明该函数有一个整型变量的参数然后再与外面的 int 结合,说明函数的返回值是 一个整型数据
Int (*p)(int);  从 P 处开始,先与指针结合,说明 P 是一个指针,然后与()结合,说明指针指向的是一个函数,然后再与()里的 int 结合,说明函数有一个 int 型的参数,再与最外层的int 结合,说明函数的返回类型是整型,所以 P 是一个指向有一个整型参数且返回类型为整型的函数的指针。
int *(*p(int))[3];  从 P 开始,先与()结合,说明 P 是一个函数,然后进入()里面,与 int 结合,说明函数有一个整型变量数,然后再与外面的*结合,说明函数返回的是一个指针,,然后到最外面一层,先与[]结合,说明返回的指针指向的是一数组,然后再与*结合,说明数组里的元素是指针,然后再与 int 结合,说明指针指向的内容是整型数据.所以 P 是一个参数为一个整数据且返回一个指向由整型指针变量组成的数组的指针变量的函数.
指针关系详解：
1，假定下面ints数组在内存中的起始位置是100，整形值和指针长度都是4个字节。
int ints[20] = {
     10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
      110, 120, 130, 140, 150, 160, 170, 180, 190,200
};
int *ip = ints + 3;
----------------------------------------------------------------------------
则有下面关系：
ints  = 100             ip = 112
ints[4] = 50            ip[4] = 80
ints +4 = 116          ip + 4 = 128
*ints + 4 = 14          *ip + 4 = 44
*(ints + 4) = 50        *(ip + 4) = 80
ints[-2] = 非法          ip[-2] = 20
&ints = 100             &ip = 未知
&ints[4] = 116         &ip[4] = 128
&int + 4 = 116         &ip + 4 = 未知
&ints[-2] = 非法        &ip[-2] = 104

2，指针与数组关系。定义下列声明：
    int  array[4][5][3];
把下列各个指针表达式转换成下标表达式
*array  =  array[0]
*(array +2) = array[2]
*(array+1) + 4 = array[1] + 4
*(*(array +1) + 4) =  array[1][4]
*(*(*array + 3) + 1) +2) = array[3][1][2]
*(*(*array+1) + 2) = array[0][1][2]
*(**array +2) = array[0][0][2]
**(*array +1) = array[0][1][0]
***array = array[0][0][0]

顶一个！！