友情提示:如果本网页打开太慢或显示不完整,请尝试鼠标右键“刷新”本网页!阅读过程发现任何错误请告诉我们,谢谢!! 报告错误
依依小说 返回本书目录 我的书架 我的书签 TXT全本下载 进入书吧 加入书签

[免费下载 c语言深度解剖[1]-第18部分

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



4个“包含 
4个 
int类型元素的数组”,
即&p'4'表示的是 
&p'0'+4*4*sizeof(int)。由于 
p被初始化为 
&a'0',那么 
&p'4''2'表示的是 
&a'0''0'+4*4*sizeof(int)+2* 
sizeof(int)。

再由上面的讲述,&p'4''2'和 
&a'4''2'的值相差 
4个 
int类型的元素。现在,上面测试
出来的结果也可以理解了吧?其实我们最简单的办法就是画内存布局图:


这里最重要的一点就是明白数组指针 
p所指向的内存到底是什么。解决这类问题的最
好办法就是画内存布局图。

4。5。2,二级指针
4。5。2。1,二级指针的内存布局
二级指针是经常用到的,尤其与二维数组在一起的时候更是令人迷糊。例如: 


char 
**p;

定义了一个二级指针变量 
p。p是一个指针变量,毫无疑问在 
32位系统下占 
4个 
byte。
它与一级指针不同的是,一级指针保存的是数据的地址,二级指针保存的是一级指针的地
址。下图帮助理解:



我们试着给变量 
p初始化: 


A),p 
= 
NULL; 
B),char*p2;p 
= 
&p2;
任何指针变量都可以被初始化为 
NULL(注意是 
NULL,不是 
NUL,更不是 
null),二
级指针也不例外。也就是说把指针指向数组的零地址。联想到前面我们把尺子比作内存,
如果把内存初始化为 
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语言中,当一维数组作为函数参数的时候,编译器总是把它解析
成一个指向其首元素首地址的指针。这条规则并不是递归的,也就是说只有一维数组才是
如此,当
返回目录 上一页 下一页 回到顶部 0 0
未阅读完?加入书签已便下次继续阅读!
温馨提示: 温看小说的同时发表评论,说出自己的看法和其它小伙伴们分享也不错哦!发表书评还可以获得积分和经验奖励,认真写原创书评 被采纳为精评可以获得大量金币、积分和经验奖励哦!