c++回调函数

最近用到了回调函数，距离上次使用至少隔了5年了，又重新熟悉了一下。

过程：一个dll封装了tcp模块，我要向dll中传入服务器信息，还有一个回调函数（接收客户端信息等）。

接口头文件中：

struct structParameter{//回调函数传的数据结构

这里面是接收缓冲区，接收长度，socketid，socket通信状态，服务端监听端口号

};

#ifdef CPP_11

using PFun_MyCallback = std::function<void(const structParameter&)>;

#else

typedef void(PFun_MyCallback *)(const structParameter&);

#endif

struct serverInfo{

ip,port,

PFun_MyCallback pCallbackFun;//回调函数指针

};

我在类中创建一个静态函数 static void netData(const structParameter&)；

serverIn server；

server.pCallbackFun = netData;

然后将server传入dll即可。

 

 

以下转自：https://blog.csdn.net/hua12134/article/details/88264250

什么是函数指针
函数指针就是指向函数的指针，指向某种特定的类型。函数的类型由它的返回类型和形参类型共同决定，与函数名无关，例如：

bool lengthCompare(const string &, const string &);

该函数类型是bool (const string &, const string &)。
如何声明一个指向该函数的指针?只需要用指针替换函数名即可：

bool （*pf）(const string &, const string &);    //pf是一个函数指针

如何使用函数指针
当把函数名作为一个值使用时，该函数自动地转换成指针，比如，把lengthCompare的地址赋给pf,下面两种写法是等价的：

pf = lengthCompare;
pf = &lengthCompare;

注意，指向不同函数类型的函数指针不存在转换规则，比如，上面的pf就只能指向bool (const string &, const string &)这种类型的函数，形参类型和返回值类型必须匹配。另外，如果函数指针有重载，则指针类型必须与重载函数中的某一个精确匹配。

typedef定义函数指针类型

typedef bool func(const string &, const string &);
typedef bool (*myFunc) (const string &, const string &);

可以看出，func是函数类型，而myFunc是指针类型，注意typedef 定义的是某种类型，并不是具体指向某个函数的函数指针。我们可以使用myFunc定义一个函数指针并初始化：

myFunc p_func = nullptr;

函数指针作形参
函数名可以直接作为实参使用，此时它被自动转换为指针（指向该函数的指针），比如：

void useBigger(const string &, const string &, lengthCompare);

自动将函数lengthCompare转换成指向该函数的指针。

返回函数指针
返回一个指向函数的指针，返回类型必须写成指针形式，因为编译器不会自动地将函数返回类型当成指针类型处理（与函数类型的形参不一样）。想要声明一个返回函数指针的函数，最简单的方法是使用类型别名（C++11新增，VS2010的编译器暂不支持）

using F = int (int*, int);    //F是函数类型
using PF = int (*) (int*, int);    //PF是指针类型

回调函数
下面这个栗子简单易懂，有助于了解回调函数

#include <iostream>
#include <cstdlib>

using namespace std;

typedef float (*p_func)(int, int, float);

//回调函数
float func_1(int a, int b, float c)
{
    return a*b*c;
}

//回调函数
float func_2(float a, float b, float c)
{
    return a+b+c;
}

float func_3(int a, int b, float c, p_func p)
{
    return (*p)(a,b,c);        //等价于 return *p(a,b,c);
}

float func_4(int a, int b, float c, float (*p_ff)(float, float, float))
{
    return (*p_ff)(a,b,c);    //等价于 return *p_ff(a,b,c);
}

//下面4个函数都是回调函数
float func_add(float a, float b, float c) 
{
    return a+b+c;
}
float func_sub(float a, float b, float c) 
{
    return a-b-c;
}
float func_mul(float a, float b, float c) 
{
    return a*b*c;
}
float func_div(float a, float b, float c) 
{
    return a/b/c;
}

int main()
{
    cout << "func_3 :" << func_3(3, 6, 2.5, func_1) << endl;
    cout << "func_4 :" << func_4(3, 6, 2.5, func_2) << endl << endl;

    //方法一：定义函数指针数组
    float(*f_p_a[4])(float, float, float);
    f_p_a[0] = func_add;
    f_p_a[1] = func_sub;
    f_p_a[2] = func_mul;
    f_p_a[3] = func_div;

    cout << "func_4(方法一) :" << func_4(3, 6, 2.5, f_p_a[0]) << endl;
    cout << "func_4(方法一) :" << func_4(3, 6, 2.5, f_p_a[1]) << endl;
    cout << "func_4(方法一) :" << func_4(3, 6, 2.5, f_p_a[2]) << endl;
    cout << "func_4(方法一) :" << func_4(3, 6, 2.5, f_p_a[3]) << endl << endl;

    //方法二：使用typedef
    typedef float (*f_p_a_type)(float, float, float);
    f_p_a_type ff_pp_aa[4] = {func_add, func_sub, func_mul, func_div};

    cout << "func_4(方法二) :" << func_4(3, 6, 2.5, ff_pp_aa[0]) << endl;
    cout << "func_4(方法二) :" << func_4(3, 6, 2.5, ff_pp_aa[1]) << endl;
    cout << "func_4(方法二) :" << func_4(3, 6, 2.5, ff_pp_aa[2]) << endl;
    cout << "func_4(方法二) :" << func_4(3, 6, 2.5, ff_pp_aa[3]) << endl << endl;

    system("pause");
    return 0;
}

运行结果：