指针才是C的精髓

注：本文章是笔者学习朱有鹏老师课程的学习笔记~

借鉴陆思明编写书时引用的话来共勉：“渗透前，看山是山，看水是水；渗透时，看山不是山，看水不是水；渗透后，看山还是山，看水还是水。”

指针到底是什么？

1.指针变量和普通变量的区别
首先必须非常明确：指针的实质就是个变量，它跟普通变量没有任何本质区别。指针完整的名字应该叫指针变量，简称为指针。

2.为什么需要指针？
(1)指针的出现是为了实现间接访问。在汇编中都有间接访问，其实就是CPU的寻址方式中的间接寻址。
(2)间接访问（CPU的间接寻址）是CPU设计时决定的，这个决定了汇编语言必须能够实现间接寻址，又决定了汇编之上的C语言也必须实现间接寻址。
(3)高级语言如Java、C#等没有指针，那他们怎么实现间接访问？

答：是语言本身帮我们封装了。

3.指针使用三部曲：定义指针变量、关联指针变量、解引用
(1)当我们int *p定义一个指针变量p时，因为p是局部变量，所以也遵循C语言局部变量的一般规律（定义局部变量并且未初始化，则值是随机的），所以此时p变量中存储的是一个随机的数字。

(2)此时如果我们解引用p，则相当于我们访问了这个随机数字为地址的内存空间。那这个空间到底能不能访问不知道（也许行也许不行），所以如果直接定义指针变量未绑定有效地址就去解引用几乎必死无疑。
(3)定义一个指针变量，不经绑定有效地址就去解引用，就好象拿一个上了镗的枪随意转了几圈然后开了一枪。
(4)指针绑定的意义就在于：让指针指向一个可以访问、应该访问的地方（就好象拿着枪瞄准目标的过程一样），指针的解引用是为了间接访问目标变量（就好象开枪是为了打中目标一样）

@定义（声明）

int *p = NULL// 初始化，防止野指针

@关联

int a = 10;

p = &a；// p->a

@解引用

int b = *p;// 读空间，等价b=a；

*p = 30;// 写空间，等价a=30；

指针带来的一些符号的理解

我们写的代码是给编译器看的，代码要想达到你想象的结果，就必要编译器对你的代码的理解和你自己对代码的理解一样。编译器理解代码就是理解符号，所以我们要正确理解C语言中的符号，才能像编译器一样思考程序、理解代码。
1.星号*
(1)C语言中*可以表示乘号，也可以表示指针符号。这两个用法是毫无关联的，只是恰好用了同一个符号而已。

(2)星号在用于指针相关功能的时候有2种用法：

第一种是指针定义时，*结合前面的类型用于表明要定义的指针的类型；

int *p;//表明p是int类型的指针变量

第二种功能是指针解引用，解引用时*p表示p指向的变量本身

int *p = &a;

*p = 30;// 等价于a=30;

2.取地址符&
取地址符使用时直接加在一个变量的前面，然后取地址符和变量加起来构成一个新的符号，这个符号表示这个变量的地址。


3.指针定义并初始化、与指针定义然后赋值的区别
(1)指针定义时可以初始化，指针的初始化其实就是给指针变量初值（跟普通变量的初始化没有任何本质区别）。
(2)指针变量定义同时初始化的格式是：int a = 32; int *p = &a;
(3)不初始化时指针变量先定义再赋值：int a = 32; int *p; p = &a;正确的
*p = &a; 错误的(这个等价于a=&a，相当于把地址给了a自己，显然是不对)
4.左值与右值
(1)放在'='左边的就叫左值，右边的就叫右值。所以赋值操作其实就是：左值 = 右值;
(2)当一个变量做左值时，编译器认为这个变量符号的真实含义是这个变量所对应的那个内存空间；当一个变量做右值时，编译器认为这个变量符号的真实含义是这个变量的值，也就是这个变量所对应的内存空间中存储的那个数。
(3)左值与右值的区别，就好象现实生活中“家”这个字的含义。譬如“我回家了”，这里面的家指的是你家的房子（类似于左值）；但是说“家比事业重要”，这时候的家指的是家人（家人就是住在家所对应的那个房子里面的人，类似于右值）

野指针问题

1.什么是野指针？有什么危害？哪里来的？

1、定义：

指针指向一个不确定的地址空间，或者虽然指向一个确定的地址空间，但引用空间的结果却是不可预知的，这样的指针就称为野指针。

例如：

int *p;

*p = 10; // p存放的是一个随机值，访问一个不确定的地址空间，结果显然是不可预知的。

2、危害：

指针因为指向地址是不可预知的，所以有3种情况：

@指向不可访问（操作系统不允许访问的敏感地址，譬如内核空间）的地址，触发段错误（Sgmentation fault）

@指向一个可用的、而且没什么特别意义的空间（譬如我们曾经使用过但是已经不用的栈空间或堆空间），这时候程序运行不会出错，也不会对当前程序造成损害，这种情况下会掩盖你的程序错误，让你以为程序没问题，其实是有问题的；

@指向了一个可用的空间，而且这个空间其实在程序中正在被使用（譬如说是程序的一个变量x），那么野指针的解引用就会刚好修改这个变量x的值，导致这个变量莫名其妙的被改变，程序出现离奇的错误。一般最终都会导致程序崩溃，或者数据被损害。

3、来源：

如指针变量如果是局部变量，则分配在栈上，本身遵从栈的规律（反复使用，使用完不擦除，所以是脏的，本次在栈上分配到的变量的默认值是上次这个栈空间被使用时余留下来的值），就决定了栈的使用多少会影响这个默认值。因此野指针的值是有一定规律不是完全随机，但是这个值的规律对我们没意义。

一般有三种来源：

@定义指针时，忘记初始化，导致指针指向不确定。

@不清楚某些地址空间的访问权限，但是指针试图指向这些空间，并且按照不允许的权限去操作。

int *p = "hello"；

*(p+1) = 'w';

由于hello作为字符串常量，存放在内存中的常量区中，该段内存只允许读操作。

但是上面却试图写不允许写的空间，一定会导致段错误。

@访问空间时，内存越界导致野指针

int a[4] = {0}；

*(buf+4) = 10；

2.怎么避免野指针？
(1)简单来说：野指针的错误来源就是指针定义了以后没有初始化，也没有赋值（总之就是指针没有明确的指向一个可用的内存空间），然后去解引用。
(2)知道了野指针产生的原因，避免方法就出来了：在指针的解引用之前，一定确保指针指向一个绝对可用的空间。

(3)常规的做法是：

int *p=NULL;

if(NULL != p) {

*p = 100;

｝else printf("p == NULL\n");

第一点：定义指针时，同时初始化为NULL

第二点：在指针解引用之前，先去判断这个指针是不是NULL
第三点：指针使用完之后，将其赋值为NULL
第四点：在指针使用之前，将其赋值绑定给一个可用地址空间
(4)野指针的防治方案4点绝对可行，但是略显麻烦。很多人懒得这么做，那实践中怎么处理？在中小型程序中，自己水平可以把握的情况下，不必严格参照这个标准；但是在大型程序，或者自己水平感觉不好把握时，建议严格参照这个方法。


3.NULL到底是什么？
(1)NULL在C/C++中定义为：
#ifdef _cplusplus // 这个符号被定义就表示当前是C++环境
#define NULL 0 // 在C++中NULL就是0
#else
#define NULL (void *)0 // 在C中NULL是强制类型转换为void *的0
#endif

(2)在C语言中，int *p;你可以p = (int *)0;但是不可以p = 0;因为类型不相同。

(3)所以NULL的实质其实就是0，然后我们给指针赋初值为NULL，其实就是让指针指向0地址处。为什么指向0地址处？

2个原因：

第一层原因是0地址处作为一个特殊地址（我们认为指针指向这里就表示指针没有被初始化，就表示是野指针）；

第二层原因是这个地址0地址在一般的操作系统中都是不可被访问的，如果C语言程序员不按规矩（不检查是否等于NULL就去解引用）写代码直接去解引用就会触发段错误，这种已经是最好的结果了。

(4)一般在判断指针是否野指针时，都写成
if (NULL != p)
而不是写成 if (p != NULL)
原因是：如果NULL写在后面，当中间是==号的时候，有时候容易忘记写成了=，这时候其实程序已经错误，但是编译器不会报错。这个错误（对新手）很难检查出来；如果习惯了把NULL写在前面，当错误的把==写成了=时，编译器会报错，程序员会发现这个错误。

const关键字与指针

1.const修饰指针的4种形式
(1)const关键字，在C语言中用来修饰变量，表示这个变量是常量。
(2)const修饰指针有4种形式，区分清楚这4种即可全部理解const和指针。
第一种：const int *p;
第二种：int const *p;
第三种：int * const p;
第四种：const int * const p;
(3)关于指针变量的理解，主要涉及到2个变量：第一个是指针变量p本身，第二个是p指向的那个变量(*p)。一个const关键字只能修饰一个变量，所以弄清楚这4个表达式的关键就是搞清楚const放在某个位置是修饰谁的

(4)理解：

一句话“近水楼台先得月”,除掉类型名int，只看const,和哪一个近就修饰哪一个。

第一种：const int *p；

const *p；// *p，p指向的空间内容不能修改
第二种：int const *p; 

const *p；// *p，p指向的空间内容不能修改
第三种：int * const p;

const p；// p，p本身存储的地址不能修改
第四种：const int * const p;

const * const p // *p,p，很明显两者都不能修改

2.const修饰的变量真的不能改吗？

(1)看一个例子：

int const a = 10;

int *p = (int *)&a;

*p = 100；

结果：a = 100；

const修饰的变量其实是可以改的（用指针修改；前提是gcc环境下,Vc下也行）。

(2)在某些单片机环境下，const修饰的变量是不可以改的。const修饰的变量到底能不能真的被修改，取决于具体的环境，C语言本身并没有完全严格一致的要求。
(3)在gcc中，const是通过编译器在编译的时候执行检查来确保实现的（也就是说const类型的变量不能改是编译错误，不是运行时错误。）所以我们只要想办法骗过编译器，就可以修改const定义的常量，而运行时不会报错。
(4)更深入一层的原因，是因为gcc把const类型的常量也放在了data段，其实和普通的全局变量放在data段是一样实现的，只是通过编译器认定这个变量是const的，运行时并没有标记const标志，所以只要骗过编译器就可以修改了。


3.const究竟应该怎么用
const是在编译器中实现的，编译时检查，并非不能骗过。所以在C语言中使用const，就好象是 一种道德约束而非法律约束，所以大家使用const时更多是传递一种信息，就是告诉编译器、也告诉读程序的人，这个变量是不应该也不必被修改的。

深入学习一下数组

1.从内存角度来理解数组
(1)从内存角度讲，数组变量就是一次分配多个变量，而且这多个变量在内存中的存储单元是依次相连接的。
(2)我们分开定义多个变量（譬如int a, b, c, d;）和一次定义一个数组（int a[4]）；这两种定义方法相同点是都定义了4个int型变量，而且这4个变量都是独立的单个使用的；不同点是单独定义时a、b、c、d在内存中的地址不一定相连，但是定义成数组后，数组中的4个元素地址肯定是依次相连的。
(3)数组中多个变量虽然必须单独访问，但是因为他们的地址彼此相连，因此很适合用指针来操作，因此数组和指针天生就叫纠结在一起。


2.从编译器角度来理解数组
(1)从编译器角度来讲，数组变量也是变量，和普通变量和指针变量并没有本质不同。变量的本质就是一个地址，这个地址在编译器中决定具体数值，具体数值和变量名绑定，变量类型决定这个地址的延续长度。
(2)搞清楚：变量、变量名、变量类型这三个概念的具体含义，很多问题都清楚了。
int a;  char a;


3.数组中几个关键符号（a a[0] &a &a[0]）的理解（前提是 int a[10]）
(1)这4个符号搞清楚了，数组相关的很多问题都有答案了。理解这些符号的时候要和左值右值结合起来，也就是搞清楚每个符号分别做左值和右值时的不同含义。

(2)

int a[10] = {0}；

sizeof(a) = 40;

sizeof(a[0]) = 4;

sizeof(&a) = 4;

sizeof(&a[0]) = 4;

1-@a就是数组名。a做左值时表示整个数组的所有空间（10×4=40字节），又因为C语言规定数组操作时要独立单个操作，不能整体操作数组，所以a不能做左值；a做右值表示数组首元素（数组的第0个元素，也就是a[0]）的首地址（首地址就是起始地址，就是4个字节中最开始第一个字节的地址）。a做右值等同于&a[0];

有一个特例！！！：

笔者老是认为sizeof(a)应该等于4，因为相当于&a[0]；查看sizeof手册得知：

　4、当操作数具有数组类型时，其结果是数组的总字节数。

 

    例如: char a[5];

          int  b[5];

          sizeof(a) = 5;

          sizeof(b) = 20;

sizeof(数组名)的时候，数组名不做左值也不做右值，纯粹就是数组名的含义。那么sizeof(数组名)实际返回的是整个数组所占用内存空间（以字节为单位的）。所以笔者将此归为一个特例~

2-@a[0]表示数组的首元素，也就是数组的第0个元素。做左值时表示数组第0个元素对应的内存空间（连续4字节）；做右值时表示数组第0个元素的值（也就是数组第0个元素对应的内存空间中存储的那个数）
3-@&a就是数组名a取地址，字面意思来看就应该是数组的地址。&a不能做左值（&a实质是一个常量，不是变量因此不能赋值，所以自然不能做左值。）；&a做右值时表示整个数组的首地址。
4-@&a[0]字面意思就是数组第0个元素的首地址（搞清楚[]和&的优先级，[]的优先级要高于&，所以a先和[]结合再取地址）。。同理只能做右值，&a[0]等同于a。

解释：为什么数组的地址是常量？

因为数组是编译器在内存中自动分配的。当我们每次执行程序时，运行时都会帮我们分配一块内存给这个数组，只要完成了分配，这个数组的地址就定好了，本次程序运行直到终止都无法再改了。那么我们在程序中只能通过&a来获取这个分配的地址，却不能去用赋值运算符修改它。

总结：

1：&a和a做右值时的区别：

一句话：“湖南省政府在长沙，长沙市政府在长沙”

&a是整个数组的首地址，而a是数组首元素的首地址。这两个在数字上是相等的，但是意义不相同。意义不相同会导致他们在参与运算的时候有不同的表现。

2：a和&a[0]做右值时意义和数值完全相同，完全可以互相替代。
3：&a是常量，不能做左值。
4：a做左值代表整个数组所有空间，所以a不能做左值。

指针与数组的天生姻缘

1.以指针方式来访问数组元素
(1)数组元素使用时不能整体访问，只能单个访问。访问方式有2种：数组形式和指针形式。
(2)数组格式访问数组元素是：数组名[下标]; (注意下标从0开始)
(3)指针格式访问数组元素是：*(指针+偏移量);

如果指针是数组首元素地址（a或者&a[0]），那么偏移量就是下标；指针也可以不是首元素地址而是其他哪个元素的地址，这时候偏移量就要考虑叠加了。

(4)数组下标方式和指针方式均可以访问数组元素，两者的实质其实是一样的。

在编译器内部都是用指针方式来访问数组元素的，数组下标方式只是编译器提供给编程者一种壳（语法糖）而已。所以用指针方式来访问数组才是本质的做法。


2.从内存角度理解指针访问数组的实质
(1)数组的特点就是：数组中各个元素的地址是依次相连的，而且数组还有一个很大的特点（其实也是数组的一个限制）就是数组中各个元素的类型比较相同。类型相同就决定了每个数组元素占几个字节是相同的（譬如int数组每个元素都占4字节，没有例外）。
(2)数组中的元素其实就是地址相连接、占地大小相同的一串内存空间。这两个特点就决定了只要知道数组中一个元素的地址，就可以很容易推算出其他元素的地址。


3.指针和数组类型的匹配问题
(1)int *p; int a[5]; p = a;// 类型匹配
(1)int *p; int a[5]; p = &a;// 类型不匹配。p是int *，&a是整个数组的指针，也就是一个数组指针类型(int (*)[5])，不是int指针类型，所以不匹配
(2)&a、a、&a[0]从数值上来看是完全相等的，但是意义来看就不同了。从意义上来看，a和&a[0]是数组首元素首地址，而&a是整个数组的首地址；从类型来看，a和&a[0]是元素的指针，也就是int *类型；而&a是数组指针，是int (*)[5];类型。


4.总结：指针类型决定了指针如何参与运算
(1)指针参与运算时，因为指针变量本身存储的数值是表示地址的，所以运算也是地址的运算。
(2)指针参与运算的特点是，指针变量+1，并不是真的加1，而是加1*sizeof(指针类型)；如果是int *指针，则+1就实际表示地址+4，如果是char *指针，则+1就表示地址+1；如果是double *指针，则+1就表示地址+8.
(3)指针变量+1时实际不是加1而是加1×sizeof(指针类型)，主要原因是希望指针+1后刚好指向下一个元素（而不希望错位）。

指针与强制类型转换

1.变量的数据类型的含义
(1)所有的类型的数据存储在内存中，都是按照二进制格式存储的。所以内存中只知道有0和1，不知道是int的、还是float的还是其他类型。

(2)int、char、short等属于整形，他们的存储方式（数转换成二进制往内存中放的方式）是相同的，只是内存格子大小不同（所以这几种整形就彼此叫二进制兼容格式）；

而float和double的存储方式彼此不同，和整形更不同。

(3)int a = 5;时，编译器给a分配4字节空间，并且将5按照int类型的存储方式转成二进制存到a所对应的内存空间中去（a做左值的）；我们printf去打印a的时候（a此时做右值），printf内部的vsprintf函数会按照格式化字符串（就是printf传参的第一个字符串参数中的%d之类的东西）所代表的类型去解析a所对应的内存空间，解析出的值用来输出。

也就是说，存进去时是按照这个变量本身的数据类型来存储的；但是取出来时是按照printf中%d之类的格式化字符串的格式来提取的。此时虽然a所代表的内存空间中的0101序列并没有变（内存是没被修改的）但是怎么理解（怎么把这些1010转成数字）就不一定了。譬如我们用%d来解析，那么还是按照int格式解析则值自然还是5；但是如果用%f来解析，则printf就以为a对应的内存空间中存储的是一个float类型的数，会按照float类型来解析，值自然是很奇怪的一个数字了。

总结：C语言中的数据类型的本质，就是决定了这个数在内存中怎么存储的问题，也就是决定了这个数如何转成二进制的问题。一定要记住的一点是内存只是存储0101的序列，而不管这些1010怎么解析。所以要求我们平时数据类型不能瞎胡乱搞。

详情请查询数值在计算机内部的存储。

分析几种情况：

* 按照int类型存却按照float类型取一定会出错

* 按照int类型存却按照char类型取有可能出错也有可能不出错

* 按照int类型存却按照short类型取有可能出错也有可能不出错

* 按照float类型存却按照double取一定会出错

注：int和char类型都是整形，类型兼容的。int和char的不同在于char只有1个字节而int有4个字节，所以int的范围比char大。在char所表示的范围之内int和char是可以互转的不会出错；但是超过了char的范围后char转成int就不一定了。（向大方向转就不会错，就好比拿小瓶子的水往大瓶子倒不会漏掉不会丢掉），而从int到char转就会出错（就好象拿大瓶子水往小瓶子倒一样）。

eg:

char a = 100;

int b = (int)a;// 没问题

int a = 0x11223344

char b = (int)a;// 有问题

int a = 0x00000001

char b = (int)a;// 不确定，需考虑大小段问题。

2.指针的数据类型的含义

(1)指针的本质是：变量，指针就是指针变量
(2)一个指针涉及2个变量：一个是指针变量自己本身，一个是指针变量指向的那个变量
(3)int *p;定义指针变量时，p（指针变量本身）是int *类型，*p（指针指向的那个变量）是int类型的。
(4)int *类型说白了就是指针类型，只要是指针类型就都是占4字节，解析方式都是按照地址的方式来解析（意思是里面存的32个二进制加起来表示一个内存地址）的。结论就是：所有的指针类型（不管是int * 还是char * 还是double *）的解析方式是相同的，都是地址。
(5)对于指针所指向的那个变量来说，指针的类型就很重要了。指针所指向的那个变量的类型（它所对应的内存空间的解析方法）要取决于指针类型。譬如指针是int *的，那么指针所指向的变量就是int类型的。


3.指针数据类型转换实例分析1（int * -> char *）
(1)int和char类型都是整形，类型兼容的。所以互转的时候有时候错有时候对。
(2)int和char的不同在于char只有1个字节而int有4个字节，所以int的范围比char大。在char所表示的范围之内int和char是可以互转的不会出错；但是超过了char的范围后char转成int就不一定了。（向大方向转就不会错，就好比拿小瓶子的水往大瓶子倒不会漏掉不会丢掉），而从int到char转就会出错（就好象拿大瓶子水往小瓶子倒一样）


4.指针数据类型转换实例分析2（int * -> float *）
之前分析过：int和float的解析方式是不兼容的，所以int *转成float *再去访问绝对会出错。

指针、数组与sizeof运算符

(1)sizeof是C语言的一个运算符（主要sizeof不是函数，虽然用法很像函数），sizeof的作用是用来返回()里面的变量或者数据类型占用的内存字节数。
(2)sizeof存在的价值？主要是因为在不同平台下各种数据类型所占的内存字节数不尽相同（譬如int在32位系统中为4字节，在16位系统中为2字节···）。所以程序中需要使用sizeof来判断当前变量/数据类型在当前环境下占几个字节。

1.char str[] = ”hello”;  

sizeof(str) //6

sizeof(str[0]) //1

strlen(str) //5 strlen不算结尾的'\0'

2.char *p=str;   

sizeof(p)// 4

sizeof(*p)// 1

strlen(p)// 5

(1)32位系统中所有指针的长度都是4，不管是什么类型的指针。
(2)strlen是一个C库函数，用来返回一个字符串的长度（注意，字符串的长度是不计算字符串末尾的'\0'的）。一定要注意strlen接收的参数必须是一个字符串（字符串的特征是以'\0'结尾）

3.int n=10; 

sizeof(n) // 4

sizeof测试一个变量本身，和sizeof测试这个变量的类型，结果是一样的。

4.int b[100]; 

sizeof(b) // 400

sizeof(数组名)的时候，数组名不做左值也不做右值，纯粹就是数组名的含义。那么sizeof(数组名)实际返回的是整个数组所占用内存空间（以字节为单位的）。
5.
void fun(int b[100])//等价于int b[ ]和int *b
{
printf("%d.\n",sizeof(b))  // 4
}
(1)函数传参，形参是可以用数组的
(2)函数形参是数组时，实际传递是不是整个数组，而是数组的首元素首地址。也就是说函数传参用数组来传，实际相当于传递的是指针（指针指向数组的首元素首地址）。


6.关于#define和typedef

#define dpChar char *

typedef char *tpChar; // typedef重命名类型

int main(void)

{

dpChar p1, p2; // 展开： char *p1,p2 <==> char *p1,char p2;

tpChar p3, p4; // 等价于：char *p3,char *p3;

printf("%d.\n%d.\n%d.\n%d.\n",sizeof(p1),sizeof(p2),sizeof(p3),sizeof(p4)); // 4 1 4 4

return 0;

}

注：#define在预编译时被处理(只做简单替换)，typedef在编译时被处理。

指针与函数传参

1.普通变量作为函数形参
(1)函数传参时，普通变量作为参数时，形参和实参名字可以相同也可以不同，实际上都是用实参来替代相对应的形参的。
(2)在子函数内部，形参的值等于实参。原因是函数调用时把实参的值赋值给了形参。
(3)这就是很多书上写的“传值调用”（相当于实参做右值，形参做左值）

例：

void func1(int b)

{

printf("b = %d.\n",b);

printf("in func1, &b = %p.\n",&b);

}

int main()

{

int a = 4;

printf("&a = %p.\n",&a);

func1(a);

return 0;

}

注：a、b不是同一个变量，内存中是独立的2个内存空间

2.数组作为函数形参
(1)函数名作为形参传参时，实际传递是不是整个数组，而是数组的首元素的首地址（也就是整个数组的首地址。因为传参时是传进来的是地址的值，所以这两个没区别）。所以在子函数内部，传进来的数组名就等于是一个指向数组首元素首地址的指针。所以sizeof得到的是4.
(2)在子函数内传参得到的数组首元素首地址，和外面得到的数组首元素首地址的值是相同的。很多人把这种特性叫做“传址调用”（所谓的传址调用就是调用子函数时传了地址（也就是指针），此时可以通过传进去的地址来访问实参。）
(3)数组作为函数形参时，[]里的数字是可有可无的。为什么？因为数组名做形参传递的实际只是个指针，根本没有数组长度这个信息。

void func1(int a[])

{

printf("sizeof(a) = %d.\n",sizeof(a));

printf("in func1,a = %p.\n",a);

}

int main()

{

int a[5];

printf("a = %p.\n",a);

func1(a);

return 0;

}

注释：我在64位linux下测试的，所以每个指针为8而不是4，所以所以sizeof(a)=8；一般都是32位下的！

3.指针作为函数形参

只有一句话：和数组作为函数形参是一样的。这就好像指针方式访问数组元素和数组方式访问数组元素的结果一样是相同的。void func1(int a[])改成void func1(*a);


4.结构体变量作为函数形参

(1)结构体变量作为函数形参的时候，实际上和普通变量（类似于int之类的）传参时表现是一模一样的。所以说结构体变量其实也是普通变量而已。

struct A

{

char a; // 结构体变量对齐问题

int b; // 因为要对齐存放，所以大小是8

};

void func1(struct A a1)

{

printf("sizeof(a1) = %d.\n",sizeof(a1));

printf("a1 = %p.\n",&a1);

printf("a1.b = %d.\n",a1.b);

}

int main()

{

struct A a =

{

.a = 4,

.b = 5555,

};

//linux内核常用，C99支持，gcc扩展一种结构体赋值方式

printf("sizeof(a) = %d.\n",sizeof(a));

printf("a = %p.\n",&a);

printf("a.b = %d.\n",a.b);

func1(a);

return 0;

}

注:形参和实参两个独立的内存单元。

(2)因为结构体一般都很大，所以如果直接用结构体变量进行传参，那么函数调用效率就会很低。（因为在函数传参的时候需要将实参赋值给形参，所以当传参的变量越大调用效率就会越低）。怎么解决？思路只有一个那就是不要传变量了，改传变量的指针（地址）进去。

struct A

{

char a; // 结构体变量对齐问题

int b; // 因为要对齐存放，所以大小是8

};

void func1(struct A *a1)

{

printf("sizeof(a1) = %ld.\n",sizeof(a1));

printf("sizeof(*a1) = %ld.\n",sizeof(*a1));

printf("a1 = %p.\n",a1);

printf("a1->b = %d.\n",a1->b); // 访问结构体时，左边是变量就用.，左边是指针就必须用->

}

int main()

{

struct A a =

{

.a = 4,

.b = 5555,

}; // linux内核常用，C99支持，gcc扩展一种结构体赋值方式

printf("sizeof(a) = %ld.\n",sizeof(a));

printf("&a = %p.\n",&a);

printf("a->b = %d.\n",a.b); // 访问结构体时，左边是变量就用.，左边是指针就必须用->

func1(&a);

return 0;

}

注：

(1)形参和实参同一个内存单元

(2)64位系统，所以sizeof(指针) = 8，用%ld。

结论：结构体因为自身太大，所以传参应该用指针来传（但是程序员可以自己决定，你非要传结构体变量过去C语言也是允许的，只是效率低了）；回想一下数组，为什么C语言设计的时候数组传参默认是传的数组首元素首地址而不是整个数组？也是因为如果数组太大，效率太低。

5.传值调用与传址调用

@传值调用：传进去子函数的是拷贝原值的一个副本。在子函数中操控的是副本，原值被作用不到。

void swap1(int a,int b)

{

int tmp;

tmp = a;

a = b;

b = tmp;

printf("in swap1,a = %d, b = %d.\n",a,b);

}

int main()

{

int x = 3, y = 5;

swap1(x,y);

printf("x = %d, y = %d.\n",x,y); // x = 3, y = 5;交换失败。

return 0;

}

@传址调用：实际上参数x和y永远无法真身进入子函数内部（进去的只能是拷贝的副本），但是把参数的地址传进去了，于是在子函数内可以通过指针的解引用方式从函数内部访问到外部的x和y原值，从而改变x和y。

void swap2(int *a,int *b)

{

int tmp;

tmp = *a;

*a = *b;

*b = tmp;

printf("in swap2,*a = %d, *b = %d.\n",*a,*b);

}

int main()

{

int x = 3, y = 5;

swap2(&x,&y);

printf("x = %d, y = %d.\n",x,y); // x = 5, y = 3;交换成功。

return 0;

}

结论：这个世界上根本没有传值和传址这两种方式，C语言本身函数调用时一直是传值的，只不过传的值可以是变量名，也可以是变量的指针。

输入型参数与输出型参数

1.函数为什么需要形参与返回值

(1)函数名是一个符号，表示整个函数代码段的首地址（实质是一个指针常量）。在程序中都是当地址用的，用来调用这个函数。

(2)形参列表和返回值。形参是函数的输入部分，返回值是函数的输出部分。

对函数最好的理解就是把函数看成是一个加工机器（程序其实就是数据处理器）

形参列表-机器的原材料输入端；

返回值-机器的成品输出端。

(3)如果没有形参列表和返回值，函数也能对数据进行加工。用全局变量即可。

一个是全局变量来传参，一个是函数参数列表返回值来传参。

eg:

int multip5(int a);

void multip5_2(void);

int x; // 被乘5的变量

int y; // 输出结果的变量

int main(void)

{

// 程序要完成的功能：对一个数乘以5

// 第一种方法：函数传参

int a = 3;

int b;

b = multip5(a);

printf("result = %d.\n",b);

// 第二种方法：用全局变量来传参

x = 2;

multip5_2();

printf("y = %d.\n",y);

}

void multip5_2(void)

{

y = 5 * x;

}

int multip5(int a)

{

return a*5;

}

注：

总的来说，函数参数传参用的比较多，这样可以实现模块化编程。

C语言中也是尽量减少使用全局变量。

(4)全局变量传参最大的好处就是省略了函数传参的开销，效率高；

实战中用的多的还是函数传参，如果参数很多传参开销很大，通过做法是把很多参数打包成一个结构体，然后通过传结构体变量指针进去。

2.函数传参中使用const指针

(1)const一般用在函数传参列表中，用法是const int *p； //p本身可变，*p即p所指向的变量不可变

(2)const用来修饰指针做函数传参，作用就在于声明在函数内部不会改变这个指针所指向的内容，所以给该函数传一个不可改变的指针（char *p = "linux"；这种）不会触发错误；而一个未声明为const的指针的函数，传一个不可改变的指针的时候就要小心。

eg:

void func1(char *p); // 这样声明就容易引起不注意，在函数中去修改会导致段错误

void func2(const char *p); // 这样声明的意义就在于指明函数一定是不可变的,如果函数中能有修改的操作，编译时就会报错，在函数中不能去修改。

void func3(char *p);

int main(void)

{

char *pStr1 = "linux";

//char *pStr2 = "linux";

char pStr3[] = "linux"; // 如果需要修改就定义为数组这种类型。

func1(pStr1);

//func2(pStr2);

func3(pStr3);

printf("%s.\n",pStr1);

//printf("%s.\n",pStr2);

printf("%s.\n",pStr3);

}

void func1(char *p)

{

//*p = 'a';

}

/*void func2(const char *p)

{

*p = 'a';

}*/

void func3(char *p)

{

*p = 'a';

}

如果把func2的注释去掉：

3.函数需要向外部返回多个值时怎么办？

(1)一般来说函数参数可以有多个，而返回值只能有一个。

(2)通常的做法是用参数来返回（在典型的Linux风格函数中，返回值是不用来返回结果的，而是用来返回0或者负数，用来表示程序执行结果是对还是错）

(3)普遍做法，编程中函数的输入和输出都是靠函数参数的，返回值只是用来表示函数执行的结果的正确性。

eg:

int multip5(int a, int *p)

{

int tmp;

tmp = 5*a;

if (tmp > 100)

{

return -1;

}

else

{

*p = tmp;

return 0;

}

}

int main(void)

{

int a,b=0,ret=-1;

a = 3;

ret = multip5(a,&b);

if (ret == -1)

{

printf("error!!!\n");

}

else

{

printf("result = %d.\n",b);

}

}

结果：

result = 15.

4.总结

怎样一眼区分函数的参数哪个作输入，哪个作输出？

1、如果传的是普通变量（不是指针），那肯定是输入型参数。

2、如果传的是指针就有2种可能。

为了区分，做法是：

如果这个指针变量参数是做输入的（通常做输入的在函数内部只需要读取这个参数而不会需要更改它），在指针前面加const修饰。

如果这个指针变量参数没加const，则表示是输出型参数。

eg:譬如C库函数中strcpy函数 man 3 strcpy