nx123

这个屌丝很懒，什么也没留下！

热门标签

C语言高级专题（3）------- 指针_*什么情况代表乘号什么情况代表间接寻址

作者：nx123 | 2024-02-06 15:01:38

踩

*什么情况代表乘号什么情况代表间接寻址

一，指针到底是什么

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

代码：
	// a的实质其实就是一个编译器中的符号，在编译器中a和一个内存空间联系起来
	// 这个内存空间就是a所代表的那个变量。
	int a;			// 定义了int型变量，名字叫a
	int *p;			// 定义了一个指针变量，名字叫p，p指向一个int型变量
	
	a = 4;			// 可以操作
	p = 4;			// 编译器不允许，因为指针变量虽然实质上也是普通变量，但是它的
				// 用途和普通变量不同。指针变量存储的应该是另外一个变量的地址
				// 而不是用来随意存一些int类型的数。
	
	p = (int *)4;		// 我们明知道其实就是数字4，但是我强制类型转换成int *类型的4
				// 相当于我告诉编译器，这个4其实是个地址（而且是个int类型变量
				// 的地址），那么(int *)4就和p类型相匹配了，编译器就过了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、为什么需要指针？

指针的出现是为了实现间接访问。在汇编中都有间接访问，其实就是CPU的寻址方式中的间接寻址。
间接访问（CPU的间接寻址）是CPU设计时决定的，这个决定了汇编语言必须能够实现间接寻址，又决定了汇编之上的C语言也必须实现简介寻址。

3、指针使用三部曲：定义指针变量、关联指针变量、解引用

(1)当我们int *p定义一个指针变量p时，因为p是局部变量，所以也遵循C语言局部变量的一般规律（定义局部变量并且未初始化，则值是随机的），所以此时p变量中存储的是一个随机的数字。
(2)此时如果我们解引用p，则相当于我们访问了这个随机数字为地址的内存空间。那这个空间到底能不能访问不知道（也许行也许不行），所以如果直接定义指针变量未绑定有效地址就去解引用就有可能会出现错误。
(3)定义一个指针变量，不经绑定有效地址就去解引用，就好象拿一个上了镗的枪随意转了几圈然后开了一枪。
(4)指针绑定的意义就在于：让指针指向一个可以访问、应该访问的地方（就好象拿着枪瞄准目标的过程一样），指针的解引用是为了间接访问目标变量（就好象开枪是为了打中目标一样）

代码：

	// 演示指针的标准使用方式
	// 指针使用分3步：定义指针变量、给指针变量赋值（绑定指针）、解引用
	int a = 23;     			
	// 第一步，定义指针变量
	int *p;
	printf("p = %p.\n", p);		// %p打印指针和%x打印指针，打印出的值是一样的
	printf("p = 0x%x.\n", p);

	// 第二步，绑定指针，其实就是给指针变量赋值，也就是让这个指针指向另外一个变量
	// 当我们没有绑定指针变量之前，这个指针不能被解引用。
	p = &a;				// 实现指针绑定，让p指向变量a
	p = (int *)4;			// 实现指针绑定，让p指向内存地址为4的那个变量
	
	// 第三步，解引用。
	// 如果没有绑定指针到某个变量就去解引用，几乎一定会出错。
	*p = 555;			// 把555放入p指向的变量中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

1、星号*

(1)C语言中*可以表示乘号，也可以表示指针符号。这两个用法是毫无关联的，只是恰好用了同一个符号而已。
(2)星号在用于指针相关功能的时候有2种用法：第一种是指针定义时，*结合前面的类型用于表明要定义的指针的类型；第二种功能是指针解引用，解引用时 *p 表示p指向的变量本身。

2、取地址符&

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

	int a;		
	int *p;
	p = &a;		
1
2
3

&a就表示a的地址。编译器一看到&a，就知道我们是要把变量a的地址赋值给指针变量p，因为变量a的地址是编译器分配的，所以只有编译器才知道a的地址，所以我们没法直接把a的地址的数字赋值给p，只有用符号&a来替代。

3、指针定义并初始化、与指针定义然后赋值的区别

(1)指针定义时可以初始化，指针的初始化其实就是给指针变量初值（跟普通变量的初始化没有任何本质区别）。
(2)指针变量定义同时初始化的格式是：int a = 32; int *p = &a;
(3)不初始化时指针变量先定义再赋值：int a = 32; int *p; p = &a; 正确的，*p = &a; 错误的

4、左值与右值

(1)放在赋值运算符左边的就叫左值，右边的就叫右值。所以赋值操作其实就是：左值 = 右值;
(2)当一个变量做左值时，编译器认为这个变量符号的真实含义是这个变量所对应的那个内存空间；当一个变量做右值时，编译器认为这个变量符号的真实含义是这个变量的值，也就是这个变量所对应的内存空间中存储的那个数。
(3)左值与右值的区别，就好象现实生活中“家”这个字的含义。譬如“我回家了”，这里面的家指的是你家的房子（类似于左值；但是说“家比事业重要”，这时候的家指的是家人（家人就是住在家所对应的那个房子里面的人，类似于右值）

三，野指针问题

1、神马是野指针？

(1)野指针，就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
(2)野指针很可能触发运行时段错误（Sgmentation fault）
(3)因为指针变量在定义时如果未初始化，值也是随机的。指针变量的值其实就是别的变量（指针所指向的那个变量）的地址，所以意味着这个指针指向了一个地址是不确定的变量，这时候去解引用就是去访问这个地址不确定的变量，所以结果是不可知的。
(4)野指针因为指向地址是不可预知的，所以有3种情况：第一种是指向不可访问（操作系统不允许访问的敏感地址，譬如内核空间）的地址，结果是触发段错误，这种算是最好的情况了；第二种是指向一个可用的、而且没什么特别意义的空间（譬如我们曾经使用过但是已经不用的栈空间或堆空间），这时候程序运行不会出错，也不会对当前程序造成损害，这种情况下会掩盖你的程序错误，让你以为程序没问题，其实是有问题的；第三种情况就是指向了一个可用的空间，而且这个空间其实在程序中正在被使用（譬如说是程序的一个变量x），那么野指针的解引用就会刚好修改这个变量x的值，导致这个变量莫名其妙的被改变，程序出现离奇的错误。一般最终都会导致程序崩溃，或者数据被损害。这种危害是最大的。
(5)指针变量如果是局部变量，则分配在栈上，本身遵从栈的规律（反复使用，使用完不擦除，所以是脏的，本次在栈上分配到的变量的默认值是上次这个栈空间被使用时余留下来的值），就决定了栈的使用多少会影响这个默认值。

2、怎么避免野指针？

(1)野指针的错误来源就是指针定义了以后没有初始化，也没有赋值，然后去解引用。
(2)知道了野指针产生的原因，避免方法就出来了：在指针的解引用之前，一定确保指针指向一个绝对可用的空间。
(3)常规的做法是：
第一点：定义指针时，同时初始化为NULL
第二点：在指针解引用之前，先去判断这个指针是不是NULL
第三点：指针使用完之后，将其赋值为NULL
第四点：在指针使用之前，将其赋值绑定给一个可用地址空间

	int b,a=5;
	int *p = NULL;
	p = &a;				// 正确的使用指针的方式，是解引用指针前跟一个绝对可用的地址绑定
	if (NULL != p)
	{
		b=*p ;
	}
	p = NULL;			// 使用完指针变量后，记得将其重新赋值为NULL
1
2
3
4
5
6
7
8

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
1
2
3
4
5

(2)在C语言中，int *p;你可以p = (int *)0;但是不可以p = 0;因为类型不相同。
(3)所以NULL的实质其实就是0，然后我们给指针赋初值为NULL，其实就是让指针指向0地址处。为什么指向0地址处？原因是0地址处作为一个特殊地址，这个0地址在一般的操作系统中都是不可被访问的，如果C语言程序员不按规矩（不检查是否等于NULL就去解引用）写代码直接去解引用就会触发段错误，提醒程序员。
(4)一般在判断指针是否野指针时，都写成if (NULL != p)而不是写成if (p != NULL)
原因是：如果NULL写在后面，当中间是双=号的时候，有时候容易忘记写成了=，这时候其实程序已经错误，但是编译器不会报错。这个错误（对新手）很难检查出来；如果习惯了把NULL写在前面，当错误的把双=写成了=时，编译器会报错，程序员会发现这个错误。

四，指针与数组的天生姻缘

1、从内存角度来理解数组

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

2、从编译器角度来理解数组

(1)从编译器角度来讲，数组变量也是变量，和普通变量和指针变量并没有本质不同。变量的本质就是一个地址，这个地址在编译器中决定具体数值，具体数值和变量名绑定，变量类型决定这个地址的延续长度。

3、数组中几个关键符号（a ，a[0] ，&a ，&a[0]）的理解（前提是定义了一个数组int a[10]）

(1)这4个符号搞清楚了，数组相关的很多问题都有答案了。理解这些符号的时候要和左值右值结合起来，也就是搞清楚每个符号分别做左值和右值时的不同含义。
(2)a就是数组名。a做左值时表示整个数组的所有空间，又因为C语言规定数组操作时要独立单个操作，不能整体操作数组，所以a不能做左值；a做右值表示数组首元素的首地址（首地址就是起始地址，int数组中就是4个字节中最开始第一个字节的地址）。a做右值等同于&a[0];
(3)a[0]表示数组的首元素，也就是数组的第0个元素。做左值时表示数组第0个元素对应的内存空间（连续4字节）；做右值时表示数组第0个元素的值.
(4)&a就是数组名a取地址，字面意思来看就应该是数组的地址。&a不能做左值（&a实质是一个常量，不是变量因此不能赋值，所以自然不能做左值。）；&a做右值时表示整个数组的首地址。
(5)&a[0]字面意思就是数组第0个元素的首地址（搞清楚[]和&的优先级，[]的优先级要高于&，所以a先和[]结合再取地址）。做左值时表示数组首元素对应的内存空间，做右值时表示数组首元素的值。做右值时&a[0]等同于a。
解释：为什么数组的地址是常量？因为数组是编译器在内存中自动分配的。当我们每次执行程序时，运行时都会帮我们分配一块内存给这个数组，只要完成了分配，这个数组的地址就定好了，本次程序运行直到终止都无法再改了。那么我们在程序中只能通过&a来获取这个分配的地址，却不能去用赋值运算符修改它。

总结：

&a和a做右值时的区别：&a是整个数组的首地址，而a是数组首元素的首地址。这两个在数字上是相等的，但是意义不相同。意义不相同会导致他们在参与运算的时候有不同的表现。
a和&a[0]做右值时意义和数值完全相同，完全可以互相替代。
&a是常量，不能做左值。
a做左值代表整个数组所有空间，所以a不能做左值。

4、以指针方式来访问数组元素

(1)数组使用时不能整体访问，只能单个访问。访问方式有数组形式和指针形式。
(2)数组格式访问数组元素是：数组名[下标]; (注意下标从0开始)
(3)指针格式访问数组元素是：*(指针+偏移量); 如果指针是数组首元素地址（a或者&a[0]），那么偏移量就是下标；指针也可以不是首元素地址而是其他哪个元素的地址，这时候偏移量就要考虑叠加了。
(4)数组下标方式和指针方式均可以访问数组元素，两者的实质其实是一样的。在编译器内部都是用指针方式来访问数组元素的，数组下标方式只是编译器提供给编程者一种壳（语法糖）而已。所以用指针方式来访问数组才是本质的做法。

5、从内存角度理解指针访问数组的实质

(1)数组的特点就是：数组中各个元素的地址是依次相连的，数组中各个元素的类型相同。类型相同就决定了每个数组元素占几个字节是相同的（譬如int数组每个元素都占4字节，没有例外）。
(2)数组中的元素其实就是地址相连接、占地大小相同的一串内存空间。这两个特点就决定了只要知道数组中一个元素的地址，就可以很容易推算出其他元素的地址。

6、指针和数组类型的匹配问题

	(1)int *p; int a[5];	p = a;		// 类型匹配
	(1)int *p; int a[5];	p = &a;		// 类型不匹配。p是int *，&a是整个数组的指针，也就是一个数组指针类型，不是int指针类型，所以不匹配
1
2

&a、a、&a[0]从数值上来看是完全相等的，但是意义来看就不同了。从意义上来看，a和&a[0]是数组首元素首地址，而&a是整个数组的首地址从类型来看，a和&a[0]是元素的指针，也就是int 类型；而&a是数组指针，是int ()[5];类型。

7、指针类型决定了指针如何参与运算

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

五，指针与强制类型转换

1、变量的数据类型的含义

所有的类型的数据存储在内存中，都是按照二进制格式存储的，所以内存中只知道有0和1。
int、char、short等属于整形，他们的存储方式（数转换成二进制往内存中放的方式）是相同的，只是内存格子大小不同（所以这几种整形就彼此叫二进制兼容格式）；而float和double的存储方式彼此不同，和整形更不同。
例如int a = 5;时，编译器给a分配4字节空间，并且将5按照int类型的存储方式转成二进制存到a所对应的内存空间中去（a做左值的）；我们printf去打印a的时候（a此时做右值），printf内部的vsprintf函数会按照格式化字符串所代表的类型去解析a所对应的内存空间，解析出的值用来输出。
也就是说，存进去时是按照这个变量本身的数据类型来存储的（譬如本例中a为int所以按照int格式来存储）；但是取出来时是按照printf中%d之类的格式化字符串的格式来提取的。此时虽然a所代表的内存空间中的10101序列并没有变（内存是没被修改的）但是怎么理解（怎么把这些1010转成数字）就不一定了。
譬如我们用%d来解析，那么还是按照int格式解析则值自然还是5；但是如果用%f来解析，则printf就以为a对应的内存空间中存储的是一个float类型的数，会按照float类型来解析，值自然是很奇怪的一个数字了。

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

分析几个题目：
1. 按照int类型存却按照float类型取	     一定会出错
2. 按照int类型存却按照char类型取		有可能出错也有可能不出错
3. 按照short类型存却按照int类型取	     有可能出错也有可能不出错
4. 按照float类型存却按照double取		一定会出错
1
2
3
4
5

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

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

4、指针数据类型转换实例分析2

（int * -> float *）
1

(1)之前分析过：int和float的解析方式是不兼容的，所以int * 转成 float *再去访问绝对会出错。

六，指针、数组与sizeof运算符

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

1、char str[] = ”hello”; sizeof(str) ，sizeof(str[0]) ，strlen(str)

char str[] = "hello";  
	printf("sizeof(str) = %d.\n", sizeof(str));				// 6
	printf("sizeof(str[0]) = %d.\n", sizeof(str[0]));		// 1
	printf("strlen(str) = %d.\n", strlen(str));				// 5
1
2
3
4

char str[] = "hello";  
	char *p = str; 
	printf("sizeof(p) = %d.\n", sizeof(p));			// 4 相当于sizeof(char *)
	printf("sizeof(*p) = %d.\n", sizeof(*p));		// 1 相当于sizeof(char)
	printf("strlen(p) = %d.\n", strlen(p));			// 5 相当于strlen(str)
1
2
3
4
5

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

2、int n=10; sizeof(n)

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

int n = 10;
	printf("sizeof(n) = %d.\n", sizeof(n));			// 4
	printf("sizeof(int) = %d.\n", sizeof(int));		// 4
1
2
3

3、int b[100]; sizeof(b)

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

	int b1[100] = {0};
	printf("sizeof(b1) = %d.\n", sizeof(b1));		// 400 100×sizeof(int)
	
	short b2[100] = {};
	printf("sizeof(b2) = %d.\n", sizeof(b2));		// 200 100×sizeof(short)
	
	double b3[100];
	printf("sizeof(b3) = %d.\n", sizeof(b3));		// 800 100×sizeof(double)
1
2
3
4
5
6
7
8

4、数组传参

	void fun(int b[100])
		{
				sizeof(b);	   
		}					
1
2
3
4

(1)函数传参，形参是可以用数组的.
(2)函数形参是数组时，实际传递是不是整个数组，而是数组的首元素首地址。也就是说函数传参用数组来传，实际相当于传递的是指针（指针指向数组的首元素首地址）。

5、define 和 typedef的一些细节

#define dpChar char *
typedef char * tpChar;
1
2

dpChar p1,  p2;			// 展开：char *p1, p2; 相当于char *p1, char p2;
tpChar p3,  p4;			// 等价于：char *p3, char *p4;	
printf("sizeof(p1) = %d.\n", sizeof(p1));		// 4
printf("sizeof(p2) = %d.\n", sizeof(p2));		// 1
printf("sizeof(p3) = %d.\n", sizeof(p3));		// 4
printf("sizeof(p4) = %d.\n", sizeof(p4));		// 4
1
2
3
4
5
6

七，const关键字与指针

1.const关键字

const是constant的简写，只要一个变量前面用const来修饰，就意味着该变量里的数据可以被访问，不能被修改。也就是说const意味着“只读”readonly

2.const关键字应用

欲阻止一个变量被改变，可使用const，在定义该const变量时，需先初始化，以后就没有机会改变他了；
对指针而言，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
在一个函数声明中，const可以修饰形参表明他是一个输入参数，在函数内部不可以改变其值；
对于类的成员函数，有时候必须指定其为const类型，表明其是一个常函数，不能修改类的成员变量；

3、const修饰指针的4种形式

const关键字，在C语言中用来修饰变量，表示这个变量是常量。
const修饰指针有4种形式，区分清楚这4种即可全部理解const和指针。
第一种：const int *p;
第二种：int const *p;
第三种：int * const p;
第四种：const int * const p;
规则：const离谁近，谁就不能被修改；

int a = 5;
	
	// 第一种
	const int *p1;		// p本身不是cosnt的，而p指向的变量是const的
	// 第二种
	int const *p2;		// p本身不是cosnt的，而p指向的变量是const的
	
	
	// 第三种
	int * const p3;		// p本身是cosnt的，p指向的变量不是const的
	// 第四种
	const int * const p4;// p本身是cosnt的，p指向的变量也是const的
	
	*p1  = 3;		// error: assignment of read-only location ‘*p1’
	p1 = &a;		// 编译无错误无警告
	
	*p2 = 5;		// error: assignment of read-only location ‘*p2’
	p2 = &a;		// 编译无错误无警告
	
	*p3 = 5;		// 编译无错误无警告
	p3 = &a;		// error: assignment of read-only variable ‘p3’
	
	p4 = &a;		// error: assignment of read-only variable ‘p4’
	*p4 = 5;		// error: assignment of read-only location ‘*p4’
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

4、const修饰的变量真的不能改吗？

(1)const修饰的变量其实是可以改的（前提是gcc环境下）。

const int a = 5;
	//a = 6;				// error: assignment of read-only variable ‘a’
	int *p;
	p = (int *)&a;			// 这里报警高可以通过强制类型转换来消除
	*p = 6;
	printf("a = %d.\n", a);	// a = 6,结果证明const类型的变量被改了
	
1
2
3
4
5
6
7

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

5、const究竟应该怎么用

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

八，指针与函数传参

1、普通变量作为函数形参

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


void func1(int b)
{
	// 在函数内部，形参b的值等于实参a
	printf("b = %d.\n", b);
	printf("in func1, &b = %p.\n", &b);
}
int main(void)
{	
	int a = 4;     
	printf("&a = %p.\n", &a);     // &a = 0x7ffc3826c2f4.
	func1(a);                     //b = 4,    in func1, &b = 0x7ffc3826c2dc.

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结论： &a和&b不同，说明a和b不是同一个变量（在内存中a和b是独立的2个内存空间）但是a和b是有关联的，实际上b是a赋值得到的。

2、数组作为函数形参

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

void func2(int a[])
{
	printf("sizeof(a) = %d.\n", sizeof(a));
	printf("in func2, a = %p.\n", a);
}
int main(void)
{	
	int a[5];
	printf("a = %p.\n", a);        //a = 0x7ffc5e60ef00.
	func2(a);                    //sizeof(a) = 8.  in func2, a = 0x7ffc5e60ef00.
                                  //用到的是64位操作系统，所以sizeof(a)是8

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3、指针作为函数形参

和数组作为函数形参是一样的.这就好像指针方式访问数组元素和数组方式访问数组元素的结果一样是一样的。

void func3(int *a)
{
	printf("sizeof(a) = %d.\n", sizeof(a));
	printf("in func2, a = %p.\n", a);
}
int main(void)
{	
	int a[5];
	printf("a = %p.\n", a);
	func3(a);
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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

结构体变量作为函数形参的时候，实际上和普通变量（类似于int之类的）传参时表现是一模一样的。所以说结构体变量其实也是普通变量而已。
因为结构体一般都很大，所以如果直接用结构体变量进行传参，那么函数调用效率就会很低。（因为在函数传参的时候需要将实参赋值给形参，所以当传参的变量越大调用效率就会越低）。怎么解决？思路只有一个那就是不要传变量了，改传变量的指针（地址）进去。
结构体因为自身太大，所以传参应该用指针来传（但是程序员可以自己决定，你非要传结构体变量过去C语言也是允许的，只是效率低了）；回想一下数组，为什么C语言设计的时候数组传参默认是传的数组首元素首地址而不是整个数组？

结构体变量传参：

struct A
{
	char a;				// 结构体变量对齐问题
	int b;				// 因为要对齐存放，所以大小是8
};

void func4(struct A a1)
{
	printf("sizeof(a1) = %d.\n", sizeof(a1));
	printf("&a1 = %p.\n", &a1);
	printf("a1.b = %d.\n", a1.b);
}


int main(void)
{	
	struct A a = 
	{
		.a = 4,
		.b = 5555,
	};
	printf("sizeof(a) = %d.\n", sizeof(a));    //sizeof(a) = 8.
	printf("&a = %p.\n", &a);                //&a = 0x7ffc93bee420.
	printf("a.b = %d.\n", a.b);             //a.b = 5555.
	func4(a);                            //sizeof(a1) = 8.
                                         //&a1 = 0x7ffc93bee400.
                                           //a1.b = 5555.
	
	return 0;
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

结构体指针传参：

struct A
{
	char a;				// 结构体变量对齐问题
	int b;				
};

void func5(struct A *a1)
{
	printf("sizeof(a1) = %d.\n", sizeof(a1));		  
	printf("sizeof(*a1) = %d.\n", sizeof(*a1));		
	printf("&a1 = %p.\n", &a1);			           
	printf("a1 = %p.\n", a1);
	printf("a1->b = %d.\n", a1->b);
}


int main(void)
{	
	struct A a = 
	{
		.a = 4,
		.b = 5555,
	};
	printf("sizeof(a) = %d.\n", sizeof(a));		//sizeof(a) = 8.
	printf("&a = %p.\n", &a);                 //&a = 0x7fffdde01030.
	printf("a.b = %d.\n", a.b);               //a.b = 5555.
	func5(&a);                            // sizeof(a1) = 8.   sizeof(*a1) = 8.
	                                       //&a1 = 0x7fffdde01018.
										    //a1 = 0x7fffdde01030.    a1->b = 5555.
	return 0;                       
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

5、传值调用与传址调用

传值调用描述的是这样一种现象：x和y作为实参，自己并没有真身进入swap1函数内部，而只是拷贝了一份自己的副本（副本具有和自己一样的值，但是是不同的变量）进入子函数swap1，然后我们在子函数swap1中交换的实际是副本而不是x、y真身。所以在swap1内部确实是交换了，但是到外部的x和y根本没有受影响。
在swap2中x和y真的被改变了（但是x和y真身还是没有进入swap2函数内，而是swap2函数内部跑出来把外面的x和y真身改了）。实际上实参x和y永远无法真身进入子函数内部（进去的只能是一份拷贝），但是在swap2我们把x和y的地址传进去给子函数了，于是乎在子函数内可以通过指针解引用方式从函数内部访问到外部的x和y真身，从而改变x和y。
结论：这个世界上根本没有传值和传址这两种方式，C语言本身函数调用时一直是传值的，只不过传的值可以是变量名，也可以是变量的指针。

void swap1(int a, int b)
{
	int tmp;
	tmp = a;
	a = b;
	b = tmp;
	printf("in swap1, a = %d, b = %d.\n", a, b);
}

void swap2(int *a, int *b)
{
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
	printf("in swap1, *a = %d, *b = %d.\n", *a, *b);
}

int main(void)
{
	int x = 3, y = 5;
	swap2(&x, &y);
	printf("x = %d, y = %d.\n", x, y);		// 交换成功
	

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

	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

九，输入型参数与输出型参数

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

函数名是一个符号，表示整个函数代码段的首地址，实质是一个指针常量，所以在程序中使用到函数名时都是当地址用的，用来调用这个函数的。
函数体是函数的关键，由一对{}括起来，包含很多句代码，函数体就是函数实际做的工作。
形参列表和返回值。形参是函数的输入部分，返回值是函数的输出部分。对函数最好的理解就是把函数看成是一个加工机器（程序其实就是数据加工器），形参列表就是这个机器的原材料输入端；而返回值就是机器的成品输出端。
其实如果没有形参列表和返回值，函数也能对数据进行加工，用全局变量即可。用全局变量来传参和用函数参数列表返回值来传参各有特点，在实践中都有使用。总的来说，函数参数传参用的比较多，因为这样可以实现模块化编程，而C语言中也是尽量减少使用全局变量。
全局变量传参最大的好处就是省略了函数传参的开销，所以效率要高一些；但是实战中用的最多的还是传参，如果参数很多传参开销非常大，通常的做法是把很多参数打包成一个结构体，然后传结构体变量指针进去。

int x;		// 被乘5的变量，也就是输入函数的变量
int y;		// 输出结果的变量

void multip5_2(void)
{
	y = 5 * x;
}

int multip5(int a)
{
	return a*5;
}

int main(void)
{
	// 程序要完成功能是：对一个数乘以5
	// 第一种方法：函数传参
	int a = 3;
	int b;
	b = multip5(a);
	printf("result = %d.\n", b);         //result =15
	
	// 第二种方法：用全局变量来传参
	x = 2;
	multip5_2();
	printf("y = %d.\n", y);               //y =10
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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

const一般用在函数参数列表中，用法是const int *p;（意义是指针变量p本身可变的，而p所指向的变量是不可变的）。
const用来修饰指针做函数传参，作用就在于声明在函数内部不会改变这个指针所指向的内容，所以给该函数传一个不可改变的指针（char *p = “linux”;这种）不会触发错误；而一个未声明为const的指针的函数，你给他传一个不可更改的指针的时候就要小心了。

void func1(int *p)
{
	*p = 5;
}

void func2(const int *p)
{
	*p = 5;
}


int main(void)
{
	int a = 1;
	func1(&a);          //ok         
	func2(&a);       //报错，func2中，指针指向的内容是const的不能被改变

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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

一般来说，函数的收入部分就是函数参数，输出部分就是返回值。问题是函数的参数可以有很多个，而返回值只能有1个。这就造成我们无法让一个函数返回多个值。
现实编程中，一个函数需要返回多个值是非常普遍的，因此完全依赖于返回值是不靠谱的，通常的做法是用参数来做返回（在典型的linux风格函数中，返回值是不用来返回结果的，而是用来返回0或者负数用来表示程序执行结果是对还是错，是成功还是失败）。
普遍做法，编程中函数的输入和输出都是靠函数参数的，返回值只是用来表示函数执行的结果是对（成功）还是错（失败）。如果这个参数是用来做输入的，就叫输入型参数；如果这个参数的目的是用来做输出的，就叫输出型参数。
输出型参数就是用来让函数内部把数据输出到函数外部的。

int multip5_3(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 = 30;
	ret = multip5_3(a, &b);
	if (ret == -1)
	{
		printf("出错了\n");
	}
	else
	{
		printf("result = %d.\n", b);
	}
	
	return 0;
}	
	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34