[免费下载 c语言深度解剖[1]-第15章

按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！


如果把内存初始化为　
NULL，就相当于把指针指向尺子上　
0毫米处，这时候指针没有任何内
存可用。
当我们真正需要使用　
p的时候，就必须把一个一级指针的地址保存到　
p中，所以　
B）的
赋值方式也是正确的。
给　
p赋值没有问题，但怎么使用　
p呢？这就需要我们前面多次提到的钥匙（“*”）。

第一步：根据　
p这个变量，取出它里面存的地址。
第二步：找到这个地址所在的内存。
第三步：用钥匙打开这块内存，取出它里面的地址，*p的值。
第四步：找到第二次取出的这个地址。
第五步：用钥匙打开这块内存，取出它里面的内容，这就是我们真正的数据，　
**p的值。
我们在这里用了两次钥匙（　
“*”）才最终取出了真正的数据。也就是说要取出二级指针

所真正指向的数据，需要使用两次两次钥匙（“*”）。
至于超过二维的数组和超过二维的指针一般使用比较少，而且按照上面的分析方法同
样也可以很轻松的分析明白，这里就不再详细讨论。读者有兴趣的话，可以研究研究。

4。6，数组参数与指针参数
我们都知道参数分为形参和实参。形参是指声明或定义函数时的参数，而实参是在调
用函数时主调函数传递过来的实际值。

4。6。1，一维数组参数
4。6。1。1，能否向函数传递一个数组？
看例子：　


void　
fun（char　
a＇10＇）　
｛　
charc　
=　
a＇3＇；　
｝　



intmain（）　


｛　


charb＇10＇=　
“abcdefg”；　


fun（b＇10＇）；　


return0；　


｝

先看上面的调用，fun（b＇10＇）；将　
b＇10＇这个数组传递到　
fun函数。但这样正确吗？b＇10＇
是代表一个数组吗？

显然不是，我们知道　
b＇0＇代表是数组的一个元素，那　
b＇10＇又何尝不是呢？只不过这里
数组越界了，这个　
b＇10＇并不存在。但在编译阶段，编译器并不会真正计算　
b＇10＇的地址并取
值，所以在编译的时候编译器并不认为这样有错误。虽然没有错误，但是编译器仍然给出
了两个警告：　


warningC4047：　
'function'：　
'char*'　
differsinlevelsof　
indirectionfrom　
'char'　


warningC4024：　
'fun'：　
differenttypesforformalandactualparameter1

这是什么意思呢？这两个警告告诉我们，函数参数需要的是一个　
char*类型的参数，而
实际参数为　
char类型，不匹配。虽然编译器没有给出错误，但是这样运行肯定会有问题。
如图：


这是一个内存异常，我们分析分析其原因。其实这里至少有两个严重的错误。

第一：b＇10＇并不存在，在编译的时候由于没有去实际地址取值，所以没有出错，但是
在运行时，将计算　
b＇10＇的实际地址，并且取值。这时候发生越界错误。

第二：编译器的警告已经告诉我们编译器需要的是一个　
char*类型的参数，而传递过去
的是一个　
char类型的参数，这时候　
fun函数会将传入的　
char类型的数据当地址处理，同样
会发生错误。（这点前面已经详细讲解）

第一个错误很好理解，那么第二个错误怎么理解呢？　
fun函数明明传递的是一个数组啊，
编译器怎么会说是　
char*类型呢？别急，我们先把函数的调用方式改变一下：　


fun（b）；　


b是一个数组，现在将数组　
b作为实际参数传递。这下该没有问题了吧？调试、运行，
一切正常，没有问题，收工！很轻易是吧？但是你确认你真正明白了这是怎么回事？数组　
b　



真的传递到了函数内部？

4。6。1。2，无法向函数传递一个数组
我们完全可以验证一下：　


void　
fun（char　
a＇10＇）　
｛　


int　
i　
=　
sizeof（a）；　


charc　
=　
a＇3＇；　


｝

如果数组　
b真正传递到函数内部，那　
i的值应该为　
10。但是我们测试后发现　
i的值竟然
为　
4！为什么会这样呢？难道数组　
b真的没有传递到函数内部？是的，确实没有传递过去，
这是因为这样一条规则：　


C语言中，当一维数组作为函数参数的时候，编译器总是把它解析成一个指向其首元
素首地址的指针。

这么做是有原因的。在　
C语言中，所有非数组形式的数据实参均以传值形式（对实参
做一份拷贝并传递给被调用的函数，函数不能修改作为实参的实际变量的值，而只能修改
传递给它的那份拷贝）调用。然而，如果要拷贝整个数组，无论在空间上还是在时间上，
其开销都是非常大的。更重要的是，在绝大部分情况下，你其实并不需要整个数组的拷贝，
你只想告诉函数在那一刻对哪个特定的数组感兴趣。这样的话，为了节省时间和空间，提
高程序运行的效率，于是就有了上述的规则。同样的，函数的返回值也不能是一个数组，
而只能是指针。这里要明确的一个概念就是：函数本身是没有类型的，只有函数的返回值
才有类型。很多书都把这点弄错了，甚至出现“XXX类型的函数”这种说法。简直是荒唐
至极！

经过上面的解释，相信你已经理解上述的规定以及它的来由。上面编译器给出的提示，
说函数的参数是一个　
char*类型的指针，这点相信也可以理解。

既然如此，我们完全可以把　
fun函数改写成下面的样子：　


void　
fun（char　
*p）　


｛　


charc　
=　
p＇3＇；//或者是　
charc　
=　
*（p＋3）；　


｝

同样，你还可以试试这样子：　


void　
fun（char　
a＇10＇）　


｛　


charc　
=　
a＇3＇；　


｝　



intmain（）　


｛　
charb＇100＇=　
“abcdefg”；　
fun（b）；　


return0；　
｝


运行完全没有问题。实际传递的数组大小与函数形参指定的数组大小没有关系。既然
如此，那我们也可以改写成下面的样子：　


void　
fun（char　
a＇　
＇）　
｛　
charc　
=　
a＇3＇；　
｝
改写成这样或许比较好，至少不会让人误会成只能传递一个　
10个元素的数组。

4。6。2，一级指针参数
4。6。2。1，能否把指针变量本身传递给一个函数
我们把上一节讨论的列子再改写一下：　


void　
fun（char　
*p）　
｛　
charc　
=　
p＇3＇；//或者是　
charc　
=　
*（p＋3）；　
｝　


intmain（）　


｛　
char*p2　
=　
“abcdefg”；　
fun（p2）；　
return0；　


｝
这个函数调用，真的把　
p2本身传递到了　
fun函数内部吗？
我们知道　
p2是　
main函数内的一个局部变量，它只在　
main函数内部有效。（这里需要

澄清一个问题：main函数内的变量不是全局变量，而是局部变量，只不过它的生命周期和


全局变量一样长而已。全局变量一定是定义在函数外部的。初学者往往弄错这点。）既然它
是局部变量，fun函数肯定无法使用　
p2的真身。那函数调用怎么办？好办：对实参做一份
拷贝并传递给被调用的函数。即对　
p2做一份拷贝，假设其拷贝名为_p2。那传递到函数内
部的就是_p2而并非　
p2本身。

4。6。2。2，无法把指针变量本身传递给一个函数
这很像孙悟空拔下一根猴毛变成自己的样子去忽悠小妖怪。所以　
fun函数实际运行时，
用到的都是_p2这个变量而非　
p2本身。如此，我们看下面的例子：　
voidGetMemory（char*　
p；intnum）　
｛　
p　
=　
（char*）malloc（num*sizeof（char））；　
｝　


intmain（）　


｛　


char*str=　
NULL；　


GetMemory（str，10）；　


strcpy（str；”hello”）；　


free（str）；//free并没有起作用，内存泄漏　


return0；　
｝
在运行　
strcpy（str；”hello”）语句的时候发生错误。这时候观察　
str的值，发现仍然为　
NULL。
也就是说　
str本身并没有改变，我们　
malloc的内存的地址并没有赋给　
str，而是赋给了_str。
而这个_str是编译器自动分配和回收的，我们根本就无法使用。所以想这样获取一块内存是

不行的。那怎么办？两个办法：

第一：用　
return。　


char*　
GetMemory（char*　
p；intnum）　


｛　


p　
=　
（char*）malloc（num*sizeof（char））；　
returnp；　
｝　


intmain（）　
｛　



char*str=　
NULL；　
str=GetMemory（str，10）；　
strcpy（str；”hello”）；　
free（str）；　


return0；　
｝


这个方法简单，容易理解。
第二：用二级指针。　
voidGetMemory（char**　
p；intnum）　
｛　


*p　
=　
（char*）malloc（num*sizeof（char））；　
returnp；　
｝　


intmain（）　


｛　
char*str=　
NULL；　
GetMemory（&str，10）；　
strcpy（str；”hello”）；　
free（str）；　
return0；　


｝
注意，这里的参数是　
&str而非　
str。这样的话传递过去的是　
str的地址，是一个值。在函
数内部，用钥匙（　
“*”）来开锁：　
*（&str），其值就是　
str。所以　
malloc分配的内存地址是真正
赋值给了　
str本身。
另外关于　
malloc和　
free的具体用法，内存管理那章有详细讨论。

4。6。3，二维数组参数与二维指针参数
前面详细分析了二维数组与二维指针，那它们作为参数时与不作为参数时又有什么区
别呢？看例子：　


voidfun（chara＇3＇＇4＇）；　



我们按照上面的分析，完全可以把　
a＇3＇＇4＇理解为一个一维数组　
a＇3＇，其每个元素都是一
个含有　
4个　
char类型数据的数组。上面的规则，　
“C语言中，当一维数组作为函数参数的时
候，编译器总是把它解析成一个指向其首元素首地址的指针。”在这里同样适用，也就是说
我们可以把这个函数声明改写为：　


voidfun（char　
（*p）＇4＇）；

这里的括号绝对不能省略，这样才能保证编译器把　
p解析为一个指向包含　
4个　
char类

型数据元素的数组，即一维数组　
a＇3＇的元素。

同样，作为参数时，一维数组“＇＇”号内的数字完全可以省略：　


voidfun（chara＇＇＇4＇）；
不过第二维的维数却不可省略，想想为什么不可以省略？
注意：如果把上面提到的声明　
void　
fun（char　
（*p）＇4＇）中的括号去掉之后，声明“void　
fun（char　
*p＇4＇）”可以改写成：　
voidfun（char**p）；

这是因为参数*p＇4＇，对于　
p来说，它是一个包含　
4个指针的一维数组，同样把这个一维数
组也改写为指针的形式，那就得到上面的写法。
上面讨论了这么多，那我们把二维数组参数和二维指针参数的等效关系整理一下：

数组参数等效的指针参数
数组的数组：char　
a＇3＇＇4＇数组的指针：char　
（*p）＇10＇
指针数组：　
char　
*a＇5＇指针的指针：char　
**p　


这里需要注意的是：C语言中，当一维数组作为函数参数的时候，编译器总是把它解析
成一个指向其首元素首地址的指针。这条规则并不是递归的，也就是说只有一维数组才是
如此，当数组超过一维时，将第一维改写为指向数组首元素首地址的指针之后，后面的维
再也不可改写。比如：a＇3＇＇4＇＇5＇作为参数时可以被改写为（*p）＇4＇＇5＇。

至于超过二维的数组和超过二级的指针，由于本身很少使用，而且按照上面的分析方法
也能很好的理解，这里就不再详细讨论。有兴趣的可以好好研究研究。

4。7，函数指针
4。7。1，函数指针的定义
顾名思义，函数指针就是函数的指针。它是一个指针，指向一个函数。看例子：　


A），char*　
（*fun1）（char*　
p1；char*　
p2）；　
B），char*　
*fun2（char*　
p1；char*　
p2）；　
C），char*　
fun3（char*　
p1；char*　
p2）；

看看上面三个表达式分别是什么意思？　


C）：这很容易，　
fun3是函数名，p1，p2是参数，其类型为　
char*型，函数的返回值为　
char　
*
类型。　
B）：也很简单，与　
C）表达式相比，唯一不同的就是函数的返回值类型为　
char**，是个
二级指针。　
A）：fun1是函数名吗？回忆一下前面讲解数组指针时的情形。我们说数组指针这么定
义或许更清晰：　
int（*）＇10＇　
p；

再看看　
A）表达式与这里何其相似！明白了吧。这里　
fun1不是什么函数名，而是一个
指针变量，它指向一个函数。这个函数有两个指针类型的参数，函数的返回值也是一个指
针。同样，我们把这个表达式改写一下：char*　
（*）（char*　
p1；char*　
p2）　
fun1；这样子是不
是好看一些呢？只可惜编译器不这么想。^_^。

4。7。2，函数指针的使用
4。7。2。1，函数指针使用的例子
上面我们定义了一个函数指针，但如何来使用它呢？先看如下例子：　


#include　
#include　


char*　
fun（char*　
p1；char*　
p2）　


｛　
inti　
=　
0；　
i　
=　
strcmp（p1；p2）；　
if　
（0　
　
i）　
｛　


returnp1；　
｝　
else　
｛　


returnp2；　
｝　
｝　


intmain（）　


｛　
char*　
（*pf）（char*　
p1；char*　
p2）；　
pf　
=　
&fun；　
（*pf）（〃aa〃；〃bb〃）；　



return0；　
｝
我们使用指针的时候，需要通过钥匙（“*”）来取其指向的内存里面的值，函数指针使

用也如此。通过用　
（*pf）取出存在这个地址上的函数，然后调用它。这里需要注意到是，在　
VisualC＋＋6。0里，给函数指针赋值时，可以用　
&fun或直接用函数名　
fun。这是因为函数名被
编译之后其实就是一个地址，所以这里两种用法没有本质的差别。这个例子很简单，就不再
详细讨论了。

4。2。7。2，*（int*）&p这是什么？
也许上面的例子过于简单，我们看看下面的例子：　


voidFunction（）　
｛　
printf（〃Call　
Function！n〃）；　
｝　


intmain（）　


｛　
void　
（*p）（）；　
*（int*）&p=（int）Function；　
（*p）（）；　
return0；　


｝
这是在干什么？*（int*）&p=（int）Function；表示什么意思？
别急，先看这行代码：　


void（*p）（）；
这行代码定义了一个指针变量　
p，p指向一个函数，这个函数的参数和返回值都是　
void。　
&p是求指针变量　
p本身的地址，这是一个　
32位的二进制常数（32位系统）。　
（int*）&p表示将地址强制转换成指向　
int类型数据的指针。　
（int）Function表示将函数的入口地址强制转换成　
int类型的数据。
分析到这里，相信你已经明白　
*（int*）&p=（int）Function；表示将函数的入口地址赋值给指

针变量　
p。
那么（*p）（）；就是表示对函数的调用。
讲解到这里，相信你已经明白了。其实函数指针与普通指针没什么差别，只是指向的内

容不同而已。

使用函数指针的好处在于，可以将实现同一功能的多个模块统一起来标识，这样一来更
容易后期的维护，系统结构更加清晰。或者归纳为：便于分层设计、利于系统抽象、降低耦
合度以及使接口与实现分开。

4。7。3，（*（void（*）　
（））0）（）这是什么？
是不是感觉上面的