函数指针
先看一段代码：
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}
结果：
0000000000401550
0000000000401550
我们可以看到函数名可以表示成地址，那么对于函数的地址，我们就可以用函数指针来存储。
void test()
{
printf("hehe\n");
}
void (*pfun1)();
星号先与变量名结合，表示指针，后面加上小括号就表示指针指向的是函数的地址。
当函数里面有参数时，我们也需要跟着写进去。
void test(char* pc, int arr[10])
{
}
int main()
{
void (*pf)(char *, int [10]) = test;
return 0;
}
只需要写数据类型即可，可以不跟变量名。
下面看一下函数指针的用例：
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*pf)(int, int) = Add;
int r = Add(3, 5);
printf("%d\n", r);
int m = (*pf)(4, 5);
printf("%d\n", m);
return 0;
}
8
9
这里我们可以直接调用函数的地址，对它进行解引用，还需要对其函数进行传参，就能实现一个函数的调用；这里*和pf需要用下括号括起来，**倘若没有下括号，那么pf会先与（4，5）先结合，**那么星号在这里就会变成无效的引用，程序将会报错。
函数指针数组
这是一个存放函数地址的数组；
int (*parr1[10])();
我们可以先写出一个函数指针int(*parr1)(),然后通过优先级将【】与parr1结合，就变成了函数指针数组。
下面我们用计算器这个例子，分别用switch和函数指针数组进行对比；
#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( "*************************\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;
}
这是用switch写出来的计算器，可以实现加减乘除的功能，但我们会发现，倘若我们要对该程序进行补充功能时，那么就得重复写case中的语句，当然我们可以直接粘贴复制，但我们看起来就会比较冗余，认为重复的地方出现过太多次了；
函数指针数组的方式：
#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 }; //转移表
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;
}
我们先在主函数创建一个函数指针数组int(*p[5])(int x, int y) = { 0, add, sub, mul, div }；调用时，只需要对指针p解引用，输入正确的下标和参数，就能实现不必要的冗余。
指向函数指针数组的指针
void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针pfun
void (*pfun)(const char*) = test;
//函数指针的数组pfunArr
void (*pfunArr[5])(const char* str);
pfunArr[0] = test;
//指向函数指针数组pfunArr的指针ppfunArr
void (*(*ppfunArr)[5])(const char*) = &pfunArr;
return 0;
}
对于这么长的描述，我们可以从函数指针下手，然后拓展到函数指针数组，最后用指针指向函数指针数组即可，我们在写的时候要注意，各符号的优先级，当有[]和星号时，如果没有小括号将变量名和星号括起来，那么它最终就是一个数组，且星号放在变量名前面，[]放在变量名后面，不能随意乱放。
总的来说，对于数组和指针，我们可以组成很长数组指针数组，对于这种写法，我们重点在于要学会看懂怎么读，懂得各符号的优先级，明白哪个与哪个相结合，拆开分解后就一目了然了。
回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
qsort函数各类的使用
void qsort (void* base, size_t num, size_t size,
int (compar)(const void,const void*))
这是一个快排函数，我们可以看到，它的参数包含函数指针，当我们调用这个函数时，必须对函数指针指向的函数进行调用完，该函数才得以实现，表明qsort函数是一个回调函数。下面我们来看看qsort函数各种类型数据的使用。
整型类型数据：
#include <stdio.h>
int int_cmp(const void * p1, const void * p2)
{
return (*( int *)p1 - *(int *) p2);
}
void test1()
{
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");
}
int main()
{
test1();
return 0;
}
结果：0 1 2 3 4 5 6 7 8 9
在这里，对于qsort函数的最后一个参数，需要我们自己创建一个符合条件的函数，使它对应的返回值能够判断不同元素的大小即可。
浮点类型的：
int float_cmp(const void* p1,const void* p2)
{
if((*(float*)p1-*(float*)p2)>0.000000)
{
return 1;
}
else if((*(float*)p1-*(float*)p2)<0.000000)
{
return -1;
}
else
{
return 0;
}
}
void test2()
{
float arr[]={
3.14,2.56,6,78,5.32,4.02};
int i=0;
qsort(arr,sizeof(arr)/sizeof(arr[0]),sizeof(float),float_cmp);
for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
{
printf( "%.2f ", arr[i]);
}
printf("\n");
}
int main()
{
// test1();
test2();
return 0;
}
2.56 3.14 4.02 5.32 6.00 78.00
在这里，对于最后一个参数，浮点数由于具有精度，函数类型为整型，所以需要与具有精度的0进行判断，所以需要加上条件判断语句。倘若使用第一种方法的强制换类型，那么将会丢失精度。
字符串：
//字符串的大小
int str_cmp_size(const void* p1,const void* p2)
{
return strcmp(*(char**)p1,*(char**)p2);
}
//字符串的长度
int str_cmp_len(const void* p1,const void* p2)
{
return strlen(*(char**)p1)-strlen(*(char**)p2);
}
void test3()
{
char* arr[]={
"abc","VPN","RTx","Rtx","rtxbbb","abbb"};
int i=0;
qsort(arr,sizeof(arr)/sizeof(arr[0]),sizeof(arr[0]),str_cmp_len);
for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
{
printf( "%s ", arr[i]);
}
printf("\n");
}
int main()
{
// test1();
//test2();
test3();
return 0;
}
大小：RTx Rtx VPN abbb abc rtxbbb
长度：VPN RTx Rtx abc abbb rtxbbb
在这里，为何不直接调用（char*)p1,而要用*（char**),这是因为如果用（char*）的话，对于形参p1来说，存的是arr数组名的地址，strcmp（）会将p地址对应的内容转换为字符串，这就不符合我们的想法，所以应该是将数组中对应的字符串的地址传过去，再对其解引用，这样才能得到真正的字符串。
struct Stu
{
char name[20];
int age;
};
int cmp_stu_by_age(const void* p1, const void* p2)
{
return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
void test4()
{
struct Stu arr[] = {
{
"zhangsan", 20}, {
"lisi", 50},{
"wangwu", 15} };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
for (int i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
{
printf( "%d ", arr[i].age);
}
printf("\n");
}
int cmp_stu_by_name(const void* p1, const void* p2)
{
return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
void test5()
{
struct Stu arr[] = {
{
"zhangsan", 20}, {
"lisi", 50},{
"wangwu",15}};
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
for (int i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
{
printf( "%s ", arr[i].name);
}
printf("\n");
}
int main()
{
// test1();
//test2();
//test3();
test4();
test5();
return 0;
}
15 20 50
lisi wangwu zhangsan
对于结构体的使用，要用结构体指针，指向对应的比较变量，就能得到最终答案。
模拟实现sqort函数
在这里，我们用的是冒泡排序实现sqort函数的思想。
void bubble_sort(int arr[], int sz)
{
int i = 0;
//趟数
for (i = 0; i < sz - 1; i++)
{
//一趟比较
//两两相邻元素比较
int j = 0;
for (j = 0; j < sz - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
这是一个整型类型的冒泡排序，当我们要用到浮点型，结构体类型时，就无法使用该函数，所以，我们根据sqort函数的参数进行模拟实现。
我们可以对上面函数进行改装，首先不能改变冒泡排序的思想，也就是两层循环不变，而我们要改变的是，对于不同类型的比较方式，还有不同类型是怎么交换的。
对于不同类型的比较，我们用到sqort的第四个参数，我们要解决的是怎么传参？我们要清楚，我们传的是每个元素的地址，不同类型意味着它们每个元素所占字节不一样，那么我们可以利用元素的大小乘上对应的j，就能实现元素地址的传递了。
(cmp((char*)base+jsize, (char)base+(j+1)size)>0)
我们用char强制类型转换，因为char*指针移动时，刚好是一个字节一个字节过去的；
对于转换，我们已经知道每个不同类型元素的地址了，我们只需要交换它们的地址即可，对于char*类型的，我们可以一个字节一个字节循环转换；那么就写一个交换函数来进行实现；
void Swap(char* buf1, char* buf2, int size)//交换arr[j],arr[j+1]这两个元素
{
int i = 0;
char tmp = 0;
for (i = 0; i < size; i++)
{
tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
原代码：
void Swap(char* buf1, char* buf2, int size)
{
int i = 0;
char tmp = 0;
for (i = 0; i < size; i++)
{
tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
void bubble_sort(void* base, int num, int size, int (*cmp)(const void*, const void*))
{
int i = 0;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
if (cmp((char*)base+j*size, (char*)base+(j+1)*size)>0)
{
Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
}
}
}
}
这就是利用冒泡排序实现sqort函数的思想，对于如何使用，使用方法和上面的sqort函数是一模一样的，这里就不在过多展示。