• C语言内功修炼--指针详讲（进阶）

    前言：

    通过之前的指针初阶讲解，相信大家已经大概明白了指针的概念以及基本用法，这里我再来整理一下：

    1.指针就是一个变量，用来存放地址，地址唯一标识着内存的一块空间。

    2.指针具有类型，指针的类型决定了指针加减整数操作的变化距离，同时也决定了解引用可操作空间大小的权限。

    3.指针的大小是固定的，一般是4个或者8个字节，取决于你的计算机的操作位数。

    4.指针的基本运算。

    如果还有不了解的朋友可以去再看看指针初阶的内容：

    C语言内功修炼---指针详讲（初阶）_失眠的稻草人259的博客-CSDN博客都说会用一门语言几个礼拜就可以了。这句话我不敢苟同，至少在我学习C语言指针之后就不这么觉得了。不信？//代码1//代码2这两行代码出自《C陷阱和缺陷》我相信大部分人在第一次看这俩行代码都是一脸懵逼。是不是头皮发麻？这是啥东西？如果你是这样，那么请收起你的骄傲，再也不要觉得C语言很“简单”，谦虚一点，好好学习！好了，其实无论你能否一眼看出来以上代码所表示的意思，我觉得都不应该轻视任何一门语言，编程世界，浩瀚无边，人外有天，天外有人。https://blog.csdn.net/qq_62987647/article/details/132794661?spm=1001.2014.3001.5501还有，想必有人想知道我在初阶提出的几个关于指针的代码到底是什么意思，带着疑问，小编带大家一步一步剖析。

    好了，下面开始我们指针进阶篇的学习：

    1.字符指针

    char *类型的指针我们叫字符指针，一般用来指向字符的地址。

    char* 指针的使用：

    1.我们可以用它来指向某一个字符的地址：

    1. char ch = 'w';
    2. char* pc = &ch;
    3. *pc = 'h';
    4. printf("%c\n", ch);

    输出为 h。

    这里我们用一个char* 类型的指针pc指向字符变量ch的地址，然后解引用这个地址，将这个地址的数据换成字符 'h',所以这个时候的ch变量存的值也就是'h'.

    2.我们可以用它来指向一个字符数组，这也是我们经常使用的方式：

    1. 	char* pc= "hello world";
    2. 	printf("%s\n", pc);

     这里我们的指针pc其实指向的是它所指向字符串首字符的地址，也就是‘h'的地址。

    题目（面试题）：

    1. char str1[] = "hello";
    2. char str2[] = "hello";
    3. const char* str3 = "hello";
    4. const char* str4 = "hello;
    5. if (str1 == str2)
    6. 	printf("str1 and str2 are same\n");
    7. else
    8. 	printf("str1 and str2 are not same\n");
    10. if (str3 == str4)
    11. 	printf("str3 and str4 are same\n");
    12. else
    13. 	printf("str3 and str4 are not same\n");

    以上代码输出什么呢？

    这是一道非常经典的考察字符指针的一道面试题，首先我们要知道，在c语言中，if（str1==str2）代码判断的是两个字符串的地址是否相等。

    str1 和 str2 都是字符数组，它们分别被初始化为 "hello"，这意味着它们在内存中占用一段连续的地址空间，并存储了相同的字符串内容。

    由于 str1 和 str2 是两个独立的数组，它们在内存中具有不同的地址，所以 str1 的地址不等于 str2 的地址，因此条件判断结果为假，打印出 “str1 and str2 are not same”。

    注意，这里的字符串str1和str2各自占据了一块独立的空间：

    所以str1[0]的地址和str2[0]的地址不一样。

    那么str3和str4呢？这里的str3和str4指针变量指向的是字符串常量 "hello" 的地址。在C语言中，字符串常量是存储在只读内存区域的，编译器会将相同的字符串常量合并为同一个地址。因此，str3 和 str4 的赋值实际上让它们指向了同一个 "hello" 字符串的地址。

    当使用 == 运算符比较两个指针变量时，比较的是它们所保存的地址值。因为 str3 和 str4 指向同一个地址，所以条件判断结果为真，打印出 “str3 and str4 are same”。

    通俗的来说，字符串常量存储在计算机内存中单独的一块区域，当几个指针指向同一个常量字符串的时候，其实指向的也就是同一个区域。但是在用字符串去初始化字符串数组的时候，计算机会在内存中再开辟出一块空间，需要多少个就开辟多少块空间，这些空间的地址也就不一样。

    打个比方，这里的字符串常量就是一口井里的水，人们可以跑到井口去喝水，此时人们去喝水的地方都是井口，是一样的。也可以用桶打回家喝，这个时候的指针就是人，桶就是数组，每个的家地址都不一样，这个时候人喝水的地方也就都不一样。（额，我也不知道这个例子合不合适hh）

    2.指针数组

    我们知道的数组有字符数组，整型数组，浮点数数组等，那么指针数组又是什么呢？

    指针数组其实本质上还是数组，只不过存放的数据类型是指针变量。

    	int* a[3];//整型字符数组

    3.数组指针

    3.1数组指针的定义

    数组指针是指一个指针变量，它指向一个数组的首元素。在 C 语言中，数组名本身就是指向数组第一个元素的指针，因此可以将数组名赋值给一个指针变量，这个指针变量就可以称为数组指针。

    int(*p)[3];

    这就是一个指向整型数组的数组指针，p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为3个整型的数组。所以p是一个 指针，指向一个数组，叫数组指针。

    //这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

    3.2 &数组名和数组名

    给出以下代码：

    int arr[10];

    这里&arr和arr分别是什么呢？

    1.  
    2. int arr[10] = { 0 };
    3. printf("%p %p %p\n", &arr, arr,&arr[0]);

    这里我们可以看到，这俩的地址是一样的，也跟首元素地址是一样的。

    这里的&arr取出来的是整个数组的地址，其实就是首元素的地址，arr是数组名，前面我们也了解了，其实数组名也就是首元素地址。

    所以这俩东西是一样的嘛？

    我们再来看：

    1.  
    2. 	int arr[10] = { 0 };
    3. 	printf("arr = %p\n", arr);
    4. 	printf("&arr= %p\n", &arr);
    5. 	printf("arr+1 = %p\n", arr + 1);
    6. 	printf("&arr+1= %p\n", &arr + 1);

    为什么arr+1和&arr+1又不一样了呢？

    虽然这俩在地址的值上是相等的，但是意义不一样。

    我们初级篇的时候就讲过，&数组名取出来的是数组的地址，这个时候的&数组名+1实际上是跳过了这个数组大小的距离，而arr+1中arr仅仅是代表首元素的地址，+1操作就只会跳过一个整型大小的距离，地址的含义不同也就意味着加减整数的权限也不同，这一点是刚接触指针容易搞混的地方。

    所以我们也就明白了，arr这个数组首元素地址是005BF708,arr+1表示的是首元素地址跳过一个整型元素大小距离的地址，一个整型的字节大小是4，所以005BF708+4=005BF70C(十六进制里的C表示十进制里的12)，同理，&arr+1表示的是首元素地址跳过整个数组大小距离的地址，这个数组大小按字节算是40个字节，所以&arr+1=005BF708+40=005BF730。

    3.3数组指针的使用

    首先我们已经知道了，数组指针指向的是一个数组的地址

    1. int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
    2. int(*p)[10] = &arr;//把数组arr的地址赋值给数组指针p

    这是最直接的使用方式，把数组的地址直接赋给指针。

    但是我们一般不会这么用。

    指针数组的常用方式：

    作为二维数组的传参方式：

    1. void print_arr1(int a[3][5], int row, int col) {
    2. 	for (int i = 0; i < row; i++) {
    3. 		for (int j = 0; j < col; j++) {
    4. 			printf("%d ", a[i][j]);
    5. 		}
    6. 		printf("\n");
    7. 	}
    8. }
    9.  
    10. void print_arr2(int(*a)[5], int row, int col) {
    11. 	for (int i = 0; i < row; i++) {
    12. 		for (int j = 0; j < col; j++) {
    13. 			printf("%d ", a[i][j]);
    14. 		}
    15. 		printf("\n");
    16. 	}
    17. }
    18. int main() {
    19. 	int arr[3][5] = { {0,1,2},{3,4,5},{6,7,8} };
    20. 	print_arr1(arr,3,5);
    21. 	printf("\n");
    22. 	print_arr2(arr,3,5);
    23. 	//数组名arr，表示首元素的地址
    24. 	//但是二维数组的首元素是二维数组的第一行
    25. 	//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
    26. 	//可以数组指针来接收
    27.  
    28. 	return 0;
    29. }

    这里需要注意的是，二维数组的首元素其实是第一行的地址，是一个一维数组的地址，所以我们可以把二维数组的元素看出是一维数组。所以，这里的arr其实是第一行一维数组的地址，是一个数组的地址，也就可以用数组指针来接收。

    那大家有没有想过，虽然此时的arr表示的是首行数组的地址，但是一个数组的地址不就是首元素的地址吗？其地址值不还是arr[0][0]吗？那我们可不可以用一个整型指针来作为参数接收这个二维数组呢？

    1. int arr[3][5] = { {0,1,2},{3,4,5},{6,7,8} };
    2. printf("%p\n", &arr[0][0]);
    3. printf("%p\n", &arr[0]);
    4. printf("%p\n", &arr);

    比如说这样：

    1. void print_arr2(int* a, int row, int col) {
    2. 	for (int i = 0; i < row; i++) {
    3. 		for (int j = 0; j < col; j++) {
    4. 			printf("%d ", a[i][j]);
    5. 		}
    6. 		printf("\n");
    7. 	}
    8. }
    9. int main() {
    10. 	int arr[3][5] = { {0,1,2},{3,4,5},{6,7,8} };
    11. 	//print_arr1(arr,3,5);
    12. 	//printf("\n");
    13. 	print_arr2(arr,3,5);

    一运行，发现失败。

    为什么呢？是因为，arr表示的是一个一维数组的地址，其接收地址的指针应该是一个数组指针，所以这里会发生类型不匹配的错误.(int(*a)[]不等于int * a).

    到这里我们就已经大致知道了数组指针和指针数组,那么我们来测试一下自己是不是真的掌握了吧!

    即时小测试:

    1. int arr[5];
    2. int *parr1[10];
    3. int (*parr2)[10];
    4. int (*parr3[10])[5];

    聪明的你来看看以上代码是什么意思吧!(不知道的私聊我告诉你答案hh).

    4.数组参数、指针参数.

    在写代码的时候,我们经常会需要把数组或者指针作为参数给指针调用,那具体我们应该怎么做呢?

    在上面简述数组指针的代码中我把数组传给了函数,但是为什么要这么使用,为什么可以这么使用想必有人心存疑惑.

    1. void print_arr1(int a[3][5], int row, int col) {
    2. 	for (int i = 0; i < row; i++) {
    3. 		for (int j = 0; j < col; j++) {
    4. 			printf("%d ", a[i][j]);
    5. 		}
    6. 		printf("\n");
    7. 	}
    8. }

    为什么要这么传参呢?还可以怎么传参呢?

    4.1一维数组传参

    1. void test(int arr[])//ok?
    2. {}
    3. void test(int arr[10])//ok?
    4. {}
    5. void test(int* arr)//ok?
    6. {}
    7. void test2(int* arr[20])//ok?
    8. {}
    9. void test2(int** arr)//ok?
    10. {}
    11.  
    12. 	
    13. int main() {
    14.     int arr[10] = { 0 };
    15. 	int* arr2[10] = { 0 };
    16. 	test(arr);
    17. 	test2(arr2);
    18. }

    上面哪些函数的参数接收一维数组表示错误呢?

    其实都是对的.

    一维数组传参主要有两种方式：

    1. //第一种传参方式，写出这种数组的形式--类型 数组名[],这里[]里的大小可写可不写，
    2. //因为无论是多少，其传过来的参数本质上也还是一个指针 
    3. void test(int arr[10])
    4. {}
    5.  
    6. //第二种传参方式--类型* 数组名 这种和第一种也是一样的，用来接收数组首元素的地址
    7. void test(int* arr)
    8. {}

    4.2二维数组传参

    1. void test(int arr[3][5])//ok?
    2. {}
    3. void test(int arr[][])//ok?
    4. {}
    5. void test(int arr[][5])//ok？
    6. {}
    7. //总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
    8. //因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
    9. //这样才方便运算。
    10. void test(int *arr)//ok？
    11. {}
    12. void test(int* arr[5])//ok？
    13. {}
    14. void test(int (*arr)[5])//ok？
    15. {}
    16. void test(int **arr)//ok？
    17. {}
    18. int main()
    19. {
    20.  int arr[3][5] = {0};
    21.  test(arr);
    22. }
    1.  
    2. void test(int arr[3][5])//可以，这里的行数可以写也可以不写
    3. {}
    4. void test(int arr[][])//不可以没有写出第二维的大小，也就不知道每一行有多少个元素
    5. {}
    6. void test(int arr[][5])//可以
    7. {}
    8. 	
    9. void test(int* arr)//不可以，这个指针只能指向某一个首元素的地址，二维数组的首元素是一个数组
    10. {}
    11. void test(int* arr[5])//不可以，这是一个指针数组，不能表示数组的地址
    12. {}
    13. void test(int(*arr)[5])//可以，数组指针，可以指向某个数组的地址，也就能指向二维数组的首元素地址
    14. {}
    15. void test(int** arr)//不可以，arr是一个二级指针，只能指向某个一级指针的地址
    16. {}
    17. int main()
    18. {
    19. 	int arr[3][5] = { 0 };
    20. 	test(arr);
    21. }

    总结：

    二维数组传参，函数形参的设计只能省略第一个[]的数字。 因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。 这样才方便运算。

    4.3一级指针传参

    思考：当一个一级指针作为某个函数的参数的时候，这个函数能接收什么参数呢？

    比如：

    1. void test1(int* P) {
    2. }
    3.  
    4. void test2(char* p) {
    5. }

    这两个函数分别能接收什么样的参数呢？

    先看test1函数，参数是一个整型指针，可以指向某个整数的地址，所以我们可以用这个指针来接收一个数组首元素的地址，这样我们就能通过这个地址向下遍历这个数组。

    1. void test1(int* p,int num) {
    2. 	for (int i = 0; i < num; i++) {
    3. 		printf("%d ", *(p + i));
    4. 	}
    5. 	printf("\n");
    6. }
    7.  
    8. int main() {
    9. 	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
    10. 	int* s = arr;
    11. 	test1(s, 10);//用整型指针s指向首元素地址，再传给函数
    12. 	test1(arr,10);//这里数组名就是数组首元素地址，也是最常用的数组传参的方式
    13. 	test1(&arr[0], 10);//取出首元素地址传参
    14. 	return 0;
    15. }

    再看test2函数，参数是一个字符指针，其实跟上面一样的，只不过一般都是用来接收一个字符串首元素的地址，这样我们也能实现在函数里面遍历这个字符串

    1.  
    2. void test2(char* p,int num) {
    3. 	for (int i = 0; i < num; i++) {
    4. 		printf("%c", *(p + i));
    5. 	}
    6. 	printf("\n");
    7. }
    8. int main() {
    9. 	char arr[] = "hello world";
    10. 	int len = strlen(arr);
    11. 	char* s = arr;
    12. 	test2(s, len);
    13. 	test2(arr, len);
    14. 	test2(&arr[0], len);
    15.  
    16. 	return 0;
    17. }

    这里我这两个函数都只是实现了遍历的功能，其实只要参数一级指针，我们就可以把数组的首元素的地址传进去，这就是传址调用，具体功能要根据需求设计。

    总结：

    一级指针做为函数参数可以用来接收某个元素的地址，也可以接收某个相同类型的指针变量。

    4.4二级指针传参

    思考：当函数的参数为二级指针的时候，可以接收什么参数？

    二级指针是什么？

    定义：二级指针是指向指针的指针。它们用于处理多级指针或者操作指向指针的指针的情况。

    int** ptr1；

    这里的ptr1就是一个二级指针，指向一个整型指针的地址

    我们可以声明一个二级指针来操作一个整型指针：

    1.  
    2. int* ptr;   // 一级指针
    3. int** pptr; // 二级指针
    4.  
    5. int num = 10;
    6. ptr = #
    7. pptr = &ptr;

    在上述示例中，pptr指向ptr，ptr指向num，因此通过pptr可以访问到num的值。

    二级指针的主要作用是在函数中传递指针的地址，以便在调用函数中修改指针的值。这对于函数的返回值需要修改为指针类型时非常有用。

    具体使用：

    1.  
    2. void test3(int** p) {
    3. 	printf("%d\n", **p);//*p表示的是指向的一级指针的地址 **p进行两次解引用，表示的是一级指针指向的元素
    4. }
    5.  
    6. int main() {
    7. 	int num = 10;
    8. 	int* ptr = #//一级指针指向一个整型变量num
    9. 	int** ptrr = &ptr;//二级指针指向一个一级指针的地址
    10. 	test3(&ptr);
    11. 	test3(ptrr);
    12. 	return 0;
    13. }

    这里要注意，要想用二级指针访所指向一级指针指向的元素，就要解引用两次。

    总结：

    二级指针传参时接收的是一个一级指针的地址，*二级指针表示的是指向指针的地址，**二级指针表示的是指向指针指向的元素。

    5.函数指针

    函数有没有地址呢？

    首先看一段代码：

    1. #include 
    2. void test()
    3. {
    4.  printf("hehe\n");
    5. }
    6. int main()
    7. {
    8.  printf("%p\n", test);
    9.  printf("%p\n", &test);
    10.  return 0;
    11. }

    这就是函数的地址，我们看到函数名其实就是函数的地址。

    那么函数的地址又该怎么保存起来呢？

    我们知道指针可以指向地址，那么我们可不可以用指针来指向某个函数呢？

    我们先来看：

    1. void test()
    2. {
    3.  printf("hehe\n");
    4. }
    5. //下面pfun1和pfun2哪个有能力存放test函数的地址？
    6. void (*pfun1)();
    7. void *pfun2();

    上面pfun1和pfun2哪个有能力存放test函数的地址？

    首先我们要知道，一个指向函数的指针其本质还是一个指针，很明显这里的pfun2是一个反回值为void*  的函数，并不是指针。而pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。

    这个时候我们就可以来回到初级篇开始提出的两段有趣的代码了：

    1. //代码1
    2. (*(void (*)())0)();
    3. //代码2
    4. void (*signal(int , void(*)(int)))(int);

    代码1：

    首先我们把代码拆开来看，先看：

    void (*)()

    这其实就是一个函数指针，该指针指向函数的返回值是void,没有参数.

    *(void (*)())0

    这里我们要从右往左看，首先将数字 0 转换为一个函数指针 void (*)()，然后通过 * 解引用该指针，得到一个函数返回值类型为 void的函数（void()），最后使用括号将其作为函数调用。

    总结：这段代码是一个函数调用表达式。

    代码2：

    先看：

    signal(int , void(*)(int))

    声明了signal函数，这个函数参数一个是int,还有一个是函数指针，该指针指向一个void(int)类型的函数（返回值为void,参数是int）。那signal函数的返回值类型是什么呢？

    void (*)(int);

    这是一个函数指针。

    void (*signal(int , void(*)(int)))(int);

    所以，signal函数的返回值类型是一个函数指针，这个指针指向的函数具有一个 int 类型的参数并返回 void。这表明 signal 函数本身可以被当作一个函数指针使用，可以用于指向其他函数并进行函数调用。

    总结：这段代码是一个函数声明，用于声明一个名为 signal 的函数。

    看到这里是不是有种豁然开朗的感觉呢？指针的使用原来可以这么巧妙！

    6.函数指针数组

    我们知道了指针数组其本质就是一个数组，只不过里面的元素类型为指针而已，那我们刚才又学到了函数指针，那么存放函数指针的数组又叫什么呢？---函数指针数组

    把函数的地址存到一个数组中，这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

    1. int (*parr1[10])();
    2. int *parr2[10]();
    3. int (*)() parr3[10];

    上面哪些是正确的函数指针数组的声明呢？

    答案是parr1,也就是第一个。

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

    那函数指针数组有什么用呢？

    函数指针数组的用途：转移表

    什么叫转移表？

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

    例子--计算机的实现

    代码：

    1. #include
    2. //加减乘除函数的实现
    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. int main()
    20. {
    21.     int x, y;
    22.     int input = 1;
    23.     int ret = 0;
    24.     do
    25.     {
    26.         printf("*************************\n");
    27.         printf(" 1:add           2:sub \n");
    28.         printf(" 3:mul           4:div \n");
    29.         printf("*************************\n");
    30.         printf("请选择：");
    31.         scanf("%d", &input);
    32.         switch (input)
    33.         {
    34.  
    35.         case 1:
    36.             printf("输入操作数：");
    37.             scanf("%d %d", &x, &y);
    38.             ret = add(x, y);
    39.             printf("ret = %d\n", ret);
    40.             break;
    41.         case 2:
    42.             printf("输入操作数：");
    43.             scanf("%d %d", &x, &y);
    44.             ret = sub(x, y);
    45.             printf("ret = %d\n", ret);
    46.             break;
    47.         case 3:
    48.             printf("输入操作数：");
    49.             scanf("%d %d", &x, &y);
    50.             ret = mul(x, y);
    51.             printf("ret = %d\n", ret);
    52.             break;
    53.         case 4:
    54.             printf("输入操作数：");
    55.             scanf("%d %d", &x, &y);
    56.             ret = div(x, y);
    57.             printf("ret = %d\n", ret);
    58.             break;
    59.         case 0:
    60.             printf("退出程序\n");
    61.             break;
    62.         default:
    63.             printf("选择错误\n");
    64.             break;
    65.         }
    66.     } while (input);
    67.  
    68.     return 0;
    69. }

    这里我们按照正常的思路去写了一个简易的计算器，实现的了基本整数的加减乘除功能，这些功能都用函数来实现调用，每一个功能的实现都有相应的模块。

    我们看这里，每一个功能我们都单独给出一个模块去实现，这样看上去好像非常清晰，但是假如还要实现一百个功能呢？这样的代码就显得非常繁琐了。

    于是我们就可以使用函数指针数组。

    既让函数指针数组存放的是函数指针，而我们又可以通过解引用来使用函数，那么我们可不可以把所有的函数指针都放在一个数组里面，每次通过下标来访问数组中不同的函数指针，也就能使用不同的函数。

    代码实现：

    1. int main()
    2. {
    3.     int x, y;
    4.     int input = 1;
    5.     int ret = 0;
    6.     int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
    7.     while (input)
    8.     {
    9.         printf("*************************\n");
    10.         printf(" 1:add           2:sub \n");
    11.         printf(" 3:mul           4:div \n");
    12.         printf("*************************\n");
    13.         printf("请选择：");
    14.         scanf("%d", &input);
    15.         if ((input <= 4 && input >= 1))
    16.         {
    17.             printf("输入操作数：");
    18.             scanf("%d %d", &x, &y);
    19.             ret = (*p[input])(x, y);
    20.         }
    21.         else
    22.             printf("输入有误\n");
    23.         printf("ret = %d\n", ret);
    24.     }
    25.     return 0;
    26. }

    以上代码是不是要比原来代码要更加简洁？

    在以上代码的核心就是：

      int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
    1. if ((input <= 4 && input >= 1))
    2.         {
    3.             printf("输入操作数：");
    4.             scanf("%d %d", &x, &y);
    5.             ret = (*p[input])(x, y);
    6.         }

    第一个代码片段是定义了一个函数指针数组p[5],这个数组里面存放了四个函数，分别是实现加减乘除功能函数的指针。

    第二个代码片段是，通过功能选择，访问相映射的函数指针数组的下标，解引用得到的也就是所对应的函数，再传参使用该函数。

    总结：

    通过使用函数指针数组，可以实现灵活的函数调用和动态的程序行为，使程序在运行时能够根据需要选择并执行不同的函数。

    7.指向函数指针数组的指针

    既然函数指针数组本质是一个数组，我们通过上面的学习又知道了数组指针这个概念，那么指向函数指针数组的指针又该怎么定义呢？

    1. void test(const char* str)
    2. {
    3.  printf("%s\n", str);
    4. }
    5. int main()
    6. {
    7.  //函数指针pfun
    8.  void (*pfun)(const char*) = test;
    9.  //函数指针的数组pfunArr
    10.  void (*pfunArr[5])(const char* str);
    11.  pfunArr[0] = test;
    12.  //指向函数指针数组pfunArr的指针ppfunArr
    13.  void (*(*ppfunArr)[5])(const char*) = &pfunArr;
    14.  return 0;
    15. }

    首先ppfunArr先与*结合，表明这是一个指针，然后跟[5]结合表明这个指针指向的是一个数组，这个数组元素的类型是void(*)(const char*)（函数指针）。

    8.回调函数

    什么叫回调函数？

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

    举例：

    qsrot函数演示：

    1. #include 
    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.     
    12.     qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
    13.     for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
    14.    {
    15.        printf( "%d ", arr[i]);
    16.    }
    17.     printf("\n");
    18.     return 0;
    19. }

    使用回调函数，模拟实现qsort（采用冒泡的方式）。

    1.  
    2. #include
    3. #include
    4. #include
    5.  struct student {
    6. 	int age;
    7. 	char name[20];
    8. };
    9.  
    10. //自定义比较剂
    11. //整数比较剂
    12. int cmp_int(void* e1, void* e2) {
    13. 	return *(int*)e2 - *(int*)e1;
    14. }
    15. //字符串比较剂
    16. int cmp_char(void* e1, void* e2) {
    17. 	return strcmp((char*)e1, (char*)e2);
    18. }
    19. //结构体比较剂,按照年龄排序
    20. int cmp_struct(void* e1, void* e2) {
    21. 	//printf("%d\n", ((struct student*)e2)->age - ((struct student*)e1)->age);
    22. 	return ((struct student*)e2)->age - ((struct student*)e1)->age;
    23. }
    24.  
    25.  
    26. void my_swap(char* e1, char* e2, size_t se) {
    27. 	for (int i = 0; i < se; i++) {
    28. 		char temp = *(e1+i);
    29. 		*(e1+i) = *(e2+i);
    30. 		*(e2+i) = temp;
    31. 	}
    32. }
    33.  
    34.  
    35. //冒泡排序法,泛型编程
    36. void my_qsort(void* base, size_t num, size_t sz, int (*cmp)(void* e1, void* e2)) {
    37. 	for (int i = 0; i < num -1; i++) {
    38. 		for (int j = 0; j < num - i-1; j++) {
    39. 			if (cmp((char*)base+j*sz,(char*)base+(j+1)*sz)>0) {
    40. 				my_swap((char*)base + j * sz, (char*)base + (j + 1) * sz,sz);
    41. 			}
    42. 		}
    43. 	}
    44. }
    45.  
    46. int main() {
    47. 	int num[10] = { 1,2,3,4,5,6,7,8,9,0 };
    48. 	char arr1[] = "asd";
    49. 	struct student s[] = { {20,"asd"},{19,"sss"},{18,"ddd"} };
    50.     int sz = sizeof(s) / sizeof(s[0]);//3
    51. 	my_qsort(num, 10, 4, cmp_int);//数组排序
    52. 	my_qsort(arr1, 3, 1, cmp_char);//字符串排序
    53.     my_qsort(s, sz, sizeof (s[0]), cmp_struct);//结构体排序
    54. 	for (int i = 0; i < 10; i++) {
    55. 		printf("%d ", num[i]);
    56. 	}
    57. 	printf("\n");
    58. 	for (int i = 0; i < 3; i++) {
    59. 		printf("%d %s\n", s[i].age, s[i].name);
    60. 	}
    61. 	printf("%s\n", arr1);
    62.  
    63.  
    64. 	return 0;
    65. }

    这里我们要注意void*类型的指针，为什么要用void*类型指针作为形参呢？

    void*类型指针？

    作为指针类型：void* 是一种通用的指针类型，可以指向任何类型的数据，即无类型指针。使用 void* 指针可以实现对任意类型的数据进行简单的传递或存储，但不能直接对其进行解引用操作，需要在使用前进行类型转换。

    通俗的来说，我们在实现这个排序函数的时候，我们不知道要对什么类型的数据进行排序，有可能是结构体，有可能是字符，也有可能是整型，为了保证传参的时候不出错，我们就用void*类型指针作为形参。

    9.指针和数组笔试题

    1. //一维数组
    2. int a[] = { 1,2,3,4 };
    3. printf("%d\n", sizeof(a));
    4. printf("%d\n", sizeof(a + 0));
    5. printf("%d\n", sizeof(*a));
    6. printf("%d\n", sizeof(a + 1));
    7. printf("%d\n", sizeof(a[1]));
    8. printf("%d\n", sizeof(&a));
    9. printf("%d\n", sizeof(*&a));
    10. printf("%d\n", sizeof(&a + 1));
    11. printf("%d\n", sizeof(&a[0]));
    12. printf("%d\n", sizeof(&a[0] + 1));
    13. //字符数组
    14. char arr[] = { 'a','b','c','d','e','f' };
    15. printf("%d\n", sizeof(arr));
    16. printf("%d\n", sizeof(arr + 0));
    17. printf("%d\n", sizeof(*arr));
    18. printf("%d\n", sizeof(arr[1]));
    19. printf("%d\n", sizeof(&arr));
    20. printf("%d\n", sizeof(&arr + 1));
    21. printf("%d\n", sizeof(&arr[0] + 1));
    22. printf("%d\n", strlen(arr));
    23. printf("%d\n", strlen(arr + 0));
    24. printf("%d\n", strlen(*arr));
    25. printf("%d\n", strlen(arr[1]));
    26. printf("%d\n", strlen(&arr));
    27.  
    28. printf("%d\n", strlen(&arr + 1));
    29. printf("%d\n", strlen(&arr[0] + 1));
    30. char arr[] = "abcdef";
    31. printf("%d\n", sizeof(arr));
    32. printf("%d\n", sizeof(arr + 0));
    33. printf("%d\n", sizeof(*arr));
    34. printf("%d\n", sizeof(arr[1]));
    35. printf("%d\n", sizeof(&arr));
    36. printf("%d\n", sizeof(&arr + 1));
    37. printf("%d\n", sizeof(&arr[0] + 1));
    38. printf("%d\n", strlen(arr));
    39. printf("%d\n", strlen(arr + 0));
    40. printf("%d\n", strlen(*arr));
    41. printf("%d\n", strlen(arr[1]));
    42. printf("%d\n", strlen(&arr));
    43. printf("%d\n", strlen(&arr + 1));
    44. printf("%d\n", strlen(&arr[0] + 1));
    45. char* p = "abcdef";
    46. printf("%d\n", sizeof(p));
    47. printf("%d\n", sizeof(p + 1));
    48. printf("%d\n", sizeof(*p));
    49. printf("%d\n", sizeof(p[0]));
    50. printf("%d\n", sizeof(&p));
    51. printf("%d\n", sizeof(&p + 1));
    52. printf("%d\n", sizeof(&p[0] + 1));
    53. printf("%d\n", strlen(p));
    54. printf("%d\n", strlen(p + 1));
    55. printf("%d\n", strlen(*p));
    56. printf("%d\n", strlen(p[0]));
    57. printf("%d\n", strlen(&p));
    58. printf("%d\n", strlen(&p + 1));
    59. printf("%d\n", strlen(&p[0] + 1));
    60. //二维数组
    61. int a[3][4] = { 0 };
    62. printf("%d\n", sizeof(a));
    63. printf("%d\n", sizeof(a[0][0]));
    64. printf("%d\n", sizeof(a[0]));
    65. printf("%d\n", sizeof(a[0] + 1));
    66. printf("%d\n", sizeof(*(a[0] + 1)));
    67. printf("%d\n", sizeof(a + 1));
    68. printf("%d\n", sizeof(*(a + 1)));
    69. printf("%d\n", sizeof(&a[0] + 1));
    70. printf("%d\n", sizeof(*(&a[0] + 1)));
    71. printf("%d\n", sizeof(*a));
    72. printf("%d\n", sizeof(a[3]));

    10.指针笔试题

    笔试题1：

    1. int main()
    2. {
    3.     int a[5] = { 1, 2, 3, 4, 5 };
    4.     int *ptr = (int *)(&a + 1);
    5.     printf( "%d,%d", *(a + 1), *(ptr - 1));
    6.     return 0;
    7. }
    8. //程序的结果是什么？

    笔试题2：

    1. //由于还没学习结构体，这里告知结构体的大小是20个字节
    2. struct Test
    3. {
    4.  int Num;
    5.  char *pcName;
    6.  short sDate;
    7.  char cha[2];
    8.  short sBa[4];
    9. }*p;
    10. //假设p 的值为0x100000。 如下表表达式的值分别为多少？
    11. //已知，结构体Test类型的变量大小是20个字节
    12. int main()
    13. {
    14.  printf("%p\n", p + 0x1);
    15.  printf("%p\n", (unsigned long)p + 0x1);
    16.  printf("%p\n", (unsigned int*)p + 0x1);
    17.  return 0;
    18. }

    笔试题3：

    1. int main()
    2. {
    3.     int a[4] = { 1, 2, 3, 4 };
    4.     int *ptr1 = (int *)(&a + 1);
    5.     int *ptr2 = (int *)((int)a + 1);
    6.     printf( "%x,%x", ptr1[-1], *ptr2);
    7.     return 0;
    8. }

    笔试题4：

    1. #include 
    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. }

    笔试题5：

    1. int main()
    2. {
    3.     int a[5][5];
    4.     int(*p)[4];
    5.     p = a;
    6.     printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    7.     return 0;
    8. }

    根据我们上面所学的，你可以试试上面的题目，看看输出什么呢？也算是检测一下自己对于指针和数组的掌握程度，如果上面的题目你都会，说明你对于指针的掌握程度已经入门啦！

    答案呢，我就不要再解释了，自己去编译器上输出看看就知道了。（自己要主动学习！） 

    其实是我累了hh.

    11.总结

    指针的学习是我们深入了解c语言不可避免的一道大关卡，要想学好c语言就必须学号指针！

    最后，麻烦大家点点关注，跪求！

  • 相关阅读:
    matplotlib基操（三）
    (14)Zotero：文献管理工具，支持阅读器和翻译插件的私人研究助理
    移动互联网测试岗——招聘现状
    好玩的js特效
    Vue3根据搜索框内容跳转至本页面指定位置
    Windows如何将软件安装在移动硬盘上？
    百科源码生活资讯百科门户类网站百科知识,生活常识
    mysql数据库中的数据如何加密呢？mysql8.0自带新特性
    Kubesphere之多租户体系
    Android入门第16天-Android里的SwitchButton的使用
  • 原文地址：https://blog.csdn.net/qq_62987647/article/details/133097671