复杂类型说明
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 结合, 说明该指针所指向的元素是整型数据.
####搞清一个指针需要搞清指针的四方面的内 容： 指针的类型、 指针所指向的类型、 指针的值或者叫 指针所指向的内存区、指针本身所占据的内 存区。
1. 指针的类型把指针声 明语句 里的指针名 字去掉， 剩下的部
分就是这个指针的类型。
例(1)int*ptr;//指针的类型是 int*
(2)char*ptr;//指针的类型是 char*
(3)int**ptr;//指针的类型是 int**
(4)int(*ptr)[3];//指针的类型是 int(*)[3]
(5)int*(*ptr)[4];//指针的类型是 int*(*)[4]
2. 指针所指向的类型把指针声 明语句 中的指针名 字和名 字左边的指针声明符*去掉， 剩下的就是指针所指向的类型。
(1)int*ptr; //指针所指向的类型是 int
(2)char*ptr; //指针所指向的的类型是 char
(3)int**ptr; //指针所指向的的类型是 int*
(4)int(*ptr)[3]; //指针所指向的的类型是 int()[3]
(5)int*(*ptr)[4]; //指针所指向的的类型是 int*()[4]
3. 指针的值----或者叫 指针所指向的内存区或地址指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在 32位程序里， 所有类型的指针的值都是一个 32位整数，因为32位程序里内存地址全都是 32 位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为 si zeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是 XX， 就相当于说该指针指向了 以 XX 为首地址的一片内存区域； 我们说一个指针指向了某块内 存区域，就相当 于说该指针的值是这块内 存区域的首地址。指针所指向的内 存区和指针所指向的类型是两个完全不同 的概念。在例1中， 指针所指向的类型已经有了 ，但由于指针还未初始化， 所以它所指向的内 存区是不存在的，或者说是无意义的。
4 指针本身所占据的内 存区你只 要用 函数 sizeof(指针的类型) 测一下就知道了。 在 32 位平台 里， 指针本身占据了 4 个字节的长度。
2、 指针的算术运算
指针可以加上或减去一个整数。 指针的这种运算的意义和通常的数值的加减运算的意义是不一样的， 以单元为单位。
一个指针 ptrold 加(减) 一个整数 n 后， 结果是一个新的指针 ptrnew，ptrnew的类型和 ptrold的类型相同 ， ptrnew 所指向的类型和 ptrold所指向的类型也相同 。 ptrnew 的值将比 ptrold 的值增加(减少) 了 n 乘sizeof(ptrold 所指向的类型) 个字节。 就是说， ptrnew 所指向的内 存区 将比ptrold 所 指 向 的 内 存 区 向 高 (低) 地址方向 移 动 了 n 乘sizeof(ptrold 所指向的类型) 个字节。
两个指针不能进行加法运算， 这是非法操作
两个指针可以进行减法操作，但必须类型相同 ，一般用在数组方面
3、 运算符&和*
int a=12; int b; int *p; int **ptr;
p=&a; //&a 的结果是一个指针， 类型是 int*， 指向的类型是int， 指向的地址是 a 的地址。
*p=24; //*p 的结果，在这里它的类型是 int， 它所占用 的地址是p 所指向的地址， 显然， *p 就是变量 a。
ptr=&p; //&p 的结果是个指针， 该指针的类型是 p 的类型加个*，在这里是 int **。 该指针所指向的类型是 p 的类型， 这里是 int*。 该指针所指向的地址就是指针 p 自 己的地址。
*ptr=&b; //*ptr 是个指针， &b 的结果也是个指针， 且这两个指针的类型和所指向的类型是一样的，所以用 &b 来给*ptr 赋值就是毫无问题的了 。
**ptr=34; //*ptr 的结果是 ptr 所指向的东西， 在这里是一个指针，对这个指针再做一次*运算， 结果是一个 int 类型的变量。
4、 指针表达式
一个表达式的结果如果是一个指针， 那么这个表达式就叫 指针表式。
由于指针表达式的结果是一个指针， 所以指针表达式也具有指针所具有的四个要素：指针的类型，指针所指向的类型，指针指向的内存区，指针自身占据的内 存。
5、 数组和指针的关系
数组的数组名 其实可以看作一个指针。 看下例：
例九：
intarray[10]={0,1,2,3,4,5,6,7,8,9},value;
value=array[0]; //也可写成： value=*array;
value=array[3]; //也可写成： value=*(array+3);
value=array[4]; //也可写成： value=*(array+4);
上例中， 一般而言数组名 array 代表数组本身， 类型是 int[10] ， 但如果把 array 看做指针的话， 它指向数组的第 0 个单元， 类型是 int* ，所指向的类型是数组单元的类型即 int。因 此*array 等于 0 就一点也不奇怪了 。 同 理， array+3 是一个指向数组第 3 个单元的指针， 所以*(array+3) 等于 3。其它依此类推。
例十：
char *str[3]={
"Hello,thisisasample!",
"Hi,goodmorning.",
"Helloworld"
};
chars[80] ；
strcpy(s,str[0]); //也可写成 strcpy(s,*str);
strcpy(s,str[1]); //也可写成 strcpy(s,*(str+1));
strcpy(s,str[2]); //也可写成 strcpy(s,*(str+2));
上例中， str 是一个三单元的数组， 该数组的每个单元都是一个指针，这些指针各指向一个字符串。 把指针数组名 str 当 作一个指针的话， 它指向数组的第 0 号单元， 它的类型是 char **， 它指向的类型是 char *。
*str 也是一个指针， 它的类型是 char *，它所指向的类型是 char，它指向的地址是字符串"Hello,thisisasample!"的第一个字符的地址， 即'H' 的地址。 注意:字符串相当 于是一个数组, 在内 存中以数组的形式储存, 只 不过字符串是一个数组常量, 内 容不可改变, 且只 能是右值. 如果看成指针的话, 他即是常量指针, 也是指针常量.str+1 也是一个指针， 它指向数组的第 1 号单元， 它的类型是 char**，它指向的类型是 char*。*(str+1) 也是一个指针， 它的类型是 char*， 它所指向的类型是 char，它指向"Hi,goodmorning."的第一个字符'H'下面总结一下数组的数组名 (数组中储存的也是数组) 的问题:声 明了 一个数组 TYPE array[n] ， 则数组名 称 array 就有了 两重含义：
第一， 它代表整个数组， 它的类型是 TYPE[n] ； 第二 ， 它是一个常量指针， 该指针的类型是 TYPE*， 该指针指向的类型是 TYPE， 也就是数组单元的类型， 该指针指向的内 存区就是数组第 0 号单元， 该指针自 己占有单独的内 存区， 注意它和数组第 0 号单元占据的内 存区是不同 的。 该指针的值是不能修改的， 即类似 array++的表达式是错误的。在不同 的表达式中数组名 array 可以扮演不同 的角 色。在表达式 sizeof(array) 中， 数组名 array 代表数组本身， 故这时sizeof 函数测出 的是整个数组的大小。在表达式*array 中， array 扮演的是指针， 因 此这个表达式的结果就是数组第 0 号单元的值。 sizeof(*array) 测出 的是数组单元的大小。表达式 array+n（ 其中 n=0， 1， 2， .... . ） 中， array 扮演的是指针， 故 array+n 的结果是一个指针， 它的类型是 TYPE *， 它指向的类型是 TYPE， 它指向数组第 n 号单元。 故 sizeof(array+n) 测出 的是指针类型的大小。 在 32 位程序中结果是 4
例十一:
int array[10];
int (*ptr)[10];
ptr=&array; ：
上例中 ptr 是一个指针， 它的类型是 int(*)[10] ， 他指向的类型是int[10] ， 我们用 整个数组的首地址来初始化它。 在语句 ptr=&array中， array 代表数组本身。本节中提到了 函数 sizeof() ， 那么我来问一问， sizeof(指针名 称)测出 的究竟是指针自 身类型的大小呢还是指针所指向的类型的大小？
答案是前者。 例如：
int(*ptr)[10];
则在 32 位程序中， 有：
sizeof(int(*)[10])==4
sizeof(int[10])==40
sizeof(ptr)==4
实际上， sizeof(对象) 测出 的都是对象自 身的类型的大小， 而不是别的什么类型的大小。
6、 指针和结构类型的关系
可以声 明一个指向结构类型对象的指针。
例十二：
struct MyStruct
{
int a;
int b;
int c;
};
struct MyStruct ss={20,30,40};
//声 明了 结构对象 ss， 并把 ss 的成员 初始化为 20， 30 和 40。
struct MyStruct *ptr=&ss;
//声 明了 一个指向结构对象 ss 的指针。 它的类型是MyStruct *, 它指向的类型是 MyStruct。
int *pstr=(int*)&ss;
//声 明了 一个指向结构对象 ss 的指针。 但是 pstr 它被指向的类型 ptr 是不同 的。
请问怎样通过指针 ptr 来访问 ss 的三个成员 变量？
答案：
ptr->a; //指向运算符， 或者可以这们(*ptr).a, 建议使用 前者
ptr->b;
ptr->c;
又请问怎样通过指针 pstr 来访问 ss 的三个成员 变量？
答案：
*pstr； //访问了 ss 的成员 a。
*(pstr+1); //访问了 ss 的成员 b。
*(pstr+2) //访问了 ss 的成员 c。
虽 然我在我的 MSVC++6.0 上调式过上述代码， 但是要知道， 这样使用 pstr 来访问结构成员 是不正规的， 为了 说明为什么不正规， 让我们看看怎样通过指针来访问数组的各个单元: (将结构体换成数组)
例十三：
int array[3]={35,56,37};
int *pa=array;
通过指针 pa 访问数组 array 的三个单元的方法是：
*pa; //访问了 第 0 号单元
*(pa+1); //访问了 第 1 号单元
*(pa+2); //访问了 第 2 号单元
从格式上看倒是与通过指针访问 结构成员 的不正规方法的格式一样。
所有的 C/C++编译器在排列数组的单元时， 总是把各个数组单元存放在连续的存储区里， 单元和单元之间没有空隙。但在存放结构对象的各个成员 时，在某种编译环境下， 可能会需要字对齐或双字对齐或者是
别的什么对齐， 需要在相邻两个成员 之间加若干个"填充字节"， 这就导致各个成员 之间可能会有若干个字节的空隙。
所以， 在例十二中， 即使*pstr 访问到了 结构对象 ss 的第一个成员 变量 a， 也不能保证*(pstr+1) 就一定能访问到结构成员 b。 因 为成员a 和成员 b 之间可能会有若干填充字节， 说不定*(pstr+1) 就正好访问
到了 这些填充字节呢。 这也证明了 指针的灵活性。 要是你的目 的就是想看看各个结构成员 之间到底有没有填充字节， 嘿， 这倒是个不错的方法。不过指针访问结构成员 的正确方法应该是象例十二中使用 指针 ptr 的
方法。
7、 指针和函数的关系
可以把一个指针声 明成为一个指向函数的指针。
int fun1(char *,int);
int (*pfun1)(char *,int);
pfun1=fun1;
int a=(*pfun1)("abcdefg",7); //通过函数指针调用 函数。
可以把指针作为函数的形参。 在函数调用 语句 中， 可以用 指针表达式来作为实参。
例十四：
int fun(char *);
inta;
char str[]="abcdefghijklmn";
a=fun(str);
int fun(char *s)
{
int num=0;
for(int i=0;;)
{
num+=*s;s++;
}
return num;
}
这个例子中的函数fun统计一个字符串中各个字符的 ASCII 码值之和。 前面说了 ， 数组的名 字也是一个指针。 在函数调用 中 ， 当 把 str作为实参传递给形参 s 后， 实际是把 str 的值传递给了 s， s 所指向的
地址就和 str 所指向的地址一致， 但是 str 和 s 各自 占用 各自 的存储空间。 在函数体内 对 s 进行自 加 1 运算， 并不意味着同 时对 str 进行了 自加 1 运算。
8、 指针类型转换
当 我们初始化一个指针或给一个指针赋值时， 赋值号的左边是一个指针， 赋值号的右边是一个指针表达式。 在我们前面所举的例子中， 绝大多 数情况下， 指针的类型和指针表达式的类型是一样的， 指针所指向的
类型和指针表达式所指向的类型是一样的。
例十五：
float f=12.3;
float *fptr=&f;
int *p;
在上面的例子中， 假如我们想让指针 p 指向实数 f， 应该怎么办？
是用 下面的语句 吗？
p=&f;
不对。 因 为指针 p 的类型是 int *， 它指向的类型是 int。 表达式&f 的结果是一个指针， 指针的类型是 float *, 它指向的类型是 float。两者不一致， 直接赋值的方法是不行的。 至少在我的 MSVC++6.0 上， 对
指针的赋值语句 要求赋值号两边的类型一致， 所指向的类型也一致， 其它的编译器上我没试过， 大家可以试试。 为了 实现我们的目 的， 需要进行"强制类型转换"：
p=(int*)&f;
如果有一个指针 p， 我们需要把它的类型和所指向的类型改为
TYEP *TYPE， 那么语法格式是： (TYPE *)p；
这样强制类型转换的结果是一个新指针， 该新指针的类型是TYPE *， 它指向的类型是 TYPE， 它指向的地址就是原指针指向的地址。
而原来的指针 p 的一切属性都没有被修改。 （ 切记）
一个函数如果使用 了 指针作为形参， 那么在函数调用 语句 的实参和形参的结合过程中，必须保证类型一致 ， 否则需要强制转换
例十六：
void fun(char*);
int a=125,b;
fun((char*)&a);
void fun(char*s)
{
charc;
c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;
c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;
}注
意这是一个 32 位程序， 故 int 类型占了 四个字节， char 类型占一个字节。 函数 fun 的作用 是把一个整数的四个字节的顺序来个颠倒。 注意到了 吗？ 在函数调用 语句 中， 实参&a 的结果是一个指针， 它的类型是int *， 它指向的类型是 int。 形参这个指针的类型是 char *， 它指向的类型是 char。 这样， 在实参和形参的结合过程中， 我们必须进行一次从 int *类型到 char *类型的转换。 结合这个例子， 我们可以这样来
想象编译器进行转换的过程： 编译器先构造一个临时指针 char *temp，然后执行 temp=(char *)&a， 最后再把 temp 的值传递给 s。 所以最后的结果是： s 的类型是 char *, 它指向的类型是 char， 它指向的地址就是
a 的首地址。我们已经知道， 指针的值就是指针指向的地址， 在 32 位程序中，指针的值其实是一个 32 位整数。 那可不可以把一个整数当 作指针的值直接赋给指针呢？ 就象下面的语句 ：
unsigned int a;
TYPE *ptr; //TYPE 是 int， char 或结构类型等等类型。
a=20345686;
ptr=20345686; //我们的目 的是要使指针 ptr 指向地址 20345686
ptr=a; //我们的目 的是要使指针 ptr 指向地址 20345686
编译一下吧。 结果发现后面两条语句 全是错的。 那么我们的目 的就不能达到了 吗？ 不， 还有办法：
unsigned int a;
TYPE *ptr; //TYPE 是 int， char 或结构类型等等类型。
a=N //N 必须代表一个合法的地址；
ptr=(TYPE*)a； //呵呵， 这就可以了 。
严格说来这里的(TYPE *) 和指针类型转换中的(TYPE *) 还不一样。 这里的(TYPE*) 的意思是把无符号整数 a 的值当 作一个地址来看待。 上面强调了 a 的值必须代表一个合法的地址， 否则的话， 在你使用 ptr 的时候，就会出 现非法操作错误。
想想能不能反过来， 把指针指向的地址即指针的值当 作一个整数取出 来。 完全可以。 下面的例子演示了 把一个指针的值当 作一个整数取出来， 然后再把这个整数当 作一个地址赋给一个指针：
例十七：
int a=123,b;
int *ptr=&a;
char *str;
b=(int)ptr; //把指针 ptr 的值当 作一个整数取出 来。
str=(char*)b; //把这个整数的值当 作一个地址赋给指针 str。