• 第十讲：C语言指针（4）

    目录

    1、回调函数是什么？

    2、qsort使⽤举例

    2.1、使⽤qsort函数排序整型数据

    2.2、使⽤qsort排序结构数据

    3、qsort函数的模拟实现

    4、sizeof和strlen的对⽐

    4.1、sizeof

    4.2、strlen

    4.3、sizeof 和 strlen的对⽐

    5、数组和指针笔试题解析

    5.1、⼀维数组

    5.2、字符数组

    5.3、⼆维数组

    6、指针运算笔试题解析

    6.1、题⽬1：

    6.2、题⽬2

    6.3、题⽬3

    6.4、题⽬4

    6.5、题⽬5

    6.6、题⽬6

    6.7、题⽬7

    6.8、题目8

    上一篇：C语言指针（3）

    https://blog.csdn.net/yi_ren_yi_xin/article/details/138138355?spm=1001.2014.3001.5501

    1、回调函数是什么？

    回调函数就是⼀个通过函数指针调⽤的函数。

    如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数 时，被调⽤的函数就是回调函数。

    回调函数不是由该函数的实现⽅直接调⽤，⽽是在特定的事件或条 件发⽣时由另外的⼀⽅调⽤的，⽤于对该事件或条件进⾏响应。

    例如：

    1. //使⽤回到函数改造后
    2. #include 
    3. int add(int a, int b)
    4. {
    5. 	return a + b;
    6. }
    7. int sub(int a, int b)
    8. {
    9. 	return a - b;
    10. }
    11. int mul(int a, int b)
    12. {
    13. 	return a * b;
    14. }
    15. int div(int a, int b)
    16. {
    17. 	return a / b;
    18. }
    19. void calc(int(*pf)(int, int))
    20. {
    21. 	int ret = 0;
    22. 	int x, y;
    23. 	printf("输入操作数：");
    24. 	scanf("%d %d", &x, &y);
    25. 	ret = pf(x, y);
    26. 	printf("ret = %d\n", ret);
    27. }
    28.  
    29. int main()
    30. {
    31. 	int input = 1;
    32. 	do
    33. 	{
    34. 		printf("*************************\n");
    35. 		printf(" 1:add 2:sub \n");
    36. 		printf(" 3:mul 4:div \n");
    37. 		printf(" 0:exit \n");
    38. 		printf("*************************\n");
    39. 		printf("请选择：");
    40. 		scanf("%d", &input);
    41. 		switch (input)
    42. 		{
    43. 		case 1:
    44. 			calc(add);
    45. 			break;
    46. 		case 2:
    47. 			calc(sub);
    48. 			break;
    49. 		case 3:
    50. 			calc(mul);
    51. 			break;
    52. 		case 4:
    53. 			calc(div);
    54. 			break;
    55. 		case 0:
    56. 			printf("退出程序\n");
    57. 			break;
    58. 		default:
    59. 			printf("选择错误\n");
    60. 			break;
    61. 		}
    62. 	} while (input);
    63. 	return 0;
    64. }

    2、qsort使⽤举例

    使用前需要包含头文件，#include。

    qsort函数的特点：

    1、快速排序的方法。

    2、适合于任意类型数据的排序。

    qsort函数的第一个参数为需要排序数组的第一个元素的地址，第二个参数为排序元素的数量，第三个参数为一个元素的大小，单位是字节，第四个参数为一个指向函数的指针，这个函数能够比较第一个参数所指向的元素。

    2.1、使⽤qsort函数排序整型数据

    1. #include <stdio.h>
    2. //qosrt函数的使⽤者得实现⼀个⽐较函数
    3. int int_cmp(const void* p1, const void* p2)
    4. {
    5. 	return (*(int*)p1 - *(int*)p2);//强制类型转换为我们要排序的类型
    6. }
    7. int main()
    8. {
    9. 	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    10. 	int i = 0;
    11. 	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
    12.  
    13. 	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    14. 	{
    15. 		printf("%d ", arr[i]);
    16. 	}
    17. 	printf("\n");
    18.  
    19. 	return 0;
    20. }

    在上面的代码中，使用void的原因是我们并不清楚传过来的实参会是什么类型的指针。

    2.2、使⽤qsort排序结构数据

    1. struct Stu //学⽣
    2. {
    3. 	char name[20];//名字
    4. 	int age;//年龄
    5. };
    6.  
    7. //假设按照年龄来⽐较
    8. int cmp_stu_by_age(const void* e1, const void* e2)
    9. {
    10. 	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
    11. }
    12.  
    13. //strcmp - 是库函数，是专⻔⽤来⽐较两个字符串的⼤⼩的,要包含头文件sting.h
    14. //假设按照名字来⽐较
    15. int cmp_stu_by_name(const void* e1, const void* e2)
    16. {
    17. 	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
    18. }
    19.  
    20. //按照年龄来排序
    21. void test2()
    22. {
    23. 	struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
    24. 	int sz = sizeof(s) / sizeof(s[0]);
    25. 	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
    26. }
    27.  
    28. //按照名字来排序
    29. void test3()
    30. {
    31. 	struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
    32. 	int sz = sizeof(s) / sizeof(s[0]);
    33. 	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
    34. }
    35.  
    36. int main()
    37. {
    38. 	test2();
    39. 	test3();
    40. 	return 0;
    41. }

    3、qsort函数的模拟实现

    使⽤回调函数，模拟实现qsort。

    1、使用冒泡排序的思想。

    2、适用于任意类型数据的排序。

    1. #include <stdio.h>
    2. int int_cmp(const void* p1, const void* p2)
    3. {
    4. 	return (*(int*)p1 - *(int*)p2);
    5. }
    6.  
    7. void _swap(void* p1, void* p2, int size)
    8. {
    9. 	int i = 0;
    10. 	for (i = 0; i < size; i++)
    11. 	{
    12. 		char tmp = *((char*)p1 + i);
    13. 		*((char*)p1 + i) = *((char*)p2 + i);
    14. 		*((char*)p2 + i) = tmp;
    15. 	}
    16. }
    17. void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
    18. {
    19. 	int i = 0;
    20. 	int j = 0;
    21. 	for (i = 0; i < count - 1; i++)
    22. 	{
    23. 		for (j = 0; j < count - i - 1; j++)
    24. 		{
    25. 			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
    26. 			{
    27. 				_swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
    28. 			}//在上面的代码中之所以转换为char*是因为void*类型无法进行任何运算。
    29. 			//此外，char*在参与运算时，是最小的一个单位，加或者减几个单位，它就相应的移动几个单位。
    30. 	    }
    31. 	}
    32. }
    33. int main()
    34. {
    35. 	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    36. 	int i = 0;
    37.  
    38. 	bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
    39.  
    40. 	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    41. 	{
    42. 		printf("%d ", arr[i]);
    43. 	}
    44. 	printf("\n");
    45. 	return 0;
    46. }

    4、sizeof和strlen的对⽐

    4.1、sizeof

     sizeof 计算变量所占内存内存空间⼤⼩的，单位是 字节，如果操作数是类型的话，计算的是使⽤类型创建的变量所占内存空间的⼤⼩。

    sizeof 只关注占⽤内存空间的⼤⼩，不在乎内存中存放什么数据。

    例如：

    1. #include
    2. int main()
    3. {
    4. 	int a = 10;
    5. 	printf("%d\n", sizeof(a));
    6. 	printf("%d\n", sizeof a);
    7. 	printf("%d\n", sizeof(int));
    8.  
    9. 	return 0;
    10. }

    4.2、strlen

    strlen 是C语⾔库函数，功能是求字符串⻓度。

    统计的是从 strlen 函数的参数中这个地址开始向后， \0 之前字符串中字符的个数。 strlen 函数会⼀直向后找 \0 字符，直到找到为⽌，所以可能存在越界查找。

    1. #include 
    2. int main()
    3. {
    4. 	char arr1[3] = { 'a', 'b', 'c' };
    5. 	char arr2[] = "abc";
    6. 	printf("%d\n", strlen(arr1));
    7. 	printf("%d\n", strlen(arr2));
    8.  
    9. 	printf("%d\n", sizeof(arr1));
    10. 	printf("%d\n", sizeof(arr2));
    11. 	return 0;
    12. }

    运行结果为：

    4.3、sizeof 和 strlen的对⽐

    sizeof ：

     1. sizeof是操作符

    2. sizeof计算操作数所占内存的⼤⼩， 单位是字节

    3. 不关注内存中存放什么数据

    strlen：

     1. strlen是库函数，使⽤需要包含头⽂件 string.h

    2. srtlen是求字符串⻓度的，统计的是 \0 之前字符的隔个数

    3. 关注内存中是否有 \0 ，如果没有 \0 ，就会持续往后找，可能会越界。

    5、数组和指针笔试题解析

    5.1、⼀维数组

    1. #include<stdio.h>
    2. int main()
    3. {
    4. 	int a[] = { 1,2,3,4 };
    5. 	printf("%d\n", sizeof(a));//结果为16个字节
    6. 	printf("%d\n", sizeof(a + 0));//a+0在这里是指针，所以大小为4或者8个字节
    7. 	printf("%d\n", sizeof(*a));//首元素，所以是4个字节
    8. 	printf("%d\n", sizeof(a + 1));//指针，4或8个字节
    9. 	printf("%d\n", sizeof(a[1]));//4个字节
    10. 	printf("%d\n", sizeof(&a));//指针，4或8个字节
    11. 	printf("%d\n", sizeof(*&a));//16个字节，&a指向整个数组，解引用后代表整个数组
    12. 	printf("%d\n", sizeof(&a + 1));//指针，4或8个字节
    13. 	printf("%d\n", sizeof(&a[0]));//指针，4或者8个字节
    14. 	printf("%d\n", sizeof(&a[0] + 1));//指针，4或者8个字节
    15. 	return 0;
    16. }

    5.2、字符数组

    代码1：

    1. #include<stdio.h>
    2. int main()
    3. {
    4. 	char arr[] = { 'a','b','c','d','e','f' };
    5. 	printf("%d\n", sizeof(arr));//结果为6
    6. 	printf("%d\n", sizeof(arr + 0));//指针，结果为4或8个字节
    7. 	printf("%d\n", sizeof(*arr));//首元素，所以为1个字节
    8. 	printf("%d\n", sizeof(arr[1]));//结果为1个字节
    9. 	printf("%d\n", sizeof(&arr));地址，结果为4或8个字节
    10. 	printf("%d\n", sizeof(&arr + 1));//地址，结果为4或8个字节
    11. 	printf("%d\n", sizeof(&arr[0] + 1));//地址，结果为4或者8个字节
    12.  
    13. 	return 0;
    14. }

    代码2：

    1. #include<stdio.h>
    2. int main()
    3. {
    4. 	char arr[] = { 'a','b','c','d','e','f' };
    5. 	printf("%d\n", strlen(arr));//随机值，因为数组中没有\0
    6. 	printf("%d\n", strlen(arr + 0));//随机值
    7. 	printf("%d\n", strlen(*arr));//*arr表示数组首元素a，字符a的数值为97，从97这个地址向后统计\0 
    8.                                   //之前的字符个数，错误
    9. 	printf("%d\n", strlen(arr[1]));//同上，错误
    10. 	printf("%d\n", strlen(&arr));//随机值
    11. 	printf("%d\n", strlen(&arr + 1));//随机值
    12. 	printf("%d\n", strlen(&arr[0] + 1));//随机值
    13.  
    14. 	return 0;
    15. }

    代码3：

    1. char arr[] = "abcdef";
    2. printf("%d\n", sizeof(arr));//7个字节
    3. printf("%d\n", sizeof(arr+0));//指针，4或者8个字节
    4. printf("%d\n", sizeof(*arr));//1个字节
    5. printf("%d\n", sizeof(arr[1]));//1个字节
    6. printf("%d\n", sizeof(&arr));//指针，4或者8个字节
    7. printf("%d\n", sizeof(&arr+1));//指针，4或者8个字节
    8. printf("%d\n", sizeof(&arr[0]+1));//指针，4或8个字节

    代码4：

    1. char arr[] = "abcdef";
    2. printf("%d\n", strlen(arr));//结果为6
    3. printf("%d\n", strlen(arr+0));//结果为6
    4. printf("%d\n", strlen(*arr));//错误
    5. printf("%d\n", strlen(arr[1]));//错误
    6. printf("%d\n", strlen(&arr));//结果为6
    7. printf("%d\n", strlen(&arr+1));//结果为
    8. printf("%d\n", strlen(&arr[0]+1));//结果为5

    代码5：

    1. char *p = "abcdef";
    2. printf("%d\n", sizeof(p));//4或者8个字节
    3. printf("%d\n", sizeof(p+1));//4或者8个字节
    4. printf("%d\n", sizeof(*p));//1个字节
    5. printf("%d\n", sizeof(p[0]));//1个字节
    6. printf("%d\n", sizeof(&p));//指针，4或者8个字节
    7. printf("%d\n", sizeof(&p+1));//4或者8字节
    8. printf("%d\n", sizeof(&p[0]+1));//4或者8个字节

    代码6：

    1. char *p = "abcdef";
    2. printf("%d\n", strlen(p));//6个
    3. printf("%d\n", strlen(p+1));//5个
    4. printf("%d\n", strlen(*p));//错误
    5. printf("%d\n", strlen(p[0]));//错误
    6. printf("%d\n", strlen(&p));//随机值
    7. printf("%d\n", strlen(&p+1));//随机值
    8. printf("%d\n", strlen(&p[0]+1));//5个

    5.3、⼆维数组

    1. int a[3][4] = {0};
    2. printf("%d\n",sizeof(a));48个字节
    3. printf("%d\n",sizeof(a[0][0]));//4个字节
    4. printf("%d\n",sizeof(a[0]));//这个就相当于二维数组的第一行的一维数组的数组名，所以结果为16个字节
    5. printf("%d\n",sizeof(a[0]+1));//这个就相当于第一行第二个元素的地址，4或者8个字节
    6. printf("%d\n",sizeof(*(a[0]+1)));//4个字节
    7. printf("%d\n",sizeof(a+1));//相当于第二行地址，4或者8个字节
    8. printf("%d\n",sizeof(*(a+1)));//16个字节
    9. printf("%d\n",sizeof(&a[0]+1));//地址，4或者8个字节
    10. printf("%d\n",sizeof(*(&a[0]+1)));//16个字节
    11. printf("%d\n",sizeof(*a));//数组的首元素，4个字节
    12. printf("%d\n",sizeof(a[3]));//16个字节，sizeof内的表达式是不计算的，它只关注类型，a[3]的类型
    13.                             //为int[4]，所以为16个字节。

    数组名的意义：

    1. sizeof(数组名)，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩。

    2. &数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址。

    3. 除此之外所有的数组名都表⽰⾸元素的地址。

    6、指针运算笔试题解析

    6.1、题⽬1：

    1. #include <stdio.h>
    2. int main()
    3. {
    4.  int a[5] = { 1, 2, 3, 4, 5 };
    5.  int *ptr = (int *)(&a + 1);
    6.  printf( "%d,%d", *(a + 1), *(ptr - 1));
    7.  return 0;
    8. }

    运行结果为：

    这个题目比较简单，就不再讲了。

    6.2、题⽬2

    1. //在X86环境下
    2. //假设结构体的⼤⼩是20个字节
    3. //程序输出的结构是啥？
    4. struct Test
    5. {
    6. 	int Num;
    7. 	char* pcName;
    8. 	short sDate;
    9. 	char cha[2];
    10. 	short sBa[4];
    11. }*p = (struct Test*)0x100000;
    12. int main()
    13. {
    14. 	printf("%p\n", p + 0x1);//加1要跳过一个结构体。
    15. 	printf("%p\n", (unsigned long)p + 0x1);
    16. 	printf("%p\n", (unsigned int*)p + 0x1);
    17. 	return 0;
    18. }

    运行结果为:

    6.3、题⽬3

    1. #include <stdio.h>
    2. int main()
    3. {
    4.  int a[3][2] = { (0, 1), (2, 3), (4, 5) };//这里有逗号表达式。
    5.  int *p;
    6.  p = a[0];
    7.  printf( "%d", p[0]);
    8.  return 0;
    9. }

    运行结果为：

    6.4、题⽬4

    1. //假设环境是x86环境，程序输出的结果是啥？
    2. #include <stdio.h>
    3. int main()
    4. {
    5. 	int a[5][5];
    6. 	int(*p)[4];
    7. 	p = a;
    8. 	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    9. 	return 0;
    10. }

    图解：

    运行结果为：

    6.5、题⽬5

    1. #include <stdio.h>
    2. int main()
    3. {
    4. 	int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    5. 	int* ptr1 = (int*)(&aa + 1);
    6. 	int* ptr2 = (int*)(*(aa + 1));
    7. 	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
    8. 	return 0;
    9. }

    运行结果为：

    6.6、题⽬6

    1. #include <stdio.h>
    2. int main()
    3. {
    4. 	char* a[] = { "work","at","alibaba" };
    5. 	char** pa = a;
    6. 	pa++;
    7. 	printf("%s\n", *pa);
    8. 	return 0;
    9. }

    运行结果为：

    6.7、题⽬7

    1. #include <stdio.h>
    2. int main()
    3. {
    4. 	char* c[] = { "ENTER","NEW","POINT","FIRST" };
    5. 	char** cp[] = { c + 3,c + 2,c + 1,c };
    6. 	char*** cpp = cp;
    7. 	printf("%s\n", **++cpp);
    8. 	printf("%s\n", *--* ++cpp + 3);
    9. 	printf("%s\n", *cpp[-2] + 3);
    10. 	printf("%s\n", cpp[-1][-1] + 1);
    11. 	return 0;
    12. }

    图解：

    运行结果为：

    6.8、题目8

    1. //X86环境下运行
    2. #include<stdio.h>//指针加1，取决于指针的类型。它要跳过一个它本身类型大小的空间。
    3. //整数加1，那就是加1
    4. int main()
    5. {
    6. 	int a[4] = { 1,2,3,4 };
    7.  
    8. 	int* ptr1 = (int*)(&a + 1);
    9.  
    10. 	int* ptr2 = (int*)((int)a + 1);
    11.  
    12. 	printf("%#x,%#x", ptr1[-1], *ptr2);//使用#可以让程序打印16进制时，把0x也给打印出来。
    13.  
    14. 	return 0;
    15. }

    图解：

    运行结果为：

    到这里，指针的内容就暂时结束了。

    如果有问题，欢迎到评论区进行交流或者私信。

  • 相关阅读:
    牛客刷SQL---2
    jupyter notebook进不去指定目录怎么办？
    MySQL之索引
    【leetcode】【剑指offer Ⅱ】067. 最大的异或
    CSS属性 - display
    动态规划：05不同路径
    qt——窗口置灰不可操作
    还在为没机器练手搭集群而苦恼？快进来免费领机器了！
    Pytorch linear 多维 输入的参数
    C++精通之路：红黑树的应用（模拟实现map/set）
  • 原文地址：https://blog.csdn.net/yi_ren_yi_xin/article/details/138159520