深入理解C语言指针奥秘系列文章之二

• 系列
• 文章
• 之二
• 奥秘
• 理解
• 语言
• 深入
• 指针
• 类型
• 指向

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);

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));

intarray[10]; 
int(*ptr)[10]; 
ptr=&array;

#p#分页标题#e#int(*ptr)[10];

sizeof(int(*)[10])==4 
sizeof(int[10])==40 
sizeof(ptr)==4

structMyStruct 
{ 
inta; 
intb; 
intc; 
} 
MyStructss={20,30,40};
//声明了结构对象ss，
并把ss的三个成员初始化为20，30和40。 
MyStruct*ptr=&ss;
//声明了一个指向结构对象ss的指针。
它的类型是MyStruct*,它指向的类型是MyStruct。 
int*pstr=(int*)&ss;
//声明了一个指向结构对象ss的指针。
但是它的类型和它指向的类型和ptr是不同的。

ptr->a; 
ptr->b; 
ptr->c;

*pstr；
//访问了ss的成员a。 
*(pstr+1);
//访问了ss的成员b。 
*(pstr+2)
//访问了ss的成员c。

intarray[3]={35,56,37}; 
int*pa=array;

*pa;
//访问了第0号单元 
*(pa+1);
//访问了第1号单元 
*(pa+2);
//访问了第2号单元

所以，在例十二中，即使*pstr访问到了结构对象ss的第一个成员变量a，也不能保证*(pstr+1)就一定能访问到结构成员b。因为成员a和成员b之间可能会有若干填充字节，说不定*(pstr+1)就正好访问到了这些填充字节呢。这也证明了指针的灵活性。要是你的目的就是想看看各个结构成员之间到底有没有填充字节，这是个不错的方法。通过指针访问结构成员的正确方法应该是象例十二中使用指针ptr的方法。

指针和函数的关系，可以把一个指针声明成为一个指向函数的指针。

intfun1(char*,int); 
int(*pfun1)(char*,int); 
pfun1=fun1; 
.... 
.... 
inta=(*pfun1)("abcdefg",7);
//通过函数指针调用函数。

例十三：

intfun(char*); 
inta; 
charstr[]="abcdefghijklmn"; 
a=fun(str); 
... 
... 
intfun(char*s) 
{ 
intnum=0; 
for(inti=0;i{ 
num+=*s;s++; 
} 
returnnum; 
}

这个例子中的函数fun统计一个字符串中各个字符的ASCII码值之和。前面说了，数组的名字也是一个指针。在函数调用中，当把str作为实参传递给形参s后，实际是把str的值传递给了s，s所指向的地址就和str所指向的地址一致，但是str和s各自占用各自的存储空间。在函数体内对s进行自加1运算，并不意味着同时对str进行了自加1运算。

指针类型转换

当我们初始化一个指针或给一个指针赋值时，赋值号的左边是一个指针，赋值号的右边是一个指针表达式。在我们前面所举的例子中，绝大多数情况下，指针的类型和指针表达式的类型是一样的，指针所指向的类型和指针表达式所指向的类型是一样的。

例十四：

1、floatf=12.3; 
2、float*fptr=&f; 
3、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的一切属性都没有被修改。

一个函数如果使用了指针作为形参，那么在函数调用语句的实参和形参的结合过程中，也会发生指针类型的转换。

例十五：

#p#分页标题#e#voidfun(char*); 
inta=125,b; 
fun((char*)&a); 
... 
... 
voidfun(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位整数。那可不可以把一个整数当作指针的值直接赋给指针呢？就象下面的语句：

unsignedinta; 
TYPE*ptr;
//TYPE是int，char或结构类型等等类型。 
... 
... 
a=20345686; 
ptr=20345686;
//我们的目的是要使指针ptr
指向地址20345686（十进制 
） 
ptr=a;
//我们的目的是要使
指针ptr指向地址20345686（十进制）

编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就不能达到了吗？不，还有办法：

unsignedinta; 
TYPE*ptr;
//TYPE是int，
char或结构类型等等类型。 
... 
... 
a=某个数，
这个数必须代表一个合法的地址； 
ptr=(TYPE*)a；

严格说来这里的(TYPE*)和指针类型转换中的(TYPE*)还不一样。这里的(TYPE*)的意思是把无符号整数a的值当作一个地址来看待。上面强调了a的值必须代表一个合法的地址，否则的话，在你使用ptr的时候，就会出现非法操作错误。

想想能不能反过来，把指针指向的地址即指针的值当作一个整数取出来。完全可以。下面的例子演示了把一个指针的值当作一个整数取出来，然后再把这个整数当作一个地址赋给一个指针：

例十六：

inta=123,b; 
int*ptr=&a; 
char*str; 
b=(int)ptr;
//把指针ptr的值
当作一个整数取出来。 
str=(char*)b;
//把这个整数的值
当作一个地址赋给指针str。

现在我们已经知道了，可以把指针的值当作一个整数取出来，也可以把一个整数值当作地址赋给一个指针。

指针的安全问题，看下面的例子：

例十七：

chars='a'; 
int*ptr; 
ptr=(int*)&s; 
*ptr=1298；

指针ptr是一个int*类型的指针，它指向的类型是int。它指向的地址就是s的首地址。在32位程序中，s占一个字节，int类型占四个字节。最后一条语句不但改变了s所占的一个字节，还把和s相临的高地址方向的三个字节也改变了。这三个字节是干什么的？只有编译程序知道，而写程序的人是不太可能知道的。也许这三个字节里存储了非常重要的数据，也许这三个字节里正好是程序的一条代码，而由于你对指针的马虎应用，这三个字节的值被改变了！这会造成崩溃性的错误。让我们再来看一例：

例十八：

1、chara; 
2、int*ptr=&a; 
... 
... 
3、ptr++; 
4、*ptr=115;

该例子完全可以通过编译，并能执行。但是看到没有？第3句对指针ptr进行自加1运算后，ptr指向了和整形变量a相邻的高地址方向的一块存储区。这块存储区里是什么？我们不知道。有可能它是一个非常重要的数据，甚至可能是一条代码。而第4句竟然往这片存储区里写入一个数据！这是严重的错误。所以在使用指针时，程序员心里必须非常清楚：我的指针究竟指向了哪里。在用指针访问数组的时候，也要注意不要超出数组的低端和高端界限，否则也会造成类似的错误。

在指针的强制类型转换：ptr1=(TYPE*)ptr2中，如果sizeof(ptr2的类型)大于sizeof(ptr1的类型)，那么在使用指针ptr1来访问ptr2所指向的存储区时是安全的。如果sizeof(ptr2的类型)小于sizeof(ptr1的类型)，那么在使用指针ptr1来访问ptr2所指向的存储区时是不安全的。至于为什么，读者结合例十七来想一想，应该会明白的。