typedef std::function与bind，placeholder

Pfirsich Zhang

已于 2024-08-26 11:23:37 修改

阅读量323

点赞数 10

分类专栏： C++ 语法特性文章标签：算法 c++

于 2024-08-19 16:29:32 首次发布

本文链接：https://blog.csdn.net/weixin_47755728/article/details/141328777

版权

C++ 语法特性专栏收录该内容

30 篇文章 0 订阅

订阅专栏

回调函数

参考关于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 函数中使用这些占位符，你可以创建一个可调用的对象，该对象在调用时将使用后续提供的参数。这在很多情况下都很有用，例如当你需要在多个线程中异步调用函数，或者当你需要将函数的部分参数绑定在一起时。