让你不再害怕指针(2)

4、指针表达式

一个表达式的结果如果是一个指针，那么这个表达式就叫指针表式。[/b]下面是一些指针表达式的例子：[/b]例七：[/b]int a,b;[/b]int array[10];[/b]int *pa;[/b]pa=&a; //&a[/b]是一个指针表达式。[/b]Int **ptr=&pa; //&pa[/b]也是一个指针表达式。[/b]*ptr=&b; //*ptr[/b]和&b都是指针表达式。[/b]pa=array;[/b]pa++; //[/b]这也是指针表达式。[/b]例八：[/b]char *arr[20];[/b]char **parr=arr; //[/b]如果把arr看作指针的话，arr也是指针表达式[/b]char *str;[/b]str=*parr; //*parr[/b]是指针表达式[/b]str=*(parr+1); //*(parr+1)[/b]是指针表达式[/b]str=*(parr+2); //*(parr+2)[/b]是指针表达式[/b]　　由于指针表达式的结果是一个指针，所以指针表达式也具有指针所具有的四个要素：指针的类型，指针所指向的类型，指针指向的内存区，指针自身占据的内存。[/b]　　好了，当一个指针表达式的结果指针已经明确地具有了指针自身占据的内存的话，这个指针表达式就是一个左值，否则就不是一个左值。　　在例七中，&a不是一个左值，因为它还没有占据明确的内存。*ptr是一个左值，因为*ptr这个指针已经占据了内存，其实*ptr就是指针pa，既然pa已经在内存中有了自己的位置，那么*ptr当然也有了自己的位置。[/b]
[/b]

5、数组和指针的关系[/u]

数组的数组名其实可以看作一个指针。看下例：[/b]例九：[/b]intarray[10]={0,1,2,3,4,5,6,7,8,9},value;[/b]value=array[0]; //[/b]也可写成：value=*array;[/b]value=array[3]; //[/b]也可写成：value=*(array+3);[/b]value=array[4]; //[/b]也可写成：value=*(array+4);[/b]上例中，一般而言数组名array代表数组本身，类型是int[10]，但如果把array看做指针的话，它指向数组的第0个单元，类型是int* ，所指向的类型是数组单元的类型即int。因此*array等于0就一点也不奇怪了。同理，array+3是一个指向数组第3个单元的指针，所以*(array+3)等于3。其它依此类推。[/b]例十：[/b]char *str[3]={[/b]　"Hello,thisisasample!",[/b]　"Hi,goodmorning.",[/b]　"Helloworld"[/b]};[/b]chars[80][/b]；[/b]strcpy(s,str[0]); //[/b]也可写成strcpy(s,*str);[/b]strcpy(s,str[1]); //[/b]也可写成strcpy(s,*(str+1));[/b]strcpy(s,str[2]); //[/b]也可写成strcpy(s,*(str+2));[/b]上例中，str是一个三单元的数组，该数组的每个单元都是一个指针，这些指针各指向一个字符串。把指针数组名str当作一个指针的话，它指向数组的第0号单元，它的类型是char **，它指向的类型是char *。[/b] [/b]*str[/b]也是一个指针，它的类型是char *，它所指向的类型是char，它指向的地址是字符串"Hello,thisisasample!"的第一个字符的地址，即'H'的地址。注意:字符串相当于是一个数组,在内存中以数组的形式储存,只不过字符串是一个数组常量,内容不可改变,且只能是右值.如果看成指针的话,他即是常量指针[/b][微软用户2] ,[/b]也是指针常量[/b][微软用户3] .[/b][/b] [/b]str+1[/b]也是一个指针，它指向数组的第1号单元，它的类型是char**，它指向的类型是char*。[/b] [/b]　　[/b]*(str+1)[/b]也是一个指针，它的类型是char*，它所指向的类型是char，它指向"Hi,goodmorning."的第一个字符'H'[/b]　　[/b]下面总结一下数组的数组名(数组中储存的也是数组)的问题:[/b]声明了一个数组TYPE array
，则数组名称array就有了两重含义：第一，它代表整个数组，它的类型是TYPE
；第二 ，它是一个常量指针，该指针的类型是TYPE*，该指针指向的类型是TYPE，也就是数组单元的类型，该指针指向的内存区就是数组第0号单元，该指针自己占有单独的内存区，注意它和数组第0号单元占据的内存区是不同的。该指针的值是不能修改的，即类似array++的表达式是错误的。[/b]在不同的表达式中数组名array可以扮演不同的角色。[/b]　　在表达式sizeof(array)中，数组名array代表数组本身，故这时sizeof函数测出的是整个数组的大小。[/b]在表达式*array中，array扮演的是指针，因此这个表达式的结果就是数组第0号单元的值。sizeof(*array)测出的是数组单元的大小。[/b]　　表达式array+n（其中n=0，1，2，.....）中，array扮演的是指针，故array+n的结果是一个指针，它的类型是TYPE *，它指向的类型是TYPE，它指向数组第n号单元。故sizeof(array+n)测出的是指针类型的大小。在32位程序中结果是4[/b]例十一:[/b]int array[10];[/b]int (*ptr)[10];[/b]ptr=&array;[/b]：[/b]上例中ptr是一个指针，它的类型是int(*)[10]，他指向的类型是int[10] ，我们用整个数组的首地址来初始化它。在语句ptr=&array中，array代表数组本身。[/b]　　本节中提到了函数sizeof()，那么我来问一问，sizeof(指针名称)测出的究竟是指针自身类型的大小呢还是指针所指向的类型的大小？答案是前者。例如：[/b]int(*ptr)[10];[/b]则在32位程序中，有：[/b]sizeof(int(*)[10])==4[/b]sizeof(int[10])==40[/b]sizeof(ptr)==4[/b]实际上，sizeof(对象)测出的都是对象自身的类型的大小，而不是别的什么类型的大小。[/b]
[/b]

6、指针和结构类型的关系

可以声明一个指向结构类型对象的指针。[/b]例十二：[/b]struct MyStruct[/b]{[/b]　int a;[/b]　int b;[/b]　int c;[/b]};[/b]struct MyStruct ss={20,30,40};[/b]//[/b]声明了结构对象ss，并把ss的成员初始化为20，30和40。[/b]struct MyStruct *ptr=&ss;[/b]//[/b]声明了一个指向结构对象ss的指针。它的类型是[/b]//MyStruct *,[/b]它指向的类型是MyStruct。[/b]int *pstr=(int*)&ss;[/b]//[/b]声明了一个指向结构对象ss的指针。但是pstr和[/b]//[/b]它被指向的类型ptr是不同的。[/b]　　[/b]请问怎样通过指针ptr来访问ss的三个成员变量？[/b]　　答案：[/b]ptr->a; //[/b]指向运算符[/b]，或者可以这们(*ptr).a,建议使用前者[/b]ptr->b;[/b]ptr->c;[/b]　　[/b]又请问怎样通过指针pstr来访问ss的三个成员变量？[/b]　　答案：[/b]*pstr[/b]； //访问了ss的成员a。[/b]*(pstr+1); //[/b]访问了ss的成员b。[/b]*(pstr+2) //[/b]访问了ss的成员c。[/b]　　虽然我在我的MSVC++6.0上调式过上述代码，但是要知道，这样使用pstr来访问结构成员是不正规的，为了说明为什么不正规，让我们看看怎样通过指针来访问数组的各个单元: (将结构体换成数组)[/b]例十三：[/b]int array[3]={35,56,37};[/b]int *pa=array;[/b]通过指针pa访问数组array的三个单元的方法是：[/b]*pa; //[/b]访问了第0号单元[/b]*(pa+1); //[/b]访问了第1号单元[/b]*(pa+2); //[/b]访问了第2号单元[/b]　　从格式上看倒是与通过指针访问结构成员的不正规方法的格式一样。[/b]　　所有的C/C++编译器在排列数组的单元时，总是把各个数组单元存放在连续的存储区里，单元和单元之间没有空隙。但在存放结构对象的各个成员时，在某种编译环境下，可能会需要字对齐或双字对齐或者是别的什么对齐，需要在相邻两个成员之间加若干个"填充字节"，这就导致各个成员之间可能会有若干个字节的空隙。[/b]　　所以，在例十二中，即使*pstr访问到了结构对象ss的第一个成员变量a，也不能保证*(pstr+1)就一定能访问到结构成员b。因为成员a和成员b之间可能会有若干填充字节，说不定*(pstr+1)就正好访问到了这些填充字节呢。这也证明了指针的灵活性。要是你的目的就是想看看各个结构成员之间到底有没有填充字节，嘿，这倒是个不错的方法。[/b]不过指针访问结构成员的正确方法应该是象例十二中使用指针ptr的方法。[/b]
[/b]

7、指针和函数的关系

可以把一个指针声明成为一个指向函数的指针。[/b]int fun1(char *,int);[/b]int (*pfun1)(char *,int);[/b]pfun1=fun1;[/b]int a=(*pfun1)("abcdefg",7); //[/b]通过函数指针调用函数。[/b]可以把指针作为函数的形参。在函数调用语句中，可以用指针表达式来作为实参。[/b]例十四：[/b]int fun(char *);[/b]inta;[/b]char str[]="abcdefghijklmn";[/b]a=fun(str);[/b]int fun(char *s)[/b]{[/b]int num=0;[/b]for(int i=0;;)[/b]{[/b]num+=*s;s++;[/b]}[/b]return num;[/b]}[/b]　　这个例子中的函数fun统计一个字符串中各个字符的ASCII码值之和。前面说了，数组的名字也是一个指针。在函数调用中，当把str作为实参传递给形参s后，实际是把str的值传递给了s，s所指向的地址就和str所指向的地址一致，但是str和s各自占用各自的存储空间。在函数体内对s进行自加1运算，并不意味着同时对str进行了自加1运算。[/b]
[/b]

8、指针类型转换

当我们初始化一个指针或给一个指针赋值时，赋值号的左边是一个指针，赋值号的右边是一个指针表达式。在我们前面所举的例子中，绝大多数情况下，指针的类型和指针表达式的类型是一样的，指针所指向的类型和指针表达式所指向的类型是一样的。[/b]例十五：[/b]float f=12.3;[/b]float *fptr=&f;[/b]int *p;[/b]　　　在上面的例子中，假如我们想让指针p指向实数f，应该怎么办？是用下面的语句吗？[/b]　　p=&f;[/b]　　不对。因为指针p的类型是int *，它指向的类型是int。表达式&f的结果是一个指针，指针的类型是float *,它指向的类型是float。两者不一致，直接赋值的方法是不行的。至少在我的MSVC++6.0上，对指针的赋值语句要求赋值号两边的类型一致，所指向的类型也一致，其它的编译器上我没试过，大家可以试试。为了实现我们的目的，需要进行"强制类型转换"：[/b]p=(int*)&f;[/b]如果有一个指针p，我们需要把它的类型和所指向的类型改为[/b]TYEP *TYPE[/b]， 那么语法格式是： (TYPE *)p；[/b][/b]这样强制类型转换的结果是一个新指针，该新指针的类型是[/b]TYPE *[/b]，它指向的类型是TYPE，它指向的地址就是原指针指向的地址。而原来的指针p的一切属性都没有被修改。（切记）[/b]　　一个函数如果使用了指针作为形参，那么在函数调用语句的实参和形参的结合过程中，必须保证类型一致 ，否则需要强制转换[/b]例十六：[/b]void fun(char*);[/b]int a=125,b;[/b]fun((char*)&a);[/b]void fun(char*s)[/b]{[/b]charc;[/b]c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;[/b]c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;[/b]}[/b]注意这是一个32位程序，故int类型占了四个字节，char类型占一个字节。函数fun的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗？在函数调用语句中，实参&a的结果是一个指针，它的类型是int *，它指向的类型是int。形参这个指针的类型是char *，它指向的类型是char。这样，在实参和形参的结合过程中，我们必须进行一次从int *类型到char *类型的转换。结合这个例子，我们可以这样来想象编译器进行转换的过程：编译器先构造一个临时指针char *temp， 然后执行temp=(char *)&a，最后再把temp的值传递给s。所以最后的结果是：s的类型是char *,它指向的类型是char，它指向的地址就是a的首地址。[/b]　　我们已经知道，指针的值就是指针指向的地址，在32位程序中，指针的值其实是一个32位整数。那可不可以把一个整数当作指针的值直接赋给指针呢？就象下面的语句：[/b]unsigned int a;[/b]TYPE *ptr; //TYPE[/b]是int，char或结构类型等等类型。[/b]a=20345686;[/b]ptr=20345686; //[/b]我们的目的是要使指针ptr指向地址20345686[/b]ptr=a; //[/b]我们的目的是要使指针ptr指向地址20345686[/b]编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就不能达到了吗？不，还有办法：[/b]unsigned int a;[/b]TYPE *ptr; //TYPE[/b]是int，char或结构类型等等类型。[/b]a=N //N[/b]必须代表一个合法的地址；[/b]ptr=(TYPE*)a[/b]； [/b]//[/b]呵呵，这就可以了。[/b]严格说来这里的(TYPE *)和指针类型转换中的(TYPE *)还不一样。这里的(TYPE*)的意思是把无符号整数a的值当作一个地址来看待。上面强调了a的值必须代表一个合法的地址，否则的话，在你使用ptr的时候，就会出现非法操作错误。[/b]想想能不能反过来，把指针指向的地址即指针的值当作一个整数取出来。完全可以。下面的例子演示了把一个指针的值当作一个整数取出来，然后再把这个整数当作一个地址赋给一个指针：[/b] [/b]例十七：[/b]int a=123,b;[/b]int *ptr=&a;[/b]char *str;[/b]b=(int)ptr; //[/b]把指针ptr的值当作一个整数取出来。[/b]str=(char*)b; //[/b]把这个整数的值当作一个地址赋给指针str。[/b]　　现在我们已经知道了，可以把指针的值当作一个整数取出来，也可以把一个整数值当作地址赋给一个指针。[/b]
[/b]

9、指针的安全问题

看下面的例子：[/b]例十八：[/b]char s='a';[/b]int *ptr;[/b]ptr=(int *)&s;[/b]*ptr=1298[/b]；[/b]　　指针ptr是一个int *类型的指针，它指向的类型是int。它指向的地址就是s的首地址。在32位程序中，s占一个字节，int类型占四个字节。最后一条语句不但改变了s所占的一个字节，还把和s相临的高地址方向的三个字节也改变了。这三个字节是干什么的？只有编译程序知道，而写程序的人是不太可能知道的。也许这三个字节里存储了非常重要的数据，也许这三个字节里正好是程序的一条代码，而由于你对指针的马虎应用，这三个字节的值被改变了！这会造成崩溃性的错误。[/b]让我们再来看一例：[/b]例十九：[/b]char a;[/b]int *ptr=&a;[/b]ptr++;[/b]*ptr=115;[/b]　　该例子完全可以通过编译，并能执行。但是看到没有？第3句对指针ptr进行自加1运算后，ptr指向了和整形变量a相邻的高地址方向的一块存储区。这块存储区里是什么？我们不知道。有可能它是一个非常重要的数据，甚至可能是一条代码。而第4句竟然往这片存储区里写入一个数据！这是严重的错误。所以在使用指针时，程序员心里必须非常清楚：我的指针究竟指向了哪里。在用指针访问数组的时候，也要注意不要超出数组的低端和高端界限，否则也会造成类似的错误。[/b]在指针的强制类型转换：ptr1=(TYPE *)ptr2中，如果sizeof(ptr2的类型)大于sizeof(ptr1的类型)，那么在使用指针ptr1来访问ptr2所指向的存储区时是安全的。如果sizeof(ptr2的类型)小于sizeof(ptr1的类型)，那么在使用指针ptr1来访问ptr2所指向的存储区时是不安全的。至于为什么，读者结合例十八来想一想，应该会明白的。[/b]
[/b]

10、结束语

现在你是否已经觉得指针再也不是你所想的那么害怕了，如果你的回答是：对，我不怕了！哈哈，恭喜你，你已经掌握C语言的精华了，C中唯一的难点就是指针，指针搞定其它小菜而已，重要的是实践，好吧，让我们先暂停C的旅程吧，开始我们的C++编程，C是对底层操作非常方便的语言，但开发大型程序本人觉得还是没有C++方便，至少维护方面不太好做。而且C++是面向对象的语言，现在基本已经是面向对象的天下了，所以建议学C++。C++是一门难学易用的语言，要真正掌握C++可不是那么容易的，将基本的学完后，就学数据结构吧，算法才是永恒的，程序设计语言层出不穷，永远学不完。学完之后就认真啃下STL这根骨头吧，推荐书籍--------范型编程与STL和STL源码剖析。如果你达到了这样要求，再一次恭喜你，你已经是个程序高手了，甚至可以说是个算法高手，因为STL里有大量的精华而高效的算法。唉，已经该说再见的时候了，让我们一起用我们的语言来谱写我们的人生吧，最后笑个，哈哈，睡觉了。好累，都2：00了[/b] [微软用户1]有关左值，简单点说就是可以放在赋值运算符左边的表达式.下面让我们来看看他的定义: 如果一个表达式可以引用到某一个对象，并且这个对象是一块内存空间且可以被检查和存储，那么这个表达式就可以做为一个左值.当然,有左值当然就会有右值这个概念: 右值指的是引用了一个存储在某个内存地址里的数据。一个变量可以同时是左值，同时也是右值，两者不是对立的。 [微软用户2]该指针是一个常量,不可改变,指向某个地址之后就不能改变了,但他所指向的单元是可以改变的,很容易与指针常量弄混,所以一般读的时候读成常量指向,从字面上看就是一个常量指向某个地址. [微软用户3]说明该指针所指向的是内容不可改变,但其自身是一个变量,可以改变指向的内容,读的时候读成指向常量,从字面上看就是指向某个常量