• 【c】指针

    哈喽大家好，大家好，欢迎收看本期博客 ! 

    我是Mr.tan

    今儿个，给大家分享c语言中的指针的相关内容，希望对大家学习c语言能有所帮助。

    目录

    哈喽大家好，大家好，欢迎收看本期博客 ! 

    我是Mr.tan

    一、指针、指针变量与指针类型

    1.1、指针

    1.2、指针变量

    1.3、一个小的单元（1个字节）到底是多大

     1.4、指针类型

    二、野指针

    2.1、野指针成因

    2.1.1、指针未初始化

    2.1.2、指针越界访问

    2.1.3、指针指向的空间释放

    2.2、如何规避野指针

    2.2.1、 指针初始化

    2.2.2. 小心指针越界

    2.2.3. 指针指向空间释放，及时置NULL

    2.2.4. 避免返回局部变量（栈）的地址

    2.2.5. 指针使用之前检查有效性

    三、指针的运算

    3.1、指针 + 或 -  整数

    3.2、指针 - 指针

    3.3、指针的关系运算

    四、指针和数组

    五、二级指针

    六、指针数组

    七、字符指针

     八、数组指针

    8.1、数组指针的定义

    8.2、&数组名和数组名

    8.3、数组指针的使用

    8.4、火眼金睛

    九、数组传参与指针传参

    9.1、一维数组传参

    9.2、二维数组传参

    9.3、一级数组传参

    9.4、二级数组传参

    十、函数指针

    十一、函数指针数组

    十二、指向函数指针数组的指针

    十三、回调函数

    13.1、qsort函数

    一、指针、指针变量与指针类型

    1.1、指针

    c语言指针其实是一个整形变量,与其它数据不同的是,它的作用是用来存储其它变量的地址。指针是编程语言中的一个对象，利用地址，它的值直接指向存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针"。意思是通过它能找到以它为地址的内存单元，指针是内存中一个最小的单元的编号。指针的大小是固定的4/8个字节(32位平台/64位平台)。

    1.2、指针变量

    可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量。

    1. int main()
    2. {
    3. 	int a = 25;//在内存中开辟一块空间
    4. 	int* pa = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
    5. 	   //a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在pa变量中，pa就是一个之指针变量。
    6. 	printf("%p\n", &a);//打印地址
    7. 	char ch = 'w';//在内存中开辟一块空间
    8. 	char* pc = &ch;//这里我们对变量ch，取出它的地址，也可以使用&操作符。
    9. 	//ch变量占用1个字节的空间，这里是将ch的第一个字节的地址存放在pc变量中，pc就是一个之指针变量。
    10. 	printf("%p\n", &ch);//打印地址
    11. 	return 0;
    12. }

    从我们监视所得的图中可知，pa作为指针变量，它里面存放的是a的地址，而它也有自己的地址。

    1. int main()
    2. {
    3. 	int a = 25;
    4. 	int* pa = &a;
    5. 	return 0;
    6. }

    1.3、一个小的单元（1个字节）到底是多大

    （1）、在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。

    （2）、在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

     1.4、指针类型

    char     * pa = NULL
    int        * pb = NULL
    short    * pc = NULL 
    long     * pd = NULL
    float     * pe = NULL
    double * pf = NULL

    当我们看到以下两段代码以及相应的截图的时候，我们会发现，同样都是把a的地址存放在指针变量当中，但是对于 int* 的指针解引用访问4个字节，而对于 char* 的指针解引用只访问1个字节，从而得出指针类型是有意义的。

    意义1：指针类型决定了进行解引用操作的时候权限有多大；

    1. int main()
    2. {
    3. 	int a = 0x11223344;
    4. 	int* pa = &a;
    5. 	*pa=0;//重点在调试的过程中观察内存的变化
    6. 	return 0;
    7. }

    1. int main()
    2. {
    3. 	int a = 0x11223344;
    4. 	char* pc = &a;
    5. 	*pc = 0;//重点在调试的过程中观察内存的变化
    6. 	return 0;
    7. }

     可以从下面的代码和截图中得出第二个意义：

    意义2：指针类型决定了指针的步长（向前/向后 走一步走多大距离）；

    1. int main()
    2. {
    3. 	int a = 0x11223344;
    4. 	int* pa = &a;
    5. 	char* pc = &a;
    6.  
    7. 	printf("pa=%p\n", pa);
    8. 	printf("pc=%p\n", pc);
    9.  
    10. 	printf("pa+1=%p\n", pa + 1);//int* 指针+1，意思是跳过一个整型，也就是向后走4个字节
    11. 	printf("pc+1=%p\n", pc + 1);//char* 指针+1，意思是跳过一个字符，也就是向后走1个字节
    12.  
    13. 	return 0;
    14. }

     小试牛刀：编写代码用指针的方法将数组初始化为1 ~ 10

    1. int main()
    2. {
    3. 	int arr[10] = { 0 };
    4. 	int* pa = arr;
    5. 	int i = 0;
    6. 	for (i = 0; i < 10; i++)
    7. 	{
    8. 		*(pa + i) = i + 1;
    9. 		printf("%d ", *(pa + i));
    10. 	}
    11. 	return 0;
    12. }

    二、野指针

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

    2.1、野指针成因

    2.1.1、指针未初始化

    1. int main()
    2. {
    3. 	int* p;//p就是野指针
    4. 	*p = 10;
    5.     return 0；
    6. }

    2.1.2、指针越界访问

    1. int main()
    2. {
    3. 	int arr[5] = { 0 };
    4. 	int* p = arr;
    5. 	int i = 0;
    6. 	for (i = 0; i <= 6; i++)
    7. 	{
    8. 		//当指针指向的范围超出数组arr的范围时，p就是野指针
    9. 		*(p++) = i;
    10. 	}
    11. 	return 0;
    12. }

    2.1.3、指针指向的空间释放

    当进入text函数的时候创建变量num，向内存申请一段空间，而出去之后就被释放，就把这段空间还给操作系统。回到主函数的时候记住了这段地址，则 p 就是野指针。

    1. #include 
    2. int* text()
    3. {
    4. 	int num = 100;
    5. 	return #
    6. }
    7. int main()
    8. {
    9. 	int* p = text();
    10. 	*p = 200;
    11. 	return 0;
    12. }

    2.2、如何规避野指针

    2.2.1、 指针初始化 

    1. int main()
    2. {
    3. 	int a = 10;
    4. 	int* pa = &a;//明确初始化
    5.  
    6. 	//NULL  -  0  ，这也是初始化指针的
    7. 	int* p = NULL;
    8. 	return 0;
    9. }

    2.2.2. 小心指针越界

    2.2.3. 指针指向空间释放，及时置NULL

    2.2.4. 避免返回局部变量（栈）的地址

    2.2.5. 指针使用之前检查有效性

    1. int main()
    2. {
    3.     int *p = NULL;
    4.     int a = 10;
    5.     p = &a;
    6.     if(p != NULL)
    7.    {
    8.         *p = 20;
    9.    }
    10.     return 0; 
    11. }

    三、指针的运算

    3.1、指针 + 或 -  整数

    1. int main()
    2. {
    3. 	float arr[4] = { 0 };
    4. 	float* pa = arr;
    5. 	int i = 0;
    6. 	for (i = 0; i < 4; i++)
    7. 	{
    8. 		*(pa + i) = i + 1;
    9. 		printf("%lf ", *(pa + i));
    10. 	}
    11. 	return 0;
    12. }

    3.2、指针 - 指针

    指针与指针相减的前提是，指针指向的是同一块连续的空间。指针与指针相减求的是相差的元素个数。 

    1. int main()
    2. {
    3.      int arr[5]={0,1,2,3,4};
    4.      printf("%d\n", arr[4] - arr[0]);
    5.      return 0;
    6. }

    小试牛刀：用指针-指针的方法求字符串的长度：

    1. int my_strlen(char* str)
    2. {
    3.     char* start = str;
    4.     while (*str != '\0')
    5.         str++;
    6.     return str - start; 
    7. }
    8.  
    9. int main()
    10. {
    11.     char arr[] = "abcdefg";
    12.     int len = my_strlen(arr);
    13.     printf("%d\n", len);
    14.     return 0;
    15. }

    3.3、指针的关系运算

    1. //将数组中的每一个元素都置为0
    2. int main()
    3. {
    4.      int values[5]={1,2,3,4,5};
    5.      int* vp;
    6.      for (vp = &values[5]; vp > &values[0];)
    7.      {
    8. 	     *--vp = 0;
    9.          printf("%d ", *vp);
    10.      }
    11.      return 0;
    12. }
    对于下方的代码，实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。
    标准规定：允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与 指向第一个元素之前的那个内存位置的指针进行比较。 
    1. for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--) 
    2. {
    3.     *vp = 0; 
    4. }

    四、指针和数组

    数组和指针不是一个东西，数组能够存放一组数，是一段连续的空间，数组的大小取决于元素的个数；而指针是一个变量，是存放地址的。它们之间的联系是：数组名是地址，数组把首元素的地址交给一个指针变量后，可以通过指针来访问数组。

    1. //用指针数组的方式打印数组中的内容
    2. int main()
    3. {
    4. 	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    5. 	int* p = arr; 
    6. 	int i = 0;
    7. 	int sz = sizeof(arr) / sizeof(arr[0]);
    8. 	for (i = 0; i < sz; i++)
    9. 	{
    10. 		printf("%d " , *p );
    11. 		p++;
    12. 	}
    13. 	return 0;
    14. }

    五、二级指针

    1. int main()
    2. {
    3. 	int a = 10;
    4. 	int* p = &a;//p是一级指针变量
    5. 	int** pp = &p;//pp是二级指针变量
    6. 	return 0;
    7. }

     对于二级指针的运算有：

    （1）、*pp 通过对pp中的地址进行解引用，这样找到的是 p ， *pp 其实访问的就是 p 。

    1. int a = 20; 
    2. *pp = &a;//等价于 p = &a
    （2）、**pp  先通过 *pp  找到 p  , 然后对 p  进行解引用操作： *p  ，那找到的是 a 
    1. **pp = 30;
    2. //等价于*p = 30;
    3. //等价于a = 30;

    六、指针数组

      存放指针的数组   
    1. int* arr1[5];
    2. //arr1是一个数组，有五个元素，每个元素是一个整型指针
    3. char *arr2[4]; 
    4. //一级字符指针的数组
    5. char **arr3[5];
    6. //二级字符指针的数组
    1. //用法：用一维数组模拟二维数组
    2. #include 
    3. int main()
    4. {
    5. 	int arr1[] = { 1,2,3,4,5 };
    6. 	int arr2[] = { 2,3,4,5,6 };
    7. 	int arr3[] = { 3,4,5,6,7 };
    8. 	int arr4[] = { 4,5,6,7,8 };
    9.  
    10. 	int* arr[4]={arr1, arr2, arr3, arr4};
    11. 	int i = 0;
    12. 	for (i = 0; i < 4; i++)
    13. 	{
    14. 		int j = 0;
    15. 		for (j = 0; j < 5; j++)
    16. 		{
    17. 			printf("%d ",arr[i][j]);
    18. 		}
    19. 		printf("\n");
    20. 	}
    21. 	return 0;
    22. }

    七、字符指针

    在指针的类型中有一种指针类型为字符指针 char* 

    ①：&tm 是取出 tm 的地址，可以把它存在 ps 中，而 ps 变量的类型为 char* 。

    1. char tm = 'w';
    2. char* ps = &tm;//①

    ①：把字符串的首元素（a）的地址存在pa中（提示：这样写在某些编译器下可能会出现报错，假如用const修饰将不会出现报错的情况）；

    ②：这种写法是错误的，会发生报错（如图所示），因为常量字符串不可以修改；

    1. char* pa = "abcdef";//①
    2. *pa = 'w';//②

    ①：const 修饰指针，放在 * 的左边限制的是 *pa，这样就不能改变 pa 中的字符串内容了。

    ②：如果用const修饰指针的时候又想改变字符串中的值是实现不了的，这样一句代码根本编译不过去，是一句无效代码；

    1. const char* pa = "abcdef";//①
    2. *pa = 'w';//②

    ①：如果想改变字符串的内容，必须给他一个可以改变的空间，如语句1所示。

    ②：数组名就是数组的首元素地址；

    1. char arr[] = "abcdef";//①
    2. char* p = arr;//②

    小试牛刀：以下代码段打印的结果是？

    1. #include 
    2. int main()
    3. {
    4. 	char str1[] = "hello bit.";
    5. 	char str2[] = "hello bit.";
    6. 	const char* str3 = "hello bit.";
    7. 	const char* str4 = "hello bit.";
    8. 	if (str1 == str2)
    9. 		printf("str1 and str2 are same\n");
    10. 	else
    11. 		printf("str1 and str2 are not same\n");
    12. 	if (str3 == str4)
    13. 		printf("str3 and str4 are same\n");
    14. 	else
    15. 		printf("str3 and str4 are not same\n");
    16. 	return 0;
    17. }

    代码解析：代码中的str3和str4指向的是一个同一个常量字符串，从内存优化的角度来说，会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同，在这里要注意的是它们比较的不是字符串中的内容，而是比较存储时的地址；如果要比较字符串的内容，要使用strcmp。

     八、数组指针

    8.1、数组指针的定义

    以下代码为整型指针、字符指针以及数组指针之间的类比。

    1. int main()
    2. {
    3. 	//整型指针  -  指向整型的指针  -   存放整型变量的地址
    4. 	int a = 10;
    5. 	int* p1 = &a;
    6. 	//int*  -  整型指针的类型
    7. 	//字符指针  -  指向字符的指针  -  存放字符变量的地址
    8. 	char ch = 'w';
    9. 	char* p2 = &ch;
    10. 	//char*  -  字符指针的类型
    11. 	//数组指针  -  指向数组的指针  -  存放的是数组的地址
    12. 	int arr[5] = { 1,2,3,4,5 };
    13. 	int(*pa)[5] = &arr;//取出的是数组的地址存放在pa中，pa是数组指针变量
    14. 	//int(*)[5]  -  数组指针类型
    15. 	return 0;
    16. }

    下面的代码段是对上述某语句的解释：

    1. int (*pa)[5];
    2. //解释：pa先和*结合，说明pa是一个指针变量，然后指着指向的是一个大小为5个整型的数组。所以pa是一个
    3. 指针，指向一个数组，叫数组指针。
    4. //这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

    8.2、&数组名和数组名

    1. int main()
    2. {
    3. 	int arr[5] = { 0 };
    4. 	printf("%p\n", arr );//int*
    5. 	printf("%p\n", arr+1 );
    6.  
    7. 	printf("%p\n", &arr[0] );//int*
    8. 	printf("%p\n", &arr[0]+1 );
    9.  
    10. 	printf("%p\n", &arr );//int(*)[5]
    11. 	printf("%p\n", &arr+1 );
    12. 	return 0;
    13. }

    根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。 实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。例中 &arr 的类型是： int(*)[5] ，是一种数组指针类型 数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是20。

    8.3、数组指针的使用 

    1. #define _CRT_SECURE_NO_WARNINGS
    2. #include 
    3.  
    4. void print1(int(*p)[5], int r, int c)//二维数组的首元素地址为二维数组的第一行，arr是二维数组的数组名，数组名又是首元素的地址，所以arr是第一行的地址，所以p指向的是二维数组的第一行，它表示第一行的地址
    5. {
    6. 	int i = 0;
    7. 	for (i = 0; i < r; i++)
    8. 	{
    9. 		int j = 0;
    10. 		for (j = 0; j < c; j++)
    11. 		{
    12. 			printf("%d ", * (*(p + i) + j));
    13. 			//p+i相当于第i行的地址，对它解引用后拿到了第i行{ *(p + i)  --->   p[i] 又相当于第i行的数组名，数组名又相当于首元素的地址 }  
    14. 			//+j表示地址偏移，向前或者向后移动，这时候拿到的是地址，解引用后就能拿到该地址上的元素了
    15. 		}
    16. 		printf("\n");
    17. 	}
    18. }
    19.  
    20. void text1()
    21. {
    22. 	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
    23. 	print1(arr, 3, 5);
    24. }
    25.  
    26. int main()
    27. {
    28. 	text1();
    29. 	return 0;
    30. }

    8.4、火眼金睛

    1. int arr[5];
    2. //整型数组
    3.  
    4. int *sarr1[10];
    5. //指针数组
    6.  
    7. int (*sarr2)[10];
    8. //数组指针
    9.  
    10. int (*sarr3[10])[5];
    11. //数组指针类型，saar3是存放【数组指针】的数组

    九、数组传参与指针传参

    9.1、一维数组传参

    数组传参：形式参数可以是数组，也可以是指针。

    1. #include 
    2. void test(int arr[])//---> 形参是数组，可以不写大小
    3. { }
    4. void test(int arr[10])//---> 形参是数组，也可以写大小，但是没什么用处
    5. { }
    6. void test(int *arr)//---> 形参是整型指针，也可以这样写
    7. { }
    8. void test2(int *arr[20])//---> 形参是指针数组，写法正确，可以省略掉20
    9. { }
    10. void test2(int **arr)//---> 形参是二级指针，书写正确
    11. { }
    12.  
    13. int main()
    14. {
    15.  int arr[10] = {0};//整型数组
    16.  int *arr2[20] = {0};//一维整型指针数组（arr2有20个元素，每个元素的类型是int*）
    17.  test(arr);
    18.  test2(arr2);
    19. }

    9.2、二维数组传参

    1. void test(int arr[3][5])//---> 形参为数组
    2. { }
    3. void test(int arr[][])//---> 形参为数组，写法错误，可以省略列，不能省略行
    4. { }
    5. void test(int arr[][5])//---> 形参为数组，列号虚和main函数中的一样
    6. { }
    7. void test(int *arr)//---> 形参为指针，书写错误，类型不匹配
    8. { }
    9. void test(int* arr[5])//---> 书写错误
    10. { }
    11. void test(int (*arr)[5])//---> 书写正确
    12. { }
    13. void test(int **arr)//---> 书写错误，二级指针接收一级指针变量的地址
    14. { }
    15.  
    16. int main()
    17. {
    18.  int arr[3][5] = {0};//二维数组
    19.  test(arr);
    20. }

    9.3、一级数组传参

    1. #include 
    2. //指针传参，指针接收
    3. void print(int *p, int sz) 
    4. {
    5.  int i = 0;
    6.  for(i=0; i
    7.  {
    8.  printf("%d\n", *(p+i));
    9.  }
    10. }
    11.  
    12. int main()
    13. {
    14.  int arr[10] = {1,2,3,4,5,6,7,8,9};
    15.  int *p = arr;
    16.  int sz = sizeof(arr)/sizeof(arr[0]);
    17.  //一级指针p，传给函数
    18.  print(p, sz);
    19.  return 0; 
    20. }

    9.4、二级数组传参

    1. #include 
    2. void test(int** qq) 
    3. {
    4.  printf("num = %d\n", **qq); 
    5. }
    6.  
    7. int main()
    8. {
    9.  int n = 20;
    10.  int*p = &n;//一级指针
    11.  int **pp = &p;//二级指针
    12.  test(pp);
    13.  test(&p);
    14.  return 0;
    15. }
    当函数的参数为二级指针的时候，可以接收什么参数？ 
    1. void test(char **p) 
    2. {
    3.  
    4. }
    5.  
    6. int main()
    7. {
    8.  char c = 'b';
    9.  char*pc = &c;
    10.  char**ppc = &pc;
    11.  char* arr[10];
    12.  test(&pc);
    13.  test(ppc);
    14.  test(arr);
    15.  return 0; 
    16. }

    十、函数指针

    不言而喻，函数指针就是指向函数的指针。

    1. #include 
    2. Add(int x, int y)
    3. {
    4. 	return x + y;
    5. }
    6.  
    7. int main()
    8. {
    9. 	printf("%p\n", Add);
    10. 	printf("%p\n", &Add);
    11. 	return 0;
    12. }

    从代码打印的结果来看，可以知道 Add 和 &Add都是函数的地址，没有去区别。那我们如何用函数指针调用Add函数呢？

    1. #include 
    2. Add(int x, int y)
    3. {
    4. 	return x + y;
    5. }
    6.  
    7. int main()
    8. {
    9. 	int (*pa)(int x, int y) = &Add;
    10. 	int ret = (*pa)(3, 5);//*可以去掉，加在这是为了容易理解
    11. 	printf("%d\n", ret);
    12. 	return 0;
    13. }

    代码分析：

    1. //代码1
    2. (*(void (*)())0)();
    3. //void (*)()---> 函数指针类型
    4. //(void (*)())0---> 把0当作一个函数的地址（强制类型转换）
    5. //(*(void (*)())0)---> 解引用，找到0地址处的函数
    6. //最后面的()---> 调用0地址处的函数，这个函数是没有参数
    7. /*整体来说，它的意思是“把0直接转换成一个void(*)()的函数指针，然后再去调用0地址处
    8. 的函数，解引用的*也可以省略掉”*/

    注意：再日常写代码的过程中，我们不要写这种代码哦，是容易出错误的。

    1. //代码2
    2. void (*signal(int , void(*)(int)))(int);
    3. /*signal(int , void(*)(int))--->signal为函数名，他一共有两个参数，第一个参数类型为为int，
    4. 第二个参数为为函数指针*/
    5. //void ( * ……)(int)--->这部分说明signal的参数返回类型为函数指针
    6. /*总体的意思是：“上述代码是一次函数声明，声明的函数叫做signal，函数的第一个参数是int类型的，
    7. 第二个参数是一个函数指针类型，该函数指针指向的函数的参数是int，返回类型是void，signal函数的
    8. 返回类型也是一个函数指针类型，该函数指针指向的函数的参数是int，返回类型是void。*/
    1. //typedf可以把一个复杂的名字重新定义
    2. void (*signal(int , void(*)(int)))(int);
    3. 上面的代码可以写成下边两句代码：
    4. typedf void(*pf_t)(int);
    5. //typedf void(*)(int)pf_t;这种写法是错误的，但是大家可能都会这么想（pf_t就是个类型）
    6. pf_t signal(int,pf_t);

    十一、函数指针数组

    要把函数的地址存到一个数组中，那这个数组就叫函数指针数组。下面代码段显示的是函数指针数组定义的形式： 
    int (*pfArr1[10])(int，int);

    下面展示一段利用函数指针数组的相关代码，计算器（整数的加减乘除）：

    1. int Add(int x, int y)
    2. {
    3. 	return x + y;
    4. }
    5.  
    6. int Sub(int x, int y)
    7. {
    8. 	return x - y;
    9. }
    10.  
    11. int Mul(int x, int y)
    12. {
    13. 	return x * y;
    14. }
    15.  
    16. int Div(int x, int y)
    17. {
    18. 	return x / y;
    19. }
    20.  
    21.  
    22. void menu()
    23. {
    24. 	printf("***************************\n");
    25. 	printf("***** 1.add    2. sub  ****\n");
    26. 	printf("***** 3.mul    4. div  ****\n");
    27. 	printf("***** 0.exit           ****\n");
    28. 	printf("***************************\n");
    29. }
    30.  
    31. int main()
    32. {
    33. 	int input = 0;
    34. 	int x = 0;
    35. 	int y = 0;
    36. 	int ret = 0;
    37.  
    38. 	int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };
    39.  
    40. 	do
    41. 	{
    42. 		menu();
    43. 		printf("请选择:>");
    44. 		scanf("%d", &input);
    45. 		if (input == 0)
    46. 		{
    47. 			printf("退出计算器\n");
    48. 			break;
    49. 		}
    50.  
    51. 		if (input >= 1 && input <= 4)
    52. 		{
    53. 			printf("请输入2个操作数:>");
    54. 			scanf("%d %d", &x, &y);
    55. 			ret = pfArr[input](x, y);
    56. 			printf("%d\n", ret);
    57. 		}
    58. 		else
    59. 		{
    60. 			printf("选择错误\n");
    61. 		}	
    62. 	} while (input);
    63. }

    十二、指向函数指针数组的指针

    指向函数指针数组的指针是一个 指针；指针指向一个 数组 ，数组的元素都是函数指针。 
    1. void test(int) 
    2. {
    3.  printf("%s\n", str);
    4. }
    5.  
    6. int main()
    7. {
    8.  
    9.  //函数指针pf
    10.  void (*pf)(int) = test;
    11.  
    12.  //函数指针的数组pfArr
    13.  void (*pfArr[5])(int);
    14.  pfArr[0] = test;
    15.  
    16.  //指向函数指针数组pfArr的指针ppfArr
    17.  void (*(*ppfArr)[5])(int) = &pfArr;
    18.  
    19.  return 0; 
    20.  
    21. }

    十三、回调函数

    回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个
    函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数
    的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进
    行响应。（说一种大家能够理解的：回调函数其实不是直接去调这个函数，而是把函数的地址传递给另外一个函数，在函数内部通过函数指针去调用这个函数，这就叫回调函数。） 
    1. //将函数指针数组中的计算器改写成利用回调函数的形式
    2.  
    3. int Add(int x, int y)
    4. {
    5. 	return x + y;
    6. }
    7.  
    8. int Sub(int x, int y)
    9. {
    10. 	return x - y;
    11. }
    12.  
    13. int Mul(int x, int y)
    14. {
    15. 	return x * y;
    16. }
    17.  
    18. int Div(int x, int y)
    19. {
    20. 	return x / y;
    21. }
    22.  
    23.  
    24. void menu()
    25. {
    26. 	printf("***************************\n");
    27. 	printf("***** 1.add    2. sub  ****\n");
    28. 	printf("***** 3.mul    4. div  ****\n");
    29. 	printf("***** 0.exit           ****\n");
    30. 	printf("***************************\n");
    31. }
    32.  
    33. void calc(int (*p)(int, int))
    34. {
    35. 	int x = 0;
    36. 	int y = 0;
    37. 	int ret = 0;
    38. 	printf("请输入2个操作数:>");
    39. 	scanf("%d %d", &x, &y);
    40. 	ret = p(x, y);
    41. 	printf("%d\n", ret);
    42. }
    43.  
    44. int main()
    45. {
    46. 	int input = 0;
    47. 	do
    48. 	{
    49. 		menu();
    50. 		printf("请选择:>");
    51. 		scanf("%d", &input);
    52. 		switch (input)
    53. 		{
    54. 		case 1:
    55. 			calc(Add);
    56. 			break;
    57. 		case 2:
    58. 			calc(Sub);
    59. 			break;
    60. 		case 3:
    61. 			calc(Mul);
    62. 			break;
    63. 		case 4:
    64. 			calc(Div);
    65. 			break;
    66. 		case 0:
    67. 			printf("退出计算器\n");
    68. 			break;
    69. 		default:
    70. 			printf("选择错误\n");
    71. 			break;
    72. 		}
    73. 	} while (input);
    74. }

    13.1、qsort函数

      qsort为c语言标准库提供的排序函数。 

    1. qsort 可以排序任意类型的数据
    2.  
    3. //使用qsort函数，要包含头文件#include 
    4.  
    5. void qsort(   void* base  ,  //待排序数据的起始地址
    6. 	          size_t num  ,  //待排序数据的元素个数
    7. 	          size_t size ,  //待排序数据元素的大小（单位是字节）
    8. 	          int (*cmp)(const void*, const void*) //比较2个元素大小的函数指针
    9.           );
    10.  
    11.  
    12. int (*cmp)(const void* p1 , const void* p2)
    13. //如果p1大于p2，返回一个大于0的数；
    14. //如果p1小于p2，返回一个小于0的数；
    15. //如果p1等于p2，返回0；

    今天的内容到此结束就结束啦，本期内容到这里就跟大家告别一段落了，让我们期待下一篇的文章到来吧，感谢您的收看！

  • 相关阅读:
    如何理解Go言中的Context?
    上网行为监管软件（上网行为管理软件通常具有哪些功能）
    SharpCrafters PostSharp Crack
    java-net-php-python-jsp保险公司报销演示录像修改版2020计算机毕业设计程序
    微服务框架 SpringCloud微服务架构 4 Ribbon 4.1 负载均衡原理
    15.位操作
    NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis
    dom——style的操作
    2-推荐系统之机器学习基础
    【c++】刷题常用技巧
  • 原文地址：https://blog.csdn.net/m0_65030571/article/details/126398948