函数指针与回调函数

(1) 

1分钟学会函数指针与回调函数（上）_哔哩哔哩_bilibili

#include 
#include 
 
int sum(int x,int y){
return x+y;
}
int difference(int x,int y){
return x-y;
}
int product(int x,int y){
return x*y;
}
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    int a=5;
    int b=8;
    int (*p_func)(int,int);
    p_func=sum;
    printf("sum's address=%p\n",sum);
    printf("func_ptr=%p\n",p_func);
    printf("%d+%d=%d\n",a,b,sum(a,b));
    printf("%d+%d=%d\n",a,b,p_func(a,b));
    return app.exec();
}

sum's address=00401659
func_ptr=00401659
5+8=13
5+8=13

关键：

int (*p_func)(int,int);

函数指针func_ptr指向的地址为00401659

函数名的首地址是00401659

函数名可以被看作一个常量，它保存了函数的内存地址，

函数的内存地址，存储了函数开始执行的位置。

(2) 

C语言 | 函数指针作为函数的参数_函数指针作为参数_嵌入式大杂烩的博客-CSDN博客

#include 
#include 
 
typedef int (*fun_t)(int,int);
int calculate(int a,int b,fun_t operation)
{
    int result;
    result=operation(a,b);
    return result;
}
int add2(int a,int b)
{
    return a+b;
}
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    int result;
    int a=192,b=48;
    result=calculate(a,b,add2);
    printf("%d+%d=%d\n",a,b,result);
    return app.exec();
}

关键：

typedef int (*fun_t)(int, int);

fun_t指向一个带两个int类型的形参，int类型的返回值的函数。

使用关键字typedef int(*)(int,int)进行重命名为fun_t。

我们已经很熟悉int,float,double这些类型了。

如int a=10;

这里就是新定义了一种类型fun_t。

可以有fun_t  m=xxx;

int xxx(int,int)
 
{
    ......
    return value;
}

函数指针可以作为参数传递给另一个函数。

这时函数指针的使用就像普通的常量和变量。

函数指针作为参数传递的时候，接收参数传递的函数

通常需要根据指针调用对应的函数。

(3)

函数指针做函数参数 使用总结及其意义_函数指针作为函数的参数_AI浩的博客-CSDN博客

函数名是函数体的入口地址

(1)可通过函数类型定义函数指针：FuncType* pointer;

(2)可直接定义：type (*pointer)(parameter list);

pointer:函数指针变量名

type:函数的返回值类型

parameter list:指向函数的参数列表。

#include 
#include 
using namespace std;
int add(int a,int b)
{
    return a+b;
}
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    int sum=add(1,2);
    cout<<"sum:"<
    //声明一个函数类型
    {
        typedef int(MyFuncType)(int a,int b);
        //这里函数类型名为MyFuncType
        //int xxx(int,int);
        MyFuncType * myFuncVar=NULL;
        myFuncVar=add;
        int sum1=myFuncVar(2,4);
        cout<<"sum1:"<
    }
    //声明一个函数指针类型。
    {
        typedef int(*PFuncType)(int a,int b);
        PFuncType myFunc=NULL;
        //为什么这里又取地址呢？
        myFunc=&add;
        int sum2=myFunc(3,5);
        cout<<"sum2:"<
    }
    //定义一个函数指针，指向一个函数的入口地址
    {
        int(*MYPFUNC)(int a,int b);
        MYPFUNC =add;
        int sum3=MYPFUNC(10,5);
        cout<<"sum3:"<
    }
    return app.exec();
}

sum:3
sum1:6
sum2:8
sum3:15

 思考：

myFunc=&add;

这里为什么要取地址？

    {
        typedef int(*PFuncType)(int a,int b);
        PFuncType myFunc=NULL;
        myFunc=&add;
        int sum2=myFunc(3,5);
        cout<<"sum2:"<
    }
    {
        typedef int(*PFuncType)(int a,int b);
        PFuncType myFunc=NULL;
        myFunc=add;
        int sum2=myFunc(3,5);
        cout<<"sum2:"<
    }

结果一致，这两者有什么区别？

函数指针做函数参数：

函数指针A指向函数C

函数指针A作为函数参数，传递给一个被调用函数B，被调用函数

就可通过该指针调用外部函数C,这就形成了回调。