逐步理解C语言指针

1.指针—内存和地址

??计算上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存是8GB/16GB/32GB等，那这些内存空间如何高效的管理呢？
??其实也是把内存划分为一个个的内存单元，每个内存单元的大小是1个字节。每个字节是8个比特位，一个比特位可以存储?个二进制的位0或1。好比做一个学生宿舍，每个宿舍住八个人。

? bit - 比特特位
? byte - 字节
1byte = 8bit
1KB = 1024byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB

??每个内存单元也都有?个编号（这个编号就相当于宿舍房间的门牌号），有了这个内存单元的编
号，CPU就可以快速找到?个内存空间。在计算机中我们把内存单元的编号也称为地址。C语言中给地址起了新的名字叫：指针。
??内存单元的编号 == 地址 == 指针

??因为内存中字节很多，所以需要给内存进行编址(就如同宿舍很多，需要给宿舍编号?样)。

??计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。

??我们可以简单理解，32位机器有32根地址总线，每根线只有两态，表示1,0【电脉冲有无】那么?根线就能表示2种含义，2根线就能表示4种含义，依次类推。32根地址线，就能表示2^32种含义，每?种含义都代表?个地址。地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传入CPU内寄存器。

2.指针变量和地址

2.1 取地址操作符（&）

??在C语言中创建变量其实就是向内存申请空间，下图就是创建了整型变量a，内存中申请4个字节，用于存放整数7，每个字节都有地址，图中4个字节的地址（以16进制进行显示的）分别是：

0x005EF6EC
0x005EF6ED
0x005EF6EE
0x005EF6EF

??&a取出的是a所占4个字节中地址较小的字节的地址，会打印：0x005EF6EC。
注意：每次运行所开辟的内存空间会不一样，所以每次运行打印的地址也会不一样。

#include <stdio.h>
int main()
{
    int a = 10;
    &a;    //取出a的地址
    printf("%p\n", &a);
    return 0;
}

因为整型变量占用4个连续的字节空间，虽然只打印第一个字节地址，但是顺藤摸瓜就可以访问到剩下的3个字节的数据了.

2.2 指针变量和指针类型

（1）指针变量

??我们通过取地址操作符(&)拿到的地址是?个数值，比如：0x005EF6EC，这个数值有时候也是需要存储起来，方便后期再使用的，那我们把这样的地址值存放在哪里呢？答案是：指针变量 中。

#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	//取出a的地址并存储到指针变量pa中
	return 0;
}

??上述中pa就是指针变量。指针变量也是?种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为地址。

（2）指针类型
??这里pa左边写的是 int* ， * 是在说明pa是指针变量，而前面的 int 是在说明pa指向的是整型(int)
类型的对象。

结论：
pa 和 *pa 两者是不一样的

1.pa里边存放的是地址（a的地址）；
2.pa是变量，有自己的地址；
3.*pa代表pa指向的空间（可以理解为 *pa等同于a）；

与此类似，还有字符型指针：

char ch = ‘w’;
char *pc = &ch;

短整型指针：

short s = 10;
short *ps = &s;

浮点型指针：

float f = 10.0;
float *pf = &f;

等等等等，还有许多类似的指针类型就不细分了。

（3）指针变量的大小
??32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后是1或者0，那我们把32根地址线产生的2进制序列当做一个地址，那么一个地址就是32个bit位，需要4个字节才能存储。
??如果指针变量是用来存放地址的，那么指针变的大小就得是4个字节的空间才可以。
??同理64位机器，假设有64根地址线，一个地址就是64个二进制位组成的二进制序列，存储起来就需要8个字节的空间，指针变的大小就是8个字节。

#include <stdio.h>
int main()
{
	printf("%zd\n", sizeof(char*));
	printf("%zd\n", sizeof(short*));
	printf("%zd\n", sizeof(int*));
	printf("%zd\n", sizeof(double*));
	return 0;
}

32位平台下地址是32个bit位，指针变量大小是4个字节；
64位平台下地址是64个bit位，指针变量大小是8个字节；
注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。

2.3 解引用操作符（ * ）

??我们将地址保存起来，未来是要使用的，那怎么使用呢？

#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	*pa = 7;
	printf("%d\n", a);
	return 0;
}

??使用解引用操作符（ * ）， * pa 的意思就是通过pa中存放的地址找到指向的空间，* pa等同于a变量，所以*pa = 7，这个操作符就是找到a的地址把a改成了7。
?? 取地址操作符（&）相当于封装打包取出来；
?? 解引用操作符（ * ）相当于拆开包装可以修改里面的内容；
?? 这两者操作符是互相抵消的。

#include <stdio.h>
int main()
{
	int a = 10;
	printf("%d\n", *(&a));
	return 0;
}

*(&a)就是先取出a的地址，然后解引用（找到这个地址的空间然后访问，但是并没有修改这个空间的数值），两者抵消了，相当于没变。打印屏幕上的信息还是a等于10。

3. 指针变量类型的意义

??指针变量的大小和类型无关，只要是指针变量，在同一个平台下，大小都是一样的，为什么还要有各种各样的指针类型呢？别急，存在即合理，其实指针类型是有特殊意义的；

3.1 指针的解引用和 + - 整数

（1）指针的解引用

??对比，下面2段代码，主要在调试时观察内存的变化：

//代码1
#include <stdio.h>
int main()
{
	int n = 0x11223344;
	int* pi = &n;
	*pi = 0;
	return 0;
}

// 代码2
#include <stdio.h>
int main()
{
	int n = 0x11223344;
	char* pc = (char*)&n;
	*pc = 0;
	return 0;
}

调试后我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将n的第一个字节改为0。
char* 的指针解引用一次性只能访问一个字节，而 int* 的指针的解引用一次性访问四个字节。
结论：指针的类型决定了，对指针解引用的时候有多大的权限（?次能操作几个字节）。

（2）指针 + - 整数
先看一段代码，调试观察地址的变化。

#include <stdio.h>
int main()
{
	int n = 10;
	char* pc = (char*)&n;
	int* pi = &n;

	printf("&n   = %p\n\n", &n);
	printf("pc   = %p\n", pc);
	printf("pc+1 = %p\n", pc + 1);
	printf("pi   = %p\n", pi);
	printf("pi+1 = %p\n", pi + 1);
	return 0;
}

我们可以看出， char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。
结论：指针的类型决定了指针向前或者向后走一步有多大（距离）。

3.2 void* 指针

??在指针类型中有一种特殊的类型是 void* 类型的，可以理解为无具体类型的指针（或者叫泛型指针），这种类型的指针可以用来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进行指针的+ -整数和解引用的运算。
??例如：

#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a; char* pc = &a;
	return 0;
}

??在上面的代码中，将?个int类型的变量的地址赋值给?个char* 类型的指针变量。编译器给出了?个警
告（如下图），是因为类型不兼容。如果换成void* 类型就不会有这样的问题了。请看以下代码：

#include <stdio.h>
int main()
{
	int a = 10;
	char ch = 'w';
	
	void* pa = &a;
	void* pc = &ch;
	
	return 0;
}

??虽然 void* 类型的指针可以接收不同类型的地址，但是无法直接进行指针运算。
??例如以下代码进行解引用时就会报错：

#include <stdio.h>
int main()
{
	int a = 10;
	void* pa = &a;
	void* pc = &a;
	*pa = 10;
	*pc = 0;
	return 0;
}

结论：一般 void* 类型的指针是使用在函数参数的部分，我们可以把void* 类型的指针当做一个垃圾桶用来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。使得一个函数来处理多种类型的数据。

4. 指针运算

（1）指针 + - 整数

?? 因为数组在内存中是连续存放的，只要知道第?个元素的地址，顺藤摸?就能找到后?的所有元素。

#include <stdio.h>
//使用指针打印数组内容
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));  //p+i 加的是i*sizeof(int)
		//p+i 这?就是指针+整数
	}
	return 0;
}

?? p指向数组首元素地址，假设p=0x0012ff80（首元素地址）, p+0=0x0012ff80（下标为0的元素地址）, p+1=0x0012ff84（下标为1的元素地址）, p+2=0x0012ff88（下标为2的元素地址）, 就这样一直循环访问下去，就能得到数组了。因为这是整型数组，每个元素占4个字节，所以用整型指针+1，就是是一次性跳过四个字节，整型数组必须用整型指针访问才不会报错。

（2）指针 - 指针（地址 - 地址）

?? 来看下面的代码：
??代码1：

#include <stdio.h>

int main() 
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	printf("%d\n", &arr[9] - &arr[0]);

	return 0;
}

?? 指针 - 指针的绝对值是指针和指针之间的元素个数。前提条件：两个指针指向同一块空间。

??代码2：
模拟库函数strlen

//指针-指针
#include <stdio.h>
int my_strlen(char* s)
{
	char* start = s;
	while (*s != '\0')
	{
		s++;
	}	
	return s - start;
}
int main()
{
	printf("%d\n", my_strlen("abc"));
	return 0;
}

?? 自定义函数 my_strlen()，字符串“abc”传参，其实是传的字符串首字母地址（a的地址），形参部分用一个字符指针 char* s 接收，char* 就指向了字符串首字母的地址，然后把这个地址赋值给另一个字符指针char * start存放，然后进入循环，s++，当 *s 等于 ‘\0’ 时停止，所以 s - start 就是末尾的地址 - 起始地址，之间的元素个数就是字符串的长度。

（3）指针的关系运算—指针比较大小（地址比较大小）

//指针的关系运算
#include <stdio.h>
//使用while循环打印数组
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = &arr[0];
	//arr是数组名，数组名就是首元素地址，arr等价于&arr[0]
	while (p < arr + sz)
		//指针的大小比较
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

5. 野指针

概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

（1） 野指针成因

1. 指针未初始化

#include <stdio.h>
int main()
{
	int* p;
	//局部变量指针未初始化，默认为随机值
	*p = 20;
	return 0;
}

2. 指针越界访问

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int* p = &arr[0];
	int i = 0;
	for (i = 0; i <= 11; i++)
	{
		//当指针指向的范围超出数组arr的范围时，p就是野指针
		*(p++) = i;
	}
	return 0;
}

3. 指针指向的空间释放

#include <stdio.h>
int* test()
{
	int n = 100;
	return &n;
}
int main()
{
	int* p = test();
	printf("%d\n", *p);
	return 0;
}

（2）如何规避野指针

1 指针初始化

?? 如果明确知道指针指向哪里就直接赋值地址，如果不知道指针应该指向哪里，可以给指针赋值NULL。
?? NULL 是C语言中定义的一个标识符常量，值是0，0也是地址，这个地址是无法使用的，读写该地址会报错。

#include <stdio.h>
int main()
{
	int num = 10;
	int* p1 = &num;
	int* p2 = NULL;
	return 0;
}

2. 小心指针越界
   ?? 一个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。

3. 避免返回局部变量的地址

4. 指针变量不再使用时，及时置NULL，指针使用之前检查有效性

6. assert断言和const修饰指针

（1） assert断言
?? assert.h 头文件定义了宏 assert() ，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。

?assert (p != NULL);

?? 上面代码在程序运行到这一行语句时，验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序继续运行，否则就会终止运行，并且给出报错信息提示。

?? 如果已经确认程序没有问题，不需要再做断言，就在 #include <assert.h> 语句的前面，定义?个宏 NDEBUG 。

?#define NDEBUG
?#include <assert.h>

??然后，重新编译程序，编译器就会禁用文件中所有的 assert() 语句。如果程序又出现问题，可以移除这条 #define NDBUG 指令（或者把它注释掉），再次编译，这样就重新启用了 assert() 语句。

（2）const修饰指针

??1. const修饰变量

??变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量的也可以修改这个变量。
??但是如果我们希望一个变量加上一些限制，不能被修改，怎么做呢？这就是const的作用。

#include <stdio.h>
int main()
{
	int m = 0;
	m = 20;
	//m是可以修改的
	const int n = 0;
	n = 20;
	//n是不能被修改的
	return 0;
}

??上述代码中n是不能被修改的，但是n本质还是变量，只不过被const修饰后，在语法上加了限制，假如我们在代码中对n进行修改，就不符合语法规则，就报错，致使没法直接修改n。

??但是如果我们绕过n，使用n的地址，去修改n就能做到了，虽然这样做是在打破语法规则。

#include <stdio.h>
int main()
{
	const int n = 0;
	printf("n = %d\n", n);
	
	int* p = &n;
	*p = 20;
	printf("n = %d\n", n);
	return 0;
}

??结果显示n确实被修改了，但是n被const修饰就是为了不能被修改，如果p拿到n的地址就可以修改n，这样就打破了const的限制，这是不合理的，所以应该让p拿到n的地址也不能修改n，那接下来怎么做呢？

??2. const修饰指针变量

??我们来看以下代码：
??代码1：

#include <stdio.h>
void main()
{
	const int a = 10;
	int * const p = &a;
	*p = 0;
	printf("a = %d\n", a);
}

??把const放在 * 右边，结果这里a依旧被修改了。因为这里限制的是p，p也是变量，也有自己的地址，*p代表p指向的空间（可以理解为 *p等同于a），只是限制了p变量，也就是p变量没办法再指向其他变量了（无法存放其他变量的地址了），但是没有限制 *p，还是可以通过指针p来修改p所指向的空间的内容，所以 *p仍然可以修改a。??*p = 0;//ok??p = &b;//err

??代码2：

#include <stdio.h>
void main()
{
	const int a = 10;
	int const *  p = &a;
	*p = 0;
	printf("a = %d\n", a);
}

??把const放在 * 左边，结果显示报错了。因为这里限制的是 *p，*p代表p指向的空间（可以理解为 *p等同于a），意思就是不能通过指针p来修改p所指向的空间的内容。但是不会限制p变量，p变量仍然可以存放其他变量的地址。??*p = 0;//err??p = &b;//ok

??代码3：

#include <stdio.h>
void main()
{
	const int a = 10;
	const int b = 20;
	const int * const p = &a;
	*p = 0;
	p = &b;
	printf("a = %d\n", a);
}

?? * 的左右两边都有const，结果显示两者都报错了，所以既限制了 *p 又限制了 p。

结论：const修饰指针变量的时候

??const如果放在 * 的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本?的内容可变。
??const如果放在 * 的右边，修饰的是指针变量本?，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。

7.数组名的理解

??数组名就是数组首元素(第?个元素)的地址，但是有两个例外：
?? sizeof(数组名)：sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
??&数组名：这里的数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组首
元素的地址是有区别的）。
??除此之外，任何地方使用数组名，数组名都表示首元素的地址。

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("&arr[0]   = %p\n", &arr[0]);
	printf("&arr[0]+1 = %p\n", &arr[0] + 1);
	printf("arr       = %p\n", arr);
	printf("arr+1     = %p\n", arr + 1);
	printf("&arr      = %p\n", &arr);
	printf("&arr+1    = %p\n", &arr + 1);
	return 0;
}

??这里我们发现 &arr[0] 和 &arr[0]+1 相差4个字节，arr 和 arr+1 相差4个字节，是因为 &arr[0] 和 arr 都是首元素的地址，+1就是跳过?个元素。
??但是 &arr 和 &arr+1 相差40个字节，这就是因为 &arr 是数组的地址，+1操作是跳过整个数组的。

8.使用指针访问数组

代码1：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	//输?
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//输?
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		scanf("%d", p + i);
		//scanf("%d", arr+i);//也可以这样写
	}
	//输出
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

??这个代码搞明白后，我们再分析一下，数组名arr是数组首元素的地址，可以赋值给p，其实数组名arr和p在这里是等价的。那我们可以使用arr[i]可以访问数组的元素，那p[i]是否也可以访问数组呢？代码2：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	//输?
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//输?
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		scanf("%d", p + i);
		//scanf("%d", arr+i);//也可以这样写
	}
	//输出
	for (i = 0; i < sz; i++)
	{
		printf("%d ", p[i]);
	}
	return 0;
}

??将 *(p+i) 换成 p[i] 也是能够正常打印的，所以本质上 p[i] 是等价于 *(p+i)的。
??同理 arr[i] 应该等价于 *(arr+i)，数组元素的访问在编译器处理的时候，也是转换成首元素的地址+偏移量求出元素的地址，然后解引用来访问的。

??在数组传参的时候，传递的是数组名，也就是说本质上数组传参本质上传递的是数组首元素的地址。
??所以：一维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

??二维数组的传参本质是传递的第一行这个一维数组的地址，那么形参也是可以写成指针形式。

9.?级指针

??指针变量也是变量，是变量就有地址，指针变量的地址就存放在二级指针中。

??ppa也是变量，ppa也有自己的地址，int** *pppa = &ppa; 三级指针，往后还有四级指针、五级指针等等，其实事实上我们三级指针用的都很少，往后的都不常用了。

#include <stdio.h>
int main()
{
	int a = 10;
	int * pa = &a;
	int** ppa = &pa;
	printf("%d\n", **ppa);

	return 0;
}

??**ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a 。

10.指针数组 和 数组指针

（1）指针数组

??整型数组，是存放整型的数组，字符数组是存放字符的数组。
??指针数组的每个元素都是用来存放地址（指针）的。

??指针数组模拟二维数组：

#include <stdio.h>
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	//数组名是数组?元素的地址，类型是int*的，就可以存放在parr数组中
	int* parr[3] = { arr1, arr2, arr3 };
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", parr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

??parr[i]是访问parr数组的元素，parr[i]找到的数组元素指向了整型一维数组，parr[i][j]就是整型一维数组中的元素。
??上述的代码模拟出二维数组的效果，实际上并非完全是二维数组，因为每一行并非是连续的。


（2）数组指针变量

??整形指针变量：int * p 存放的是整型变量的地址，能够指向整形数据的指针。
??数组指针变量是：存放的是数组的地址，能够指向数组的指针变量。

?int *p1[10];?//指针数组
?int (*p2)[10];?//数组指针变量

??p2先和*结合，说明p2是?个指针变量变量，然后指着指向的是?个大小为10个整型的数组。所以
p2是?个指针，指向?个数组，叫 数组指针。
??注意：[ ]的优先级要高于 * 的，所以必须加上（）来保证p2先和 * 结合。

??数组指针变量的初始化

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int(*p)[10] = &arr;
    // 去掉p就是数组指针的类型
	return 0;
}

11.函数指针

??函数也是有地址的，函数名就是函数的地址，当然也可以通过 &函数名 的方式获得函数的地址。
??要将函数的地址存放起来，就得创建函数指针变量，函数指针的写法其实和数组指针非常类似。如下：

#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int(*pf)(int, int) = Add;  //x和y写上或者省略都是可以的
    //去掉pf就是函数指针的类型
    
	printf("%d\n", (*pf)(2, 3));
	printf("%d\n", pf(3, 5));
	return 0;
}

??把一个函数的地址放到函数指针里的时候，再通过函数指针调用所对应的函数时，解引用操作符 * 是可以省略的，写上 * 更容易理解这是函数指针。

12.typedef关键字

??typedef 是用来类型重命名的，可以将复杂的类型，简单化。
??比如，你觉得 unsigned int 写起来方便，如果能写成 uint 就方便多了，那么我们可以使用：

?typedef unsigned int uint;?//将unsigned int 重命名为uint

??但是对于数组指针和函数指针稍微有点区别：
??比如我们有数组指针类型 int(*)[5] ,需要重命名为 parr_t ，那可以这样写：

?typedef int( * parr_t )[5];?//新的类型名必须在 * 的右边

?函数指针类型的重命名也是一样的，比如，将 void(*)(int) 类型重命名为 pf_t ,就可以这样写：

?typedef void( * pf_t )(int);?//新的类型名必须在 * 的右边

区别：
??typedef void( * pf_t )(int); ?pf_t 是函数指针类型的重命名
?? void( * pf )(int);??pf是函数指针变量的名字

13.函数指针数组 和 转移表

??要把函数的地址存到一个数组中，那这个数组就叫函数指针数组。

?int (*parr1[3])( );

??parr1 先和 [ ] 结合，说明 parr1 是数组，数组的内容是 int (*)() 类型的函数指针。

??函数指针数组的用途：转移表：
??举例：计算器的?般实现：

#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = div(x, y);
			printf("ret = %d\n", ret);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

??使用函数指针数组的实现：

#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	int(*p[5])(int x, int y) = { 0, add, sub, mul, div };
	//转移表
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		if ((input <= 4 && input >= 1))
		{
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
			printf("ret = %d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出计算器\n");
		}
		else
		{
			printf("输入有误\n");
		}
	} while (input);
	return 0;
}

14.回调函数

??回调函数就是?个通过函数指针调?的函数。
??如果你把函数的指针（地址）作为参数传递给另?个函数，当这个指针被用来调用其所指向的函数时，被调用的函数就是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

#include <stdio.h>
int add(int a, int b)
{
??return a + b;
}
int sub(int a, int b)
{
??return a - b;
}
int mul(int a, int b)
{
??return a * b;
}
int div(int a, int b)
{
??return a / b;
}

void calc(int( * pf )(int, int))
{
??int ret = 0;
??int x, y;
??printf(“输?操作数：”);
??scanf(“%d %d”, &x, &y);
??ret = pf(x, y);
??printf(“ret = %d\n”, ret);
}

int main()
{
??int input = 1;
??do
??{
????printf(" ************************* \n");
????printf(" ?1:add ??2:sub? \n");
????printf(" ?3:mul?? 4:div ?\n");
????printf(" ?0:exit ?\n");
????printf(" ************************* \n");
????printf(“请选择：”);
????scanf(“%d”, &input);
????switch (input)
????{
????case 1:
??????calc(add);
??????break;
????case 2:
??????calc(sub);
??????break;
????case 3:
??????calc(mul);
??????break;
????case 4:
??????calc(div);
??????break;
????case 0:
??????printf(“退出程序\n”);
??????break;
????default:
??????printf(“选择错误\n”);
??????break;
????}
??} while (input);
??return 0;
}