C++11新特性之可调用对象包装器和绑定器

一、可调用对象

C++中可调用对象有六种.

1.普通函数

普通函数类型可以声明函数,定义函数指针和引用,但是不能定义函数的实体.

using Fun = void (int, const string&);  // 普通函数类型的别名。
Fun show;        // 声明普通函数。int main()
{show(1, "我是一只傻傻鸟。");                 // 直接调用普通函数。void(*fp1)(int, const string&) = show; // 声明函数指针，指向普通函数。void(&fr1)(int, const string&) = show; // 声明函数引用，引用普通函数。fp1(2, "我是一只傻傻鸟。");                       // 用函数指针调用普通函数。fr1(3, "我是一只傻傻鸟。");                        // 用函数引用调用普通函数。Fun* fp2 = show;                                        // 声明函数指针，指向普通函数。Fun& fr2 = show;                                   // 声明函数引用，引用普通函数。fp2(4, "我是一只傻傻鸟。");                       // 用函数指针调用普通函数。fr2(5, "我是一只傻傻鸟。");                        // 用函数引用调用普通函数。
}// 定义普通函数
void show(int bh, const string& message) {  cout << "亲爱的" << bh << "，" << message << endl;
}// 以下代码是错误的，不能用函数类型定义函数的实体。
//Func show1 {
//  cout << "亲爱的" << bh << "，" << message << endl;
//}

2.类的静态成员函数

using Fun = void (int, const string&);  // 普通函数类型的别名。struct AA  // 类中有静态成员函数。
{static void show(int bh, const string& message) {cout << "亲爱的" << bh << "，" << message << endl;}
};int main()
{AA::show(1, "我是一只傻傻鸟。");                 // 直接调用静态成员函数。void(*fp1)(int, const string&) = AA::show;   // 用函数指针指向静态成员函数。void(&fr1)(int, const string&) = AA::show;    // 引用静态成员函数。fp1(2, "我是一只傻傻鸟。");                       // 用函数指针调用静态成员函数。fr1(3, "我是一只傻傻鸟。");                      // 用函数引用调用静态成员函数。Fun* fp2 = AA::show;                                      // 用函数指针指向静态成员函数。Fun& fr2 = AA::show;                                  // 引用静态成员函数。fp2(4, "我是一只傻傻鸟。");                       // 用函数指针调用静态成员函数。fr2(5, "我是一只傻傻鸟。");                      // 用函数引用调用静态成员函数。
}

3.仿函数

struct BB    // 仿函数。
{void operator()(int bh, const string& message) {cout << "亲爱的" << bh << "，" << message << endl;}
};int main()
{BB bb;bb(11, "我是一只傻傻鸟。");        // 用对象调用仿函数。BB()(12, "我是一只傻傻鸟。");     // 用匿名对象调用仿函数。BB& br = bb;                 // 引用函数br(13, "我是一只傻傻鸟。");        // 用对象的引用调用仿函数。
}

4.lambda函数

lambda函数的本质是仿函数,所以用理解仿函数的方式去理解他就行.

int main()
{// 创建lambda对象。auto lb = [](int bh, const string& message) {cout << "亲爱的" << bh << "，" << message << endl;};auto& lr = lb;  // 引用lambda对象。lb(1, "我是一只傻傻鸟。");       // 用lambda对象调用仿函数。lr(2, "我是一只傻傻鸟。");      // 用lambda对象的引用调用仿函数。
}

5.类的非静态成员函数

类的非静态成员函数有地址，但是，只能通过类的对象才能调用它，所以，C++对它做了特别处理。

类的非静态成员函数只有指针类型，没有引用类型，不能引用。

struct CC    // 类中有普通成员函数。
{void show(int bh, const string& message) {cout << "亲爱的" << bh << "，" << message << endl;}
};int main()
{CC cc;cc.show(14, "我是一只傻傻鸟。");void (CC::* fp11)(int, const string&) = &CC::show;        // 定义类的成员函数的指针。注意:取地址符号不能省,而普通函数可以(cc.*fp11)(15, "我是一只傻傻鸟。");                                 // 用类的成员函数的指针调用成员函数。using pFun = void (CC::*)(int, const string&);     // 类成员函数的指针类型。pFun fp12 = &CC::show;                                       // 让类成员函数的指针指向类的成员函数的地址。(cc.*fp12)(16, "我是一只傻傻鸟。");                           // 用类成员函数的指针调用类的成员函数。
}

6.可被转换为函数指针的类对象

类可以重载类型转换运算符operator 数据类型() ，如果数据类型是函数指针或函数引用类型，那么该类实例也将成为可调用对象。

它的本质是类，调用的代码像函数。

在实际开发中，意义不大。

// 定义函数
void show(int bh, const string& message) {cout << "亲爱的" << bh << "，" << message << endl;
}struct DD      // 可以被转换为函数指针的类。
{using Fun = void (*)(int, const string&);operator Fun() {return show; // 返回普通函数。}
};int main()
{DD dd;dd(17, "我是一只傻傻鸟。");                        // 可以被转换为函数指针的类对象。
}

二、包装器function

std::function模板类是一个通用的可调用对象的包装器，用简单的、统一的方式处理可调用对象。

template<class _Fty>

class function……

_Fty是可调用对象的类型，格式：返回类型(参数列表)。

包含头文件：#include <functional>

1.包装普通函数

// 普通函数
void show(int bh, const string& message) {cout << "亲爱的" << bh << "，" << message << endl;
}
int main()
{using Fun = void(int, const string&);  // 函数类型的别名。// 普通函数。void(*fp1)(int, const string&) = show; // 声明函数指针，指向函数对象。fp1(1, "我是一只傻傻鸟。");                       // 用函数指针调用普通函数。function<void(int, const string&)> fn1 = show;    // 包装普通全局函数show。fn1(1, "我是一只傻傻鸟。");                                       // 用function对象调用普通全局函数show。
}

2.包装类的静态成员函数

struct AA    // 类中有静态成员函数。
{static void show(int bh, const string& message) {cout << "亲爱的" << bh << "，" << message << endl;}
};
int main()
{// 类的静态成员函数。void(*fp3)(int, const string&) = AA::show;    // 用函数指针指向类的静态成员函数。fp3(2, "我是一只傻傻鸟。");                            // 用函数指针调用类的静态成员函数。function<void(int, const string&)> fn3 = AA::show;        // 包装类的静态成员函数。fn3(2, "我是一只傻傻鸟。");                                             // 用function对象调用类的静态成员函数。
}

3.包装仿函数

struct BB    // 仿函数。
{void operator()(int bh, const string& message) {cout << "亲爱的" << bh << "，" << message << endl;
};
int main()
{// 仿函数。BB bb;bb(3, "我是一只傻傻鸟。");      // 用仿函数对象调用仿函数。function<void(int, const string&)> fn4 = BB();        // 包装仿函数。fn4(3, "我是一只傻傻鸟。");                                      // 用function对象调用仿函数。
}

4.包装lambda函数

int main()
{
// 创建lambda对象。auto lb = [](int bh, const string& message) {cout << "亲爱的" << bh << "，" << message << endl;};lb(4, "我是一只傻傻鸟。");          // 调用lambda函数。function<void(int, const string&)> fn5 = lb;            // 包装lamba函数。fn5(4, "我是一只傻傻鸟。");                                      // 用function对象调用lamba函数。
}

5.包装类的非静态成员函数

非静态成员函数包装时第一个参数要是类名,调用时传对象名.

struct CC    // 类中有普通成员函数。
{void show(int bh, const string& message) {cout << "亲爱的" << bh << "，" << message << endl;}
};
int main()
{// 类的非静态成员函数。CC cc;void (CC:: * fp11)(int, const string&) = &CC::show;        // 定义类成员函数的指针。(cc.*fp11)(5, "我是一只傻傻鸟。");                                  // 用类成员函数的指针调用类的成员函数。function<void(CC&,int, const string&)> fn11 = &CC::show;    // 包装成员函数。fn11(cc,5, "我是一只傻傻鸟。");                                         // 用function对象调用成员函数。
}

6.可被转换为函数指针的类

struct DD        // 可以被转换为普通函数指针的类。
{using Fun = void (*)(int, const string&);    // 函数指针的别名。operator Fun() {return show;  // 返回普通函数show的地址。}
};
int main()
{// 可以被转换为函数指针的类对象。DD dd;dd(6, "我是一只傻傻鸟。");                       // 用可以被转换为函数指针的类对象调用普通函数。function<void(int, const string&)> fn12 = dd;           // 包装可以被转换为函数指针的类。fn12(6, "我是一只傻傻鸟。");                                        // 用function对象调用它。
}

7.异常

重载了bool运算符，用于判断是否包装了可调用对象。
如果std::function对象未包装可调用对象，使用std::function对象将抛出std::bad_function_call异常.

int main()
{function<void(int, const string&)> fx=dd;try {fx(6, "我是一只傻傻鸟。");}catch (std::bad_function_call e) {cout << "抛出了std::bad_function_call异常。";}
}

三、绑定器bind()

std::bind()模板函数是一个通用的函数适配器（绑定器），它用一个可调用对象及其参数，生成一个新的可调用对象，以适应模板。

包含头文件：#include <functional>

函数原型：

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()的本质是仿函数。

1.bind()的基本用法

// 普通函数
void show(int bh, const string& message) {cout << "亲爱的" << bh << "号，" << message << endl;
}int main()
{function<void(int, const string&)> fn1 = show;function<void(int, const string&)> fn2 = bind(show, placeholders::_1, placeholders::_2);fn1(1, "我是一只傻傻鸟。");fn2(1, "我是一只傻傻鸟。");//参数调换位置function<void(const string&, int)> fn3 = bind(show, placeholders::_2, placeholders::_1);fn3("我是一只傻傻鸟。", 1);//参数提前绑定int bh = 3;function<void(const string&)> fn4 = bind(show, bh, placeholders::_1);//或是引用传递 function<void(const string&)> fn4 = bind(show, std::ref(3), placeholders::_1);fn4("我是一只傻傻鸟。");//需要的参数比show多,用以下方法,第三个参数随便填function<void(int, const string&,int)> fn5 = bind(show, placeholders::_1, placeholders::_2);fn5(1, "我是一只傻傻鸟。", 88);
}

2.用bind来绑定六种可调用对象

重点是类的非静态成员函数,将对象提前绑定,使形式达到统一,可以用于模板.

// 普通函数
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<void(int, const string&)> fn1 = bind(show, placeholders::_1, placeholders::_2);    // 绑定普通全局函数show。fn1(1, "我是一只傻傻鸟。");                                       // 用function对象调用普通全局函数show。// 类的静态成员函数。function<void(int, const string&)> fn3 = bind(AA::show, placeholders::_1, placeholders::_2);      // 绑定类的静态成员函数。fn3(2, "我是一只傻傻鸟。");                                             // 用function对象调用类的静态成员函数。// 仿函数。function<void(int, const string&)> fn4 = bind(BB(), placeholders::_1, placeholders::_2);         // 绑定仿函数。fn4(3, "我是一只傻傻鸟。");                                      // 用function对象调用仿函数。// 创建lambda对象。auto lb = [](int bh, const string& message) {cout << "亲爱的" << bh << "，" << message << endl;};function<void(int, const string&)> fn5 = bind(lb, placeholders::_1, placeholders::_2);          // 绑定lamba函数。fn5(4, "我是一只傻傻鸟。");                                      // 用function对象调用lamba函数。// 类的非静态成员函数。CC cc;//function<void(CC&, int, const string&)> fn11 = bind(&CC::show, placeholders::_1, placeholders::_2, placeholders::_3);       // 绑定成员函数。//fn11(cc, 5, "我是一只傻傻鸟。");                                          // 用function对象调用成员函数。function<void(int, const string&)> fn11 = bind(&CC::show,&cc,placeholders::_1, placeholders::_2);       // 绑定成员函数。fn11(5, "我是一只傻傻鸟。");                                            // 用function对象调用成员函数。// 可以被转换为函数指针的类对象。DD dd;function<void(int, const string&)> fn12 = bind(dd, placeholders::_1, placeholders::_2);         // 绑定可以被转换为函数指针的类。fn12(6, "我是一只傻傻鸟。");                                        // 用function对象调用它。
}

四、三种应用场景

1.可变参数函数

写一个函数，函数的参数是函数对象及参数，功能和thread类的构造函数相同。

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<typename Fn, typename...Args>
auto show(Fn&& fn, Args&&...args) -> decltype(bind(forward<Fn>(fn), forward<Args>(args)...))
{cout << "准备工作......\n";auto f = bind(forward<Fn>(fn), forward<Args>(args)...);f();cout << "完成。\n";return f;
}int main()
{show(show0);show(show1,"我是一只傻傻鸟。");CC cc;auto f = show(&CC::show2,&cc, 3,"我是一只傻傻鸟。");f();
}

2.回调函数

在消息队列和网络库的框架中，当接收到消息（报文）时，回调用户自定义的函数对象，把消息（报文）参数传给它，由它决定如何处理。

#include <iostream>
#include <string>
#include <thread>                      // 线程类头文件。
#include <mutex>                      // 互斥锁类的头文件。
#include <deque>                      // deque容器的头文件。
#include <queue>                      // queue容器的头文件。
#include <condition_variable>  // 条件变量的头文件。
#include <functional>
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<string, deque<string>> m_q;   // 缓存队列，底层容器用deque。function<void(const string&)> m_callback;  // 回调函数对象。
public:// 注册回调函数，回调函数只有一个参数（消费者接收到的数据）。//如果可调用对象是类的非静态成员函数,args中将有一个this指针,否则没有.//占位参数为待处理的数据template<typename Fn, typename ...Args>void callback(Fn && fn, Args&&...args) {m_callback = bind(forward<Fn>(fn), forward<Args>(args)..., std::placeholders::_1);  // 绑定回调函数。}void incache(int num)     // 生产数据，num指定数据的个数。{lock_guard<mutex> 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<mutex>，并申请加锁。unique_lock<mutex> 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();
}

3. 取代虚函数

C++虚函数在执行过程中会跳转两次（先查找对象的函数表，再次通过该函数表中的地址找到真正的执行地址），这样的话，CPU会跳转两次，而普通函数只跳转一次。

CPU每跳转一次，预取指令要作废很多，所以效率会很低。（百度）

为了管理的方便（基类指针可指向派生类对象和自动析构派生类），保留类之间的继承关系。

#include <iostream>         // 包含头文件。
#include <functional>
using namespace std;struct Hero  {                          // 英雄基类//virtual void show() { cout << "英雄释放了技能。\n"; }function<void()> m_callback;        // 用于绑定子类的成员函数。// 注册子类成员函数，子类成员函数没有参数。template<typename Fn, typename ...Args>void callback(Fn&& fn, Args&&...args) {m_callback = bind(forward<Fn>(fn), forward<Args>(args)...);}void show() { m_callback(); }   // 调用子类的成员函数。
};struct SF :public Hero  {         // 影魔派生类void show() { cout << "SF释放了技能。\n"; }
};struct MK :public Hero  {         // 大圣派生类void show() { cout << "MK释放了技能。\n"; }
};int main()
{// 根据用户选择的英雄，施展技能。int id = 0;     // 英雄的id。cout << "请输入英雄（1-SF；2-MK。）：";cin >> id;// 创建基类指针，将指向派生类对象，用基类指针调用派生类的成员函数。Hero* ptr = nullptr;if (id == 1) {            // 1-SFptr = new SF;ptr->callback(&SF::show, dynamic_cast<SF*>(ptr));  // 注册子类成员函数。}else if (id == 2) {     // 2-MKptr = new MK;ptr->callback(&MK::show, dynamic_cast<MK*>(ptr));  // 注册子类成员函数。}if (ptr != nullptr) {ptr->show();      // 调用子类的成员函数。delete ptr;            // 释放派生类对象。}
}