包装器function
std::function模板类是一个通用的可调用对象的包装器，用简单的、统一的方式处理可调用对象。
template
class function……
_Fty是可调用对象的类型，格式：返回类型(参数列表)。
包含头文件：#include
注意：
重载了bool运算符，用于判断是否包装了可调用对象。
如果std::function对象未包装可调用对象，使用std::function对象将抛出std::bad_function_call异常。
示例：
#include
#include
using namespace std;
// 普通函数
void show(int bh, const string& message) {
cout << "亲爱的" << bh << "，" << message << endl;
}
struct AA // 类中有静态成员函数。
{
static void show(int bh, const string& message) {
cout << "亲爱的" << bh << "，" << message << endl;
}
};
struct BB // 仿函数。
{
void operator()(int bh, const string& message) {
cout << "亲爱的" << bh << "，" << message << endl;
}
};
struct CC // 类中有普通成员函数。
{
void show(int bh, const string& message) {
cout << "亲爱的" << bh << "，" << message << endl;
}
};
struct DD // 可以被转换为普通函数指针的类。
{
using Fun = void (*)(int, const string&); // 函数指针的别名。
operator Fun() {
return show; // 返回普通函数show的地址。
}
};
int main()
{
using Fun = void(int, const string&); // 函数类型的别名。
// 普通函数。
void(*fp1)(int, const string&) = show; // 声明函数指针，指向函数对象。
fp1(1, "我是一只傻傻鸟。"); // 用函数指针调用普通函数。
function fn1 = show; // 包装普通全局函数show。
fn1(1, "我是一只傻傻鸟。"); // 用function对象调用普通全局函数show。
// 类的静态成员函数。
void(*fp3)(int, const string&) = AA::show; // 用函数指针指向类的静态成员函数。
fp3(2, "我是一只傻傻鸟。"); // 用函数指针调用类的静态成员函数。
function fn3 = AA::show; // 包装类的静态成员函数。
fn3(2, "我是一只傻傻鸟。"); // 用function对象调用类的静态成员函数。
// 仿函数。
BB bb;
bb(3, "我是一只傻傻鸟。"); // 用仿函数对象调用仿函数。
function fn4 = BB(); // 包装仿函数。
fn4(3, "我是一只傻傻鸟。"); // 用function对象调用仿函数。
// 创建lambda对象。
auto lb = [](int bh, const string& message) {
cout << "亲爱的" << bh << "，" << message << endl;
};
lb(4, "我是一只傻傻鸟。"); // 调用lambda函数。
function fn5 = lb; // 包装lamba函数。
fn5(4, "我是一只傻傻鸟。"); // 用function对象调用lamba函数。
// 类的非静态成员函数。
CC cc;
void (CC:: * fp11)(int, const string&) = &CC::show; // 定义类成员函数的指针。
(cc.*fp11)(5, "我是一只傻傻鸟。"); // 用类成员函数的指针调用类的成员函数。
function fn11 = &CC::show; // 包装成员函数。
fn11(cc,5, "我是一只傻傻鸟。"); // 用function对象调用成员函数。
// 可以被转换为函数指针的类对象。
DD dd;
dd(6, "我是一只傻傻鸟。"); // 用可以被转换为函数指针的类对象调用普通函数。
function fn12 = dd; // 包装可以被转换为函数指针的类。
fn12(6, "我是一只傻傻鸟。"); // 用function对象调用它。
function fx=dd;
try {
if (fx) fx(6, "我是一只傻傻鸟。");
}
catch (std::bad_function_call e) {
cout << "抛出了std::bad_function_call异常。";
}
}
std::bind()模板函数是一个通用的函数适配器（绑定器），它用一个可调用对象及其参数，生成一个新的可调用对象，以适应模板。
包含头文件：#include
函数原型：
template< class Fx, class... Args >
function<> bind (Fx&& fx, Args&...args);
Fx：需要绑定的可调用对象（可以是前两节课介绍的那六种，也可以是function对象）。
args：绑定参数列表，可以是左值、右值和参数占位符std::placeholders::_n，如果参数不是占位符，缺省为值传递，std:: ref(参数)则为引用传递。
std::bind()返回std::function的对象。
std::bind()的本质是仿函数。
示例一（bind的基本用法）：
#include
#include
using namespace std;
// 普通函数
void show(int bh, const string& message) {
cout << "亲爱的" << bh << "号，" << message << endl;
}
int main()
{
function fn1 = show;
function fn2 = bind(show, placeholders::_1, placeholders::_2);
fn1(1, "我是一只傻傻鸟。");
fn2(1, "我是一只傻傻鸟。");
function fn3 = bind(show, placeholders::_2, placeholders::_1);
fn3("我是一只傻傻鸟。", 1);
function fn4 = bind(show, 3, placeholders::_1);
fn4("我是一只傻傻鸟。");
function fn5 = bind(show, placeholders::_1, placeholders::_2);
fn5(1, "我是一只傻傻鸟。", 88);
}
示例二（绑定六种可调用对象）：
#include
#include
using namespace std;
// 普通函数
void show(int bh, const string& message) {
cout << "亲爱的" << bh << "，" << message << endl;
}
struct AA // 类中有静态成员函数。
{
static void show(int bh, const string& message) {
cout << "亲爱的" << bh << "，" << message << endl;
}
};
struct BB // 仿函数。
{
void operator()(int bh, const string& message) {
cout << "亲爱的" << bh << "，" << message << endl;
}
};
struct CC // 类中有普通成员函数。
{
void show(int bh, const string& message) {
cout << "亲爱的" << bh << "，" << message << endl;
}
};
struct DD // 可以被转换为普通函数指针的类。
{
using Fun = void (*)(int, const string&); // 函数指针的别名。
operator Fun() {
return show; // 返回普通函数show的地址。
}
};
int main()
{
// 普通函数。
function fn1 = bind(show, placeholders::_1, placeholders::_2); // 绑定普通全局函数show。
fn1(1, "我是一只傻傻鸟。"); // 用function对象调用普通全局函数show。
// 类的静态成员函数。
function fn3 = bind(AA::show, placeholders::_1, placeholders::_2); // 绑定类的静态成员函数。
fn3(2, "我是一只傻傻鸟。"); // 用function对象调用类的静态成员函数。
// 仿函数。
function fn4 = bind(BB(), placeholders::_1, placeholders::_2); // 绑定仿函数。
fn4(3, "我是一只傻傻鸟。"); // 用function对象调用仿函数。
// 创建lambda对象。
auto lb = [](int bh, const string& message) {
cout << "亲爱的" << bh << "，" << message << endl;
};
function fn5 = bind(lb, placeholders::_1, placeholders::_2); // 绑定lamba函数。
fn5(4, "我是一只傻傻鸟。"); // 用function对象调用lamba函数。
// 类的非静态成员函数。
CC cc;
//function fn11 = bind(&CC::show, placeholders::_1, placeholders::_2, placeholders::_3); // 绑定成员函数。
//fn11(cc, 5, "我是一只傻傻鸟。"); // 用function对象调用成员函数。
function fn11 = bind(&CC::show,&cc,placeholders::_1, placeholders::_2); // 绑定成员函数。
fn11(5, "我是一只傻傻鸟。"); // 用function对象调用成员函数。
// 可以被转换为函数指针的类对象。
DD dd;
function fn12 = bind(dd, placeholders::_1, placeholders::_2); // 绑定可以被转换为函数指针的类。
fn12(6, "我是一只傻傻鸟。"); // 用function对象调用它。
}
写一个函数，函数的参数是函数对象及参数，功能和thread类的构造函数相同。
示例：
#include
#include
#include
using namespace std;
void show0() { // 普通函数。
cout << "亲爱的，我是一只傻傻鸟。\n";
}
void show1(const string& message) { // 普通函数。
cout << "亲爱的，" << message << endl;
}
struct CC // 类中有普通成员函数。
{
void show2(int bh, const string& message) {
cout << "亲爱的" << bh << "号，" << message << endl;
}
};
template
auto show(Fn&& fn, Args&&...args) -> decltype(bind(forward(fn), forward(args)...))
{
cout << "表白前的准备工作......\n";
auto f = bind(forward(fn), forward(args)...);
f();
cout << "表白完成。\n";
return f;
}
int main()
{
show(show0);
show(show1,"我是一只傻傻鸟。");
CC cc;
auto f = show(&CC::show2,&cc, 3,"我是一只傻傻鸟。");
f();
//thread t1(show0);
//thread t2(show1,"我是一只傻傻鸟。");
//CC cc;
//thread t3(&CC::show2,&cc, 3,"我是一只傻傻鸟。");
//t1.join();
//t2.join();
//t3.join();
}
在消息队列和网络库的框架中，当接收到消息（报文）时，回调用户自定义的函数对象，把消息（报文）参数传给它，由它决定如何处理。
示例：
#include
#include
#include // 线程类头文件。
#include // 互斥锁类的头文件。
#include // deque容器的头文件。
#include // queue容器的头文件。
#include // 条件变量的头文件。
#include
using namespace std;
void show(const string& message) { // 处理业务的普通函数
cout << "处理数据：" << message << endl;
}
struct BB { // 处理业务的类
void show(const string& message) {
cout << "处理表白数据：" << message << endl;
}
};
class AA
{
mutex m_mutex; // 互斥锁。
condition_variable m_cond; // 条件变量。
queue> m_q; // 缓存队列，底层容器用deque。
function m_callback; // 回调函数对象。
public:
// 注册回调函数，回调函数只有一个参数（消费者接收到的数据）。
template
void callback(Fn && fn, Args&&...args) {
m_callback = bind(forward(fn), forward(args)..., std::placeholders::_1); // 绑定回调函数。
}
void incache(int num) // 生产数据，num指定数据的个数。
{
lock_guard lock(m_mutex); // 申请加锁。
for (int ii = 0; ii < num; ii++)
{
static int bh = 1; // 超女编号。
string message = to_string(bh++) + "号超女"; // 拼接出一个数据。
m_q.push(message); // 把生产出来的数据入队。
}
//m_cond.notify_one(); // 唤醒一个被当前条件变量阻塞的线程。
m_cond.notify_all(); // 唤醒全部被当前条件变量阻塞的线程。
}
void outcache() { // 消费者线程任务函数。
while (true) {
// 把互斥锁转换成unique_lock，并申请加锁。
unique_lock lock(m_mutex);
// 1）把互斥锁解开；2）阻塞，等待被唤醒；3）给互斥锁加锁。
m_cond.wait(lock, [this] { return !m_q.empty(); });
// 数据元素出队。
string message = m_q.front(); m_q.pop();
cout << "线程：" << this_thread::get_id() << "，" << message << endl;
lock.unlock(); // 手工解锁。
// 处理出队的数据（把数据消费掉）。
if (m_callback) m_callback(message); // 回调函数，把收到的数据传给它。
}
}
};
int main()
{
AA aa;
// aa.callback(show); // 把普通函数show()注册为回调函数。
BB bb;
aa.callback(&BB::show, &bb); // 把类成员函数BB::show()注册为回调函数。
thread t1(&AA::outcache, &aa); // 创建消费者线程t1。
thread t2(&AA::outcache, &aa); // 创建消费者线程t2。
thread t3(&AA::outcache, &aa); // 创建消费者线程t3。
this_thread::sleep_for(chrono::seconds(2)); // 休眠2秒。
aa.incache(2); // 生产2个数据。
this_thread::sleep_for(chrono::seconds(3)); // 休眠3秒。
aa.incache(5); // 生产5个数据。
t1.join(); // 回收子线程的资源。
t2.join();
t3.join();
}
C++虚函数在执行过程中会跳转两次（先查找对象的函数表，再次通过该函数表中的地址找到真正的执行地址），这样的话，CPU会跳转两次，而普通函数只跳转一次。
CPU每跳转一次，预取指令要作废很多，所以效率会很低。（百度）
为了管理的方便（基类指针可指向派生类对象和自动析构派生类），保留类之间的继承关系。
示例：
#include // 包含头文件。
#include
using namespace std;
struct Hero { // 英雄基类
//virtual void show() { cout << "英雄释放了技能。\n"; }
function m_callback; // 用于绑定子类的成员函数。
// 注册子类成员函数，子类成员函数没有参数。
template
void callback(Fn&& fn, Args&&...args) {
m_callback = bind(forward(fn), forward(args)...);
}
void show() { m_callback(); } // 调用子类的成员函数。
};
struct XS :public Hero { // 西施派生类
void show() { cout << "西施释放了技能。\n"; }
};
struct HX :public Hero { // 韩信派生类
void show() { cout << "韩信释放了技能。\n"; }
};
int main()
{
// 根据用户选择的英雄，施展技能。
int id = 0; // 英雄的id。
cout << "请输入英雄（1-西施；2-韩信。）：";
cin >> id;
// 创建基类指针，将指向派生类对象，用基类指针调用派生类的成员函数。
Hero* ptr = nullptr;
if (id == 1) { // 1-西施
ptr = new XS;
ptr->callback(&XS::show, static_cast(ptr)); // 注册子类成员函数。
}
else if (id == 2) { // 2-韩信
ptr = new HX;
ptr->callback(&HX::show, static_cast(ptr)); // 注册子类成员函数。
}
if (ptr != nullptr) {
ptr->show(); // 调用子类的成员函数。
delete ptr; // 释放派生类对象。
}
}