用函数指针改造
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 menu() { printf("****************************\n"); printf("***** 1. Add 2. Sub*****\n"); printf("***** 3. Mul 4. Div*****\n"); printf("***** 0. Exit *****\n"); printf("****************************\n"); } void calc(int(*pf)(int, int)) { int x = 0; int y = 0; int ret = 0; printf("输入操作数："); scanf("%d %d", &x, &y); ret = pf(x, y); printf("ret = %d\n", ret); } int main() { int input = 1; do { menu(); printf("请选择："); scanf("%d", &input); switch (input) { case 0: printf("退出程序\n"); break; case 1: calc(add); break; case 2: calc(sub); break; case 3: calc(mul); break; case 4: calc(div); break; default: printf("选择错误\n"); break; } } while (input); return 0; }
将冗余的代码全部封装到calc函数中，并把calc函数的参数设为一个函数指针。无论你是想用加减乘除的哪一个功能，只要把其函数的地址作为参数传给calc即可。
上面已经说过函数指针的用途了，那么函数指针数组是用来干嘛的呢？答案是转移表。
你是否觉得上面计算器代码已经足够简洁？大漏特漏，如果用函数指针数组来实现，代码将会更加简单。
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 }; //转移表 while (input) { printf("*************************\n"); printf(" 1:add 2:sub \n"); printf(" 3:mul 4:div \n"); printf("*************************\n"); printf("请选择："); scanf("%d", &input); if ((input <= 4 && input >= 1)) { printf("输入操作数："); scanf("%d %d", &x, &y); ret = (*p[input])(x, y); } else printf("输入有误\n"); printf("ret = %d\n", ret); } return 0; }
补个零只是为了实现选1就是调用add函数，毕竟数组的下标是从零开始的。从上面的代码可以看到，使用函数指针和函数指针数组可以简化代码。但他们实际的用途远不止于此。尤其是函数指针演变出来的回调函数，简直是妙不可言。
回调函数
回调函数就是通过函数指针调用的函数。如果我们把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方调用，而是在特定的事件或条件发生时由另一方调用，用于对该事件或者条件响应。值得一提的是C语言的库函数qsort就是使用了回调函数。
qsort简介
void qsort(void* base,//起始地址 size_t num,//元素个数 size_t size,//单个元素大小 int (*compar)(const void*, const void*));//比较函数 //qsort使用 //qsort函数的使用者得实现一个比较函数 int int_cmp(const void * p1, const void * p2) { return (*( int *)p1 - *(int *) p2); } int main() { int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 }; int i = 0; qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp); for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++) { printf( "%d ", arr[i]); } printf("\n"); return 0; }
上面出现了void * 类型，这个指针类型是泛型指针，可以接受任意类型的地址，但不能解引用也不能加减整数操作，因为无法确定类型不知道一次该访问多少字节。
使用回调函数改造冒泡排序
使用回调函数参考库函数的qsort可以将原本只能排序整形的冒泡排序改成可以排序任意类型。
struct Stu { char name[20]; int age[3]; }; int cmp_stu_name(const void* e1, const void* e2) { return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name); } int cmp_int(const void* e1, const void* e2) { return *((int*)e1) - (*(int*)e2);//e1大于e2，返回值大于零，相等返回值等于零，小于返回值小于零 } //在这个函数里调用不同的cmp函数就可以解决，但是问题在于cmp都是void型的元素， //强转成char*，然后每次交换宽度个char*， void Swap(char* e1, char* e2,int width) { //一个字节一个字节的交换 for (int i = 0; i < width; i++) { char tmp = *e1; *e1 = *e2; *e2 = tmp; e1++; e2++; } } int better_bubble_sort(void* base, size_t num, size_t width, int(*cmp)(const void* e1, const void* e2)) { int flag = 1;//假设数组就是有序的 int i = 0, j = 0; for ( i = 0; i < num; i++) { for (j = 0; j < num - 1 - i; j++) { if (cmp((char*)base + j * width, (char*)base + (j + 1) * width)>0)//这里的cmp就是传参过来的cmp，比较什么类型完全由使用者决定。从起始地址开始加上j*width就是当前元素 { Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);//交换两个元素 flag = 0; } } if (flag == 1) { break;//说明数组本省就是有序的，不用排 } } } int main() { int arr[] = { 0,1,2,6,5,4,7,8,9,3 }; struct Stu S[] = { {"zhangsan",15},{"lisi",20 },{"wangwu",30} }; int sz = sizeof(arr) / sizeof(arr[0]); int sz = sizeof(S) / sizeof(S[0]); better_bubble_sort(arr, sz1, sizeof(arr[0]), cmp_int); better_bubble_sort(S, sz,sizeof(S[0]), cmp_stu_name); for (int i = 0; i < sz; i++) { printf("%d ", arr[i]); } for (int i = 0; i < sz; i++) { printf("%s ", S[i]); } }
这里需要注意的就是，我们在写函数时不会知道使用则会传什么参数给我们，因此以最小的char类型来比较和交换，因为类型最小也占一个字节。而宽度又给我们提供了，一个类型的比较范围。从起始地址加上j乘宽度就可以得到当前元素的地址。而代码运行结果也确实告诉我们，改良后的代码不但能排序整形同样可以排序字符型。
8.数组和指针面试题
数组
一维数组：
int a[] = { 1,2,3,4 }; printf("%d\n", sizeof(a)); printf("%d\n", sizeof(a + 0)); printf("%d\n", sizeof(*a)); printf("%d\n", sizeof(a + 1)); printf("%d\n", sizeof(a[1])); printf("%d\n", sizeof(&a)); printf("%d\n", sizeof(*&a)); printf("%d\n", sizeof(&a + 1)); printf("%d\n", sizeof(&a[0])); printf("%d\n", sizeof(&a[0] + 1));
解析：
int a[] = { 1,2,3,4 }; printf("%d\n", sizeof(a));//16个字节 //sizeof数组名和单独的&数组名都是得到整个数组 printf("%d\n", sizeof(a + 0));//4/8 //a是首元素的地址，加零跳过零个整形，还是首元素地址，地址就是4/8个字节 printf("%d\n", sizeof(*a));//4 //*a是首元素 printf("%d\n", sizeof(a + 1));//4/8 //跳过一个元素，得到的是数组第二个元素的地址 printf("%d\n", sizeof(a[1]));//4 //数组第二个元素 printf("%d\n", sizeof(&a));//4/8 //虽然取出的是整个数组的地址，但地址就是4/8个字节 printf("%d\n", sizeof(*&a));//16 //&a是整个数组，解引用后也就得到整个数组 printf("%d\n", sizeof(&a + 1));//4/8 //从a的地址向后跳过了一整个数组的地址 printf("%d\n", sizeof(&a[0]));//4/8 //第一个元素的地址 printf("%d\n", sizeof(&a[0] + 1));//4/8 //与a+1一样
字符数组：
char arr[] = { 'a','b','c','d','e','f' }; printf("%d\n", strlen(arr)); printf("%d\n", strlen(arr + 0)); printf("%d\n", strlen(*arr)); printf("%d\n", strlen(arr[1])); printf("%d\n", strlen(&arr)); printf("%d\n", strlen(&arr + 1)); printf("%d\n", strlen(&arr[0] + 1));
解析：
char arr[] = { 'a','b','c','d','e','f' }; printf("%d\n", strlen(arr));//随机值 //因为数组中没有\0,而strlen要读取到\0才会停止 printf("%d\n", strlen(arr + 0));//随机值，理由同上 printf("%d\n", strlen(*arr));//访问冲突 //因为strlen(const char*str)，参数是字符指针，传字符a不合理。 //同时也包含了野指针问题，strlen（'a'）==strlen(97）把97作为地址传过去，但是97这块地址并不属于你。 printf("%d\n", strlen(arr[1]));//访问冲突，理由同上 printf("%d\n", strlen(&arr));//随机值，并且和第一第二个相同 //数组的地址和数组首元素地址相同，任何类型的地址都是该类型的起始地址 printf("%d\n", strlen(&arr + 1));//随机值-6 //跳过了一个arr数组，并且arr数组有六个元素 printf("%d\n", strlen(&arr[0] + 1));//随机值-1，只是跳过了第一个元素
二维数组：
int a[3][4] = {0}; printf("%d\n", sizeof(a[0] + 1)); printf("%d\n", sizeof(*(a[0] + 1))); printf("%d\n", sizeof(a + 1)); printf("%d\n", sizeof(&a[0] + 1)); printf("%d\n", sizeof(*a)); printf("%d\n", sizeof(a[3]));
解析：
int a[3][4] = {0}; printf("%d\n", sizeof(a[0] + 1));//4/8 //a[0]是第一行的数组名，并没有单独放在sizeof内，代表的是第一行的首元素的地址，因此a[0]+1其实就是第一行第二个元素的地址 printf("%d\n", sizeof(*(a[0] + 1)));//4 //得到的是a[0][1] printf("%d\n", sizeof(a + 1));//4/8 //a代表首元素的地址，其实就是第一行的地址，+1以后代表的是数组第二行的地址 printf("%d\n", sizeof(&a[0] + 1));//4/8 //第二行的地址 printf("%d\n", sizeof(*a));//16 //第一行的元素 printf("%d\n", sizeof(a[3]));//16 //看起来似乎越界了，但是sizeof只要知道类型就能计算大小，并不会真正的去访问。
指针面试题
试题一：
struct Test { int Num; char* pcName; short sDate; char cha[2]; short sBa[4]; }*p = (struct Test*)0x100000; //假设p 的值为0x100000。 如下表表达式的值分别为多少？ //已知，结构体Test类型的变量大小是20个字节 int main() { printf("%p\n", p + 0x1); printf("%p\n", (unsigned long)p + 0x1); printf("%p\n", (unsigned int*)p + 0x1); return 0; }
解析：
int main() { printf("%p\n", p + 0x1);//0x100014 //p是结构体指针，已知这个结构体是20个字节，+1就是跳过20个字节。 printf("%p\n", (unsigned long)p + 0x1); //把p强制转换为长整型，结果就是这个十六进制转为十进制再加一。/把整形以地址的形式打印出来是可以的 printf("%p\n", (unsigned int*)p + 0x1); //转为int型，+1就是往后跳四个字节。0x100004 return 0; }
试题二：
int main() { int a[5][5]; int(*p)[4]; p = a; printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]); return 0; }
解析：
试题三：
int main() { int a[4] = { 1, 2, 3, 4 }; int *ptr1 = (int *)(&a + 1); int *ptr2 = (int *)((int)a + 1); printf( "%x,%x", ptr1[-1], *ptr2); return 0; }
解析：
int* ptr1 = (int*)(&a + 1);
//无非就是跳过一个数组
int* ptr2 = (int*)((int)a + 1);//2000000
//这个有点意思了
试题四：
int main() { char *c[] = {"ENTER","NEW","POINT","FIRST"}; char**cp[] = {c+3,c+2,c+1,c}; char***cpp = cp; printf("%s\n", **++cpp); printf("%s\n", *--*++cpp+3); printf("%s\n", *cpp[-2]+3); printf("%s\n", cpp[-1][-1]+1); return 0; }
这题有点难度，我们一个一个画图掰扯：
printf(“%s\n”, **++cpp);
printf(“%s\n”, –++cpp+3);
printf(“%s\n”, *cpp[-2]+3);
printf(“%s\n”, cpp[ -1] [ -1 ]+1);
人脑的想象力是有限的，因此学会画图是我们的必备技能。
写在后面
指针是C语言的重要内容，为了后续数据结构的学习，在C语言的学习过程中，我们应该要把指针，结构体，动态内存管理这三章学好。
要坚持学习坚持进步啊。说到进步，我想起一个骚话：这个世界上没有毫无道理的横空出世，我被女生拒绝了三百多次才有今天的人见人爱，我是浩哥我还在提升自己，你也可以。（出自抖音某博主）。
