回调函数
参考关于C++ 回调函数(callback) 精简且实用_c++ callback-CSDN博客
回调函数不是在函数的定义上区别于普通函数,而是在调用的方式有区别,因为归根到底,他们都是代码中芸芸众生的普普通通的函数,即“回调函数”的重点在“回调”这两个字。
下图列举了普通函数执行和回调函数调用的区别。
- 对于普通函数,就是按照实现设定的逻辑和顺序执行。
- 对于回调函数,假设Program A和Program B分别有两个人独立开发。回调函数Fun A2它是由Program A定义,但是由Program B调用。Program B只负责取调用Fun A2,但是不管Fun A2函数具体的功能实现。
因为有这样的使用场景,Fun A2只有在 Fun B1调用时才能执行,有点像中断函数的概念。那可能会有人问,在Program A中不断去查询Fun B1的状态,一旦它被执行了,就让Program A自己去执行Fun A2不行吗?
答案是“可以”,但是这样实现的方案不好。因为整个过程中Program A一直都在查询状态,非常耗资源,查询频率高了费CPU,查询频率低了实时性保证不了,Fun B1都执行好久了你才反应过来,Fun A2的执行就会明显晚于Fun B1了。正因为如此,回调函数才登上了舞台。
如何实现函数回调
函数的回调并不复杂,把 Fun A2的函数的地址/指针告诉Program B就可以了。
其实我们在这里要讨论的是在C++中,常用回调函数的类型。
得到函数的地址是其中一个关键步骤。
普通和函数和类的静态成员函数都分配有确定的函数地址,但是类的非静态函数(即普通函数)是类共用的,并不会给类的每一个实例都分配一个独立的成员函数,这样就太浪费存储资源了。所以类的非静态函数作为回调函数是有区别的,也是这篇文章想要讨论的重点。
普通函数作为回调函数
#include <iostream>
void programA_FunA1() { printf("I'am ProgramA_FunA1 and be called..\n"); }
void programA_FunA2() { printf("I'am ProgramA_FunA2 and be called..\n"); }
void programB_FunB1(void (*callback)()) {
printf("I'am programB_FunB1 and be called..\n");
callback();
}
int main(int argc, char **argv) {
programA_FunA1();
programB_FunB1(programA_FunA2);
}
执行结果:
类的静态函数作为回调函数
#include <iostream>
class ProgramA {
public:
void FunA1() {printf("I'am ProgramA.FunA1() and be called..\n"); }
static void FunA2() {printf("I'am ProgramA.FunA2() and be called..\n"); }
};
class ProgramB {
public:
void FunB1(void (*callback)()){
printf("I'am ProgramB.FunB1() and be called..\n");
callback();
}
};
int main(int argc, char **argv) {
ProgramA PA;
PA.FunA1();
ProgramB PB;
PB.FunB1(ProgramA::FunA2);
}
执行结果:
可以看出,以上两种方式没有什么本质的区别。
但这种实现有一个很明显的缺点:static 函数不能访问非static 成员变量或函数,会严重限制回调函数可以实现的功能。
#include <iostream>
#include <functional> // fucntion/bind
class ProgramA {
public:
void FunA1() { printf("I'am ProgramA.FunA1() and be called..\n"); }
void FunA2() { printf("I'am ProgramA.FunA2() and be called..\n"); }
static void FunA3() { printf("I'am ProgramA.FunA3() and be called..\n"); }
};
class ProgramB {
typedef std::function<void ()> CallbackFun;
public:
void FunB1(CallbackFun callback) {
printf("I'am ProgramB.FunB2() and be called..\n");
callback();
}
};
void normFun() { printf("I'am normFun() and be called..\n"); }
int main(int argc, char **argv) {
ProgramA PA;
PA.FunA1();
printf("\n");
ProgramB PB;
PB.FunB1(normFun);
printf("\n");
PB.FunB1(ProgramA::FunA3);
printf("\n");
PB.FunB1(std::bind(&ProgramA::FunA2, &PA));
}
执行结果:
std::funtion支持直接传入函数地址,或者通过std::bind指定。
简而言之,std::funtion是定义函数类型(输入、输出),std::bind是绑定特定的函数(具体的要调用的函数)。
typedef std::function <void(int, int)> func_t;
参考typedef function<int (int,int)> func_t;-CSDN博客
这段代码是C++中用于创建函数类型别名(function type alias)的语法。让我们来逐步解释它:
typedef: typedef 是C++中的关键字,用于创建类型别名。它允许你为一个已存在的类型创建一个新的、易于使用的名称。
function: 这部分指定了要创建的类型别名的名称。在这里将创建一个名为 func1的类型别名。
<int(int,int)>: 这部分定义了 func1类型别名所代表的函数类型的签名。具体来说,它是一个接受两个int参数并返回一个int的函数类型。如果这里是<void(int, string)>,则表明它是一个接受int和string类型参数并且返回void的函数类型
综合起来,typedef std::function <int(int, int)> func_t; 创建了一个名为 func_t的类型别名,该别名表示一个接受两个整数参数并返回一个 int 的函数类型。这个别名可以在代码中用来声明和使用函数指针或者函数对象,从而使代码更具可读性和灵活性。例如:
fun_t myFunction; // 声明一个函数类型别名的变量
int result = myFunction(5, 10); // 调用函数类型别名代表的函数
myFunction 是一个函数类型别名的变量,可以用来调用一个接受两个整数参数并返回一个整数的函数。
function包装器
function包装器是一种函数包装器,也叫做适配器。它可以对可调用对象进行包装,C++中的function本质就是一个类模板。
function包装器可以对可调用对象进行包装,包括函数指针(函数名)、仿函数(函数对象)、lambda表达式、类的成员函数。
int f(int a, int b){return a + b;}
struct Functor{
public:
int operator()(int a, int b){return a + b;}
};
class Plus{
public:
static int plusi(int a, int b){return a + b;}
double plusd(double a, double b){return a + b;}
};
int main(){
// 1、包装函数指针(函数名)
function<int(int, int)> func1 = f;
cout << func1(1, 2) << endl;
// 2、包装仿函数(函数对象)
function<int(int, int)> func2 = Functor();
cout << func2(1, 2) << endl;
// 3、包装lambda表达式
function<int(int, int)> func3 = [](int a, int b) {return a + b; };
cout << func3(1, 2) << endl;
// 4、包装静态成员函数
function<int(int, int)> func4 = &Plus::plusi; // &可省略
cout << func4(1, 2) << endl;
// 5、包装类的非静态成员函数
function<double(Plus, double, double)> func5 = &Plus::plusd; // &不可省略
cout << func5(Plus(), 1.1, 2.2) << endl;
return 0;
}
- 包装时指明返回值类型和各形参类型,然后可调用对象赋值给function包装器即可,包装后function对象就可以像普通函数一样使用了。
- 取静态成员函数的地址可以不用取地址运算符 & ,但取非静态成员函数地址使用 & 。
- 包装费静态的成员函数需要注意,非静态成员函数的第一个参数是隐藏this指针,因此在包装时需要指明第一个形参的类型为类的类型。
bind()函数
头文件:#include <functional>
使用形式:bind(callable, arg_list);
callable是需要绑定的函数或函数指针(函数体,仿函数等)
arg_list是一个逗号分隔的参数列表,依次代表需要填入callable的参数
arg_list可以是占位符_1,_2,...,_n,或者实际参数。
占位符表示新生成的可调用对象newCallable的形参。
bind函数的返回值是一个可调用对象,可以通过调用该对象来执行绑定的函数。
#include <iostream>
#include <functional>
using namespace std;
using namespace std::placeholders;
void print(int a, int b, int c) {
cout << a << " " << b << " " << c << endl;
}
int main() {
function<void(int, int, int)> f1 = bind(print, _1, _2, _3);
f1(1, 2, 3); // 输出:1 2 3
function<void(int, int, int)> f2 = bind(print, _2, _1, 100);
f2(1, 2); // 输出:2 1 100
auto f3 = bind(print, _3, 100, _2);
f3(50, 44, 23); // 输出:23 100 44
return 0;
}
f1绑定了三个占位符,表示需要传入三个参数;f2绑定了两个占位符和一个常量100,表示需要传入两个参数,其中第一个参数在print函数中对应第二个参数,第二个参数在print函数中对应第一个参数,第三个参数固定为100;f3绑定了三个占位符和一个常量100,表示需要传入三个参数,其中第二个参数固定为100,第二个参数在print函数中对应第三个参数,第三个参数在print函数中对应第一个参数。最后,通过调用可调用对象来执行绑定的函数,输出了相应的结果。
std::placeholders
placeholders是 C++ 标准库中的一个命名空间,它包含了一组特殊的占位符对象,用于与 bind 函数一起使用。这些占位符对象允许你在绑定函数时表示某些参数是未指定的,并在稍后提供这些参数的值。
placeholders 中有以下占位符:
placeholders::_1:表示第一个未指定的参数。
placeholders::_2:表示第二个未指定的参数。
…
placeholders::_N:表示第 N 个未指定的参数。
通过在 bind 函数中使用这些占位符,你可以创建一个可调用的对象,该对象在调用时将使用后续提供的参数。这在很多情况下都很有用,例如当你需要在多个线程中异步调用函数,或者当你需要将函数的部分参数绑定在一起时。