C语言函数指针和回调函数

彻底搞定C指针－函数名与函数指针

函数名&函数名取地址

函数指针

通常我们可以将指针指向某类型的变量，称为类型指针（如，整型指针）。若将一个指针指向函数，则称为函数指针。

函数名的意义

函数名代表函数的入口地址，同样的，我们可以通过根据该地址进行函数调用，而非直接调用函数名。

 void test001(){
     printf("hello, world");
 }

 int main(){

     printf("函数入口地址：%d", test001);//qt中的函数入口地址不会变，C中会变，这里仅为了说明问题
     //test001();
     int *testADD = (int *);//将地址转化为int型指针
     void(*myfunc)() = testADD;//将函数写成函数指针，有些书上会写&testADD
     myfunc(); //调用函数指针
     system("pause");
     return ;
 }

另外，还有以下结论：

（1）test001的函数名与myfunc函数指针都是一样的，即都是函数指针。test001函数名是一个函数指针常量，而myfunc是一个函数指针变量，这是它们的关系。

 int test001(int a, char b){
     printf("hello, world\n");
     return ;
 }

 int main(){

     int(*myFun)(int, char) = test001;
     myFun = test001;

     //下面四种表达式的结果是相同的
     int a = ;
     char b = 's';
     myFun(a, b);
     (*myFun)(a, b);
     test001(a, b);
     (*test001)(a, b);

     system("pause");
     return ;
 }

（2）testADD和&testADD的值一样，但表达的含义不同，与数组名和“&数组名”类似，详见指针和数组的关系。

定义函数指针

定义函数指针最简单的是直接定义函数指针变量，另外还有定义函数类型和定义函数指针类型。

 int test001(int a, char b){
     printf("hello, world\n");
     return ;
 }

 void test002(){

     //定义函数类型
     typedef int(Fun)(int, char);
     Fun *funFir = test001;

     //定义函数指针类型
     typedef int(*FunP)(int, char);
     FunP funSec = test001;

     //定义函数指针变量
     int(*funThi)(int, char) = NULL;//若报错，在强制转型，(int(*)(int , char))NULL
     funThi = test001;
 }

函数指针用于形参

这种用法通常出现在回调函数中，一般回调函数用于定制操作，下面的例子将说明如何进行定制操作

 /*
 -----------------------
 函数指针用作另一个函数的参数
 -----------------------
 */
 int con1(int a, int b){
     return a + b;
 }

 int con2(int a, int b){
     return a - b;
 }

 int con3(int a, int b){
     return a + b + ;
 }

 //在函数体中显式调用函数，将失去灵活性
 //尽管我可以用switch实现三种con的切换
 void doc(){
     int a = ;
     int b = ;
     int ret = con1(a, b);
 }

 //用如下的调用方式，调用者并不知道调用的哪个函数
 //因此根据函数指针的函数原型可以自己实现新函数，并进行调用
 int doc_p(int(*temp)(int ,char)){
     int a = ;
     int b = ;
     int ret = temp(a,b);
     return ret;
 }

 /*
 ---------------------
 函数指针数组
 ---------------------
 */
 void func1(){
     printf("a");
 }
 void func2(){
     printf("a");
 }
 void func3(){
     printf("a");
 }

 void test003(){
     int(*func[])();
     func[] = func1;
     func[] = func2;
     func[] = func3;

     for (int i = ; i < ; ++i)
     {
         func[i];
     }
 }

为什么我们要把函数作为参数来调用呢，直接在函数体里面调用不好吗？

在这个意义上，“把函数做成参数”和“把变量做成参数”目的是一致的，就是以不变应万变。形参是不变的，而实参是可以定制的。唯一不同的是，普通的实参可以由计算机程序自动产生，而函数这种参数计算机程序是无法自己写出来的，因为函数本身就是程序，它必须由人来写。所以对于回调函数这种参数而言，它的“变”在于人有变或者人的需求有变。

回调函数

回调函数和普通函数完成的功能是一样的，但回调函数更灵活，普通函数在函数体中调用，失去了变量的灵活性，有点类似于模板编程。

（1）首先是通过内存偏移，访问数组的各元素地址，两种方法的结果相同

 void printAll(void *arr, int eleSize, int len){

     char *start = (char*)arr; //强制转型
     for (int i = ; i < len; ++i){
         printf("%d\n", start+i*eleSize);//内存偏移
     }
 }

 void test004(){
     int arr[] = {,,,,};
     printAll(arr, sizeof(int), );
     printf("-------------------\n");
     for (int i = ; i < ; ++i){
         printf("%d\n", &arr[i]);
     }
 }

 int main(){
     test004();

     system("pause");
     return ;
 }

（2）对上面的函数用函数指针进行改写

 //添加函数指针作形参，必须写明变量名
 void printAll(void *arr, int eleSize, int len, void(*print)(void *data)){

     char *start = (char*)arr; //强制转型
     for (int i = ; i < len; ++i){
         char *eleAddr = start + i*eleSize;
         print(eleAddr);
         //print(start+i*eleSize);
     }
 }

 //自定义的被调用函数
 void Myprint(void * data){
     int *p = (int *)data;
     printf("%d\n", *p);
 }

 void test004(){
     int arr[] = {,,,,};
     printAll(arr, sizeof(int), , Myprint);
 }

 int main(){
     test004();

     system("pause");
     return ;
 }

（3）对上面的函数指针添加自定义的数据类型

 //添加函数指针作形参，必须写明变量名
 void printAll(void *arr, int eleSize, int len, void(*print)(void *data)){

     char *start = (char*)arr; //强制转型
     for (int i = ; i < len; ++i){
         char *eleAddr = start + i*eleSize;
         print(eleAddr);
         //print(start+i*eleSize);
     }
 }

 //自定义的被调用函数
 void Myprint(void * data){
     int *p = (int *)data;
     printf("%d\n", *p);
 }

 struct Person{
     char name[];
     int age;
 };

 //添加自定义的数据类型打印函数
 void MyprintStruct(void * data){
     struct Person *p = (struct Person  *)data;
     printf("%s,%d\n", p->name, p->age);
 }

 void test004(){
     int arr[] = {,,,,};
     printAll(arr, sizeof(int), , Myprint);

     struct Person person[] = {
         {"aaa", },
         {"bbb", }
     };
     printAll(person, sizeof(struct Person), , MyprintStruct);

 }

 int main(){
     test004();

     system("pause");
     return ;
 }

回调函数最大的优势在于灵活操作，可以实现用户定制的函数，降低耦合性，实现多样性。