functional

std::bind

原型：

template< class R, class F, class... Args >
constexpr /* 未指定 */ bind( F&& f, Args&&... args );

函数模板 std::bind 生成 f 的转发调用包装器。调用此包装器等价于以一些绑定到 args 的参数调用 f

• f — 可调用 (Callable) 对象（函数对象、指向函数指针、到函数引用、指向成员函数指针或指向数据成员指针）
• args ---- 要绑定的参数列表，未绑定参数会被命名空间 std::placeholders 的占位符 _1,_2, _3… 替换

使用示例

#include <functional>
#include <iostream>
#include <memory>
#include <random>void f(int n1, int n2, int n3, const int& n4, int n5)
{std::cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << n4 << ' ' << n5 << '\n';
}int g(int n1)
{return n1;
}struct Foo
{void print_sum(int n1, int n2){std::cout << n1 + n2 << '\n';}int data = 10;
};int main()
{using namespace std::placeholders;  // 对于 _1, _2, _3...std::cout << "参数重排序和按引用传递：";int n = 7;// （ _1 与 _2 来自 std::placeholders ，并表示将来会传递给 f1 的参数）//std::cref返回需要被包装的到对象的左值引用，返回后面n的值auto f1 = std::bind(f, _2, 42, _1, std::cref(n), n);n = 10;f1(1, 2, 1001); // 1 为 _1 所绑定， 2 为 _2 所绑定，不使用 1001// 进行到 f(2, 42, 1, n, 7) 的调用std::cout << "嵌套 bind 子表达式共享占位符：";auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5);f2(10, 11, 12); // 进行到 f(12, g(12), 12, 4, 5); 的调用std::cout << "绑定指向成员函数指针：";Foo foo;auto f3 = std::bind(&Foo::print_sum, &foo, 95, _1);f3(5);std::cout << "绑定是指向成员函数指针的 mem_fn：";auto ptr_to_print_sum = std::mem_fn(&Foo::print_sum);auto f4 = std::bind(ptr_to_print_sum, &foo, 95, _1);f4(5);std::cout << "绑定指向数据成员指针：";auto f5 = std::bind(&Foo::data, _1);std::cout << f5(foo) << '\n';std::cout << "绑定是指向数据成员指针的 mem_fn：";auto ptr_to_data = std::mem_fn(&Foo::data);auto f6 = std::bind(ptr_to_data, _1);std::cout << f6(foo) << '\n';std::cout << "使用智能指针调用被引用对象的成员：";std::cout << f6(std::make_shared<Foo>(foo)) << '\n'<< f6(std::make_unique<Foo>(foo)) << '\n';
}

输出:

参数重排序和按引用传递：2 42 1 10 7
嵌套 bind 子表达式共享占位符：12 12 12 4 5
绑定指向成员函数指针：100
绑定是指向成员函数指针的 mem_fn：100
绑定指向数据成员指针：10
绑定是指向数据成员指针的 mem_fn：10
使用智能指针调用被引用对象的成员：10
10

std::function

类模板 std::function 是通用多态函数包装器。 std::function 的实例能存储、复制及调用任何可复制构造的可调用目标——函数（通过其指针）、 lambda 表达式、 bind 表达式或其他函数对象，还有指向成员函数指针和指向数据成员指针。

存储的可调用对象被称为 std::function 的目标。若 std::function 不含目标，则称它为空。调用空 std::function 的目标导致抛出 std::bad_function_call 异常。

• 实际上时对函数指针的优化

typedef  void（*ptr）（int，int）// 这里的ptr就是一个函数指针|||V
std::function<void(int ,int)> func;

• 头文件

#include <functional>

类模板

template< class R, class... Args >
class function<R(Args...)>;

• R: 被调用函数的返回类型
• Args…：被调用函数的形参

成员函数

• 构造函数

从各种资源构造 std::function

• 析构函数

销毁 std::function 对象。若 std::function 非空，则亦销毁其目标。

• operator=

赋值新目标给 std::function 。

1. 赋值 other 的目标副本，如同以执行 function(other).swap(*this);
2. 移动 other 的目标到 *this 。 other 在有未指定值的合法状态。
3. 舍弃当前目标。 *this 在调用后为空。

template< class F >
function& operator=( std::reference_wrapper<F> f ) noexcept;

• swap

交换 *this 与 other 存储的可调用对象。

• operator bool

检查是否包含了有效的目标

• operator()

调用其目标

• target_type

返回存储的函数的类型。

• target

返回指向存储的可调用函数目标的指针。

使用

#include <functional>
#include <iostream>struct Foo {Foo(int num) : num_(num) {}void print_add(int i) const { std::cout << num_+i << '\n'; }int num_;
};void print_num(int i)
{std::cout << i << '\n';
}struct PrintNum {void operator()(int i) const{std::cout << i << '\n';}
};int main()
{// 存储自由函数std::function<void(int)> f_display = print_num;f_display(-9);//-9// 存储 lambdastd::function<void()> f_display_42 = []() { print_num(42); };f_display_42();//42// 存储到 std::bind 调用的结果std::function<void()> f_display_31337 = std::bind(print_num, 31337);f_display_31337();//31337// 存储到成员函数的调用std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;const Foo foo(314159);//创建FOO对象f_add_display(foo, 1);//314160f_add_display(314159, 1);//314160// 存储到数据成员访问器的调用std::function<int(Foo const&)> f_num = &Foo::num_;std::cout << "num_: " << f_num(foo) << '\n'; //num_: 314159// 存储到成员函数及对象的调用using std::placeholders::_1;std::function<void(int)> f_add_display2 = std::bind( &Foo::print_add, foo, _1 );f_add_display2(2);//314161// 存储到成员函数和对象指针的调用std::function<void(int)> f_add_display3 = std::bind( &Foo::print_add, &foo, _1 );f_add_display3(3);//314162// 存储到函数对象(仿函数)的调用std::function<void(int)> f_display_obj = PrintNum();f_display_obj(18);//18//递归使用std::function<int(int)> factorial = [&](int i) -> int{if(i == 1)return 1;return i * factorial(i - 1);};for (int i{5}; i != 8; ++i) { std::cout << i << "! = " << factorial(i) << ";  "; }
}

其他：

#include <functional>
#include <iostream>
#include <string>int f(int, int) { return 1; }
int g(int, int) { return 2; }void test(std::function<int(int, int)> const& arg)
{int (*const* ptr)(int, int) = arg.target<int(*)(int, int)>();if (ptr && *ptr == f)std::cout << "it is the function f\n";if (ptr && *ptr == g)std::cout << "it is the function g\n";
}int main()
{test(std::function<int(int, int)>(f));test(std::function<int(int, int)>(g));std::function<int(int,int)> fn1(f),fn2([](int a , int b) {return a+b;});std::cout << fn1.target_type().name() << '\n'<< fn2.target_type().name() << '\n';
}

输出结果：

it is the function f
it is the function g
PFiiiE
Z4mainEUliiE_

推导指引(C++17 起)

#include <functional>
int func(double) { return 0; }
int main() {std::function f{func}; // 指引 #1 推导 function<int(double)>int i = 5;std::function g = [&](double) { return i; }; // 指引 #2 推导 function<int(double)>
}

---