C语言指针利用要领
副标题#e#
为初学者处事。这是本文的宗旨。指针是c和c++中的难点和重点。有些措施员们能干dos下的basic。c语言的其它各类特性，在basic中都有雷同的对象。只有指针，是baisc所不具备的。指针是c的魂灵。
我不想反复大大都书上说得很清楚的对象，我只是把我看过的书中说得不清楚或没有说，而我又以为我领略得有点原理的对象写出来。
1、指针的观念
指针是一个非凡的变量，它内里存储的数值被表明成为内存里的一个地点。要搞清一个指针需要搞清指针的四方面的内容：指针的范例，指针所指向的范例，指针的值可能叫指针所指向的内存区，尚有指针自己所占据的内存区。让我们别离说明。
先声明几个指针放着做例子：
例一：
(1)int *ptr;
(2)char *ptr;
(3)int **ptr;
(4)int (*ptr)[3];
(5)int *(*ptr)[4];
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]
在指针的算术运算中，指针所指向的范例有很大的浸染。指针的范例(即指针自己的范例)和指针所指向的范例是两个观念。当你对C越来越熟悉时，你会发明，把与指针搅和在一起的"范例"这个观念分成"指针的范例"和"指针所指向的范例"两个观念，是能干指针的要害点之一。
3、指针的值，可能叫指针所指向的内存区或地点
指针的值是指针自己存储的数值，这个值将被编译器看成一个地点，而不是一个一般的数值。在32位措施里，所有范例的指针的值都是一个32位整数，因为32位措施里内存地点全都是32位长。
指针所指向的内存区就是从指针的值所代表的谁人内存地点开始，长度为sizeof(指针所指向的范例)的一片内存区。今后，我们说一个指针的值是XX，就相当于说该指针指向了以XX为首地点的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地点。
指针所指向的内存区和指针所指向的范例是两个完全差异的观念。在例一中，指针所指向的范例已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，可能说是无意义的。
今后，每碰着一个指针，都应该问问：这个指针的范例是什么？指针指向的范例是什么？该指针指向了那边？
4、指针自己所占据的内存区
指针自己占了多大的内存？你只要用函数sizeof(指针的范例)测一下就知道了。在32位平台里，指针自己占据了4个字节的长度。指针自己占据的内存这个观念在判定一个指针表达式是否是左值时很有用。
#p#副标题#e#
第二章 指针的算术运算
指针可以加上或减去一个整数。指针的这种运算的意义和凡是的数值的加减运算的意义是纷歧样的。譬喻：
例二：
1.char a[20];
2.int *ptr=a;
...
...
3.ptr++;
在上例中，指针ptr的范例是int*,它指向的范例是int，它被初始化为指向整形变量a。接下来的第3句中，指针ptr被加了1，编译器是这样处理惩罚的：它把指针ptr的值加上了sizeof(int)，在32位措施中，是被加上了4。
由于地点是用字节做单元的，故ptr所指向的地点由本来的变量a的地点向高地点偏向增加了4个字节。由于char范例的长度是一个字节，所以，本来ptr是指向数组a的第0号单位开始的四个字节，此时指向了数组a中从第4号单位开始的四个字节。我们可以用一个指针和一个轮回来遍历一个数组，看例子：
例三：
int array[20];
int*ptr=array;
...
//此处略去为整型数组赋值的代码。
...
for(i=0;i<20;i++)
{
(*ptr)++;
ptr++；
}
这个例子将整型数组中各个单位的值加1。由于每次轮回都将指针ptr加1，所以每次轮回都能会见数组的下一个单位。
再看例子：
例四：
1.char a[20];
2.int *ptr=a;
...
...
3.ptr+=5;
#p#分页标题#e#
在这个例子中，ptr被加上了5，编译器是这样处理惩罚的：将指针ptr的值加上5乘sizeof(int)，在32位措施中就是加上了5乘4=20。由于地点的单元是字节，故此刻的ptr所指向的地点比起加5后的ptr所指向的地点来说，向高地点偏向移动了20个字节。
在这个例子中，没加5前的ptr指向数组a的第0号单位开始的四个字节，加5后，ptr已经指向了数组a的正当范畴之外了。固然这种环境在应用上会出问题，但在语法上却是可以的。这也浮现出了指针的机动性。
假如上例中，ptr是被减去5，那么处理惩罚进程大同小异，只不外ptr的值是被减去5乘sizeof(int)，新的ptr指向的地点将比本来的ptr所指向的地点向低地点偏向移动了20个字节。
总结一下，一个指针ptrold加上一个整数n后，功效是一个新的指针ptrnew，ptrnew的范例和ptrold的范例沟通，ptrnew所指向的范例和ptrold所指向的范例也沟通。ptrnew的值将比ptrold的值增加了n乘sizeof(ptrold所指向的范例)个字节。就是说，ptrnew所指向的内存区将比ptrold所指向的内存区向高地点偏向移动了n乘sizeof(ptrold所指向的范例)个字节。
一个指针ptrold减去一个整数n后，功效是一个新的指针ptrnew，ptrnew的范例和ptrold的范例沟通，ptrnew所指向的范例和ptrold所指向的范例也沟通。ptrnew的值将比ptrold的值淘汰了n乘sizeof(ptrold所指向的范例)个字节，就是说，ptrnew所指向的内存区将比ptrold所指向的内存区向低地点偏向移动了n乘sizeof(ptrold所指向的范例)个字节。
第三章。运算符&和*
这里&是取地点运算符，*是…书上叫做"间接运算符"。&a的运算功效是一个指针，指针的范例是a的范例加个*，指针所指向的范例是a的范例，指针所指向的地点嘛，那就是a的地点。
*p的运算功效就八门五花了。总之*p的功效是p所指向的对象，这个对象有这些特点：它的范例是p指向的范例，它所占用的地点是p所指向的地点。
例五：
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范例的变量。
第四章 指针表达式
一个表达式的最后功效假如是一个指针，那么这个表达式就叫指针表达式。下面是一些指针表达式的例子：
例六：
int a,b;
int array[10];
int *pa;
pa=&a;
//&a是一个指针表达式。
int **ptr=&pa;
//&pa也是一个指针表达式。
*ptr=&b;
//*ptr和&b都是指针表达式。
pa=array;
pa++;
//这也是指针表达式。
例七：
char *arr[20];
char **parr=arr;
//假如把arr看作指针的话，arr也是指针表达式
char *str;
str=*parr;
//*parr是指针表达式
str=*(parr+1);
//*(parr+1)是指针表达式
str=*(parr+2);
//*(parr+2)是指针表达式
由于指针表达式的功效是一个指针，所以指针表达式也具有指针所具有的四个要素：指针的范例，指针所指向的范例，指针指向的内存区，指针自身占据的内存。
好了，当一个指针表达式的功效指针已经明晰地具有了指针自身占据的内存的话，这个指针表达式就是一个左值，不然就不是一个左值。
在例七中，&a不是一个左值，因为它还没有占据明晰的内存。*ptr是一个左值，因为*ptr这个指针已经占据了内存，其实*ptr就是指针pa，既然pa已经在内存中有了本身的位置，那么*ptr虽然也有了本身的位置。
第五章。数组和指针的干系
数组的数组名其实可以看作一个指针。看下例：
#p#分页标题#e#
例八：
int array[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"
};
char s[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’，等等。
下面总结一下数组的数组名的问题。声明白一个数组TYPEarray[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)测出的是指针范例的巨细。
例十：
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(工具)测出的都是工具自身的范例的巨细，而不是此外什么范例的巨细。
