网站备份 ftp,怎么做网站投放广告,网站内容和功能清单,淘宝网店代运营正规公司std::function模板类是一个通用的可调用对象的包装器#xff0c;用简单的、统一的方式处理可调用对象。
templateclass _Fty
class function……
_Fty是可调用对象的类型#xff0c;格式#xff1a;返回类型(参数列表)。
包含头文件#xff1a;#include functi…std::function模板类是一个通用的可调用对象的包装器用简单的、统一的方式处理可调用对象。
templateclass _Fty
class function……
_Fty是可调用对象的类型格式返回类型(参数列表)。
包含头文件#include functional
注意
重载了bool运算符用于判断是否包装了可调用对象。
如果std::function对象未包装可调用对象使用std::function对象将抛出std::bad_function_call异常。
示例
#include iostream
#include functional
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, 我是一只傻傻鸟。); // 用函数指针调用普通函数。functionvoid(int, const string) fn1 show; // 包装普通全局函数show。fn1(1, 我是一只傻傻鸟。); // 用function对象调用普通全局函数show。// 类的静态成员函数。void(*fp3)(int, const string) AA::show; // 用函数指针指向类的静态成员函数。fp3(2, 我是一只傻傻鸟。); // 用函数指针调用类的静态成员函数。functionvoid(int, const string) fn3 AA::show; // 包装类的静态成员函数。fn3(2, 我是一只傻傻鸟。); // 用function对象调用类的静态成员函数。// 仿函数。BB bb;bb(3, 我是一只傻傻鸟。); // 用仿函数对象调用仿函数。functionvoid(int, const string) fn4 BB(); // 包装仿函数。fn4(3, 我是一只傻傻鸟。); // 用function对象调用仿函数。// 创建lambda对象。auto lb [](int bh, const string message) {cout 亲爱的 bh message endl;};lb(4, 我是一只傻傻鸟。); // 调用lambda函数。functionvoid(int, const string) fn5 lb; // 包装lamba函数。fn5(4, 我是一只傻傻鸟。); // 用function对象调用lamba函数。// 类的非静态成员函数。CC cc;void (CC:: * fp11)(int, const string) CC::show; // 定义类成员函数的指针。(cc.*fp11)(5, 我是一只傻傻鸟。); // 用类成员函数的指针调用类的成员函数。functionvoid(CC,int, const string) fn11 CC::show; // 包装成员函数。fn11(cc,5, 我是一只傻傻鸟。); // 用function对象调用成员函数。// 可以被转换为函数指针的类对象。DD dd;dd(6, 我是一只傻傻鸟。); // 用可以被转换为函数指针的类对象调用普通函数。functionvoid(int, const string) fn12 dd; // 包装可以被转换为函数指针的类。fn12(6, 我是一只傻傻鸟。); // 用function对象调用它。functionvoid(int, const string) fxdd;try {if (fx) fx(6, 我是一只傻傻鸟。);}catch (std::bad_function_call e) {cout 抛出了std::bad_function_call异常。;}
}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()的本质是仿函数。
示例一bind的基本用法
#include iostream
#include functional
using namespace std;// 普通函数
void show(int bh, const string message) {cout 亲爱的 bh 号 message endl;
}int main()
{functionvoid(int, const string) fn1 show;functionvoid(int, const string) fn2 bind(show, placeholders::_1, placeholders::_2);fn1(1, 我是一只傻傻鸟。);fn2(1, 我是一只傻傻鸟。);functionvoid(const string, int) fn3 bind(show, placeholders::_2, placeholders::_1);fn3(我是一只傻傻鸟。, 1);functionvoid(const string) fn4 bind(show, 3, placeholders::_1);fn4(我是一只傻傻鸟。);functionvoid(int, const string,int) fn5 bind(show, placeholders::_1, placeholders::_2);fn5(1, 我是一只傻傻鸟。, 88);
}
示例二绑定六种可调用对象
#include iostream
#include functional
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()
{// 普通函数。functionvoid(int, const string) fn1 bind(show, placeholders::_1, placeholders::_2); // 绑定普通全局函数show。fn1(1, 我是一只傻傻鸟。); // 用function对象调用普通全局函数show。// 类的静态成员函数。functionvoid(int, const string) fn3 bind(AA::show, placeholders::_1, placeholders::_2); // 绑定类的静态成员函数。fn3(2, 我是一只傻傻鸟。); // 用function对象调用类的静态成员函数。// 仿函数。functionvoid(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;};functionvoid(int, const string) fn5 bind(lb, placeholders::_1, placeholders::_2); // 绑定lamba函数。fn5(4, 我是一只傻傻鸟。); // 用function对象调用lamba函数。// 类的非静态成员函数。CC cc;//functionvoid(CC, int, const string) fn11 bind(CC::show, placeholders::_1, placeholders::_2, placeholders::_3); // 绑定成员函数。//fn11(cc, 5, 我是一只傻傻鸟。); // 用function对象调用成员函数。functionvoid(int, const string) fn11 bind(CC::show,cc,placeholders::_1, placeholders::_2); // 绑定成员函数。fn11(5, 我是一只傻傻鸟。); // 用function对象调用成员函数。// 可以被转换为函数指针的类对象。DD dd;functionvoid(int, const string) fn12 bind(dd, placeholders::_1, placeholders::_2); // 绑定可以被转换为函数指针的类。fn12(6, 我是一只傻傻鸟。); // 用function对象调用它。
}写一个函数函数的参数是函数对象及参数功能和thread类的构造函数相同。
示例
#include iostream
#include thread
#include functional
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;}
};templatetypename Fn, typename...Args
auto show(Fn fn, Args...args) - decltype(bind(forwardFn(fn), forwardArgs(args)...))
{cout 表白前的准备工作......\n;auto f bind(forwardFn(fn), forwardArgs(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 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; // 条件变量。queuestring, dequestring m_q; // 缓存队列底层容器用deque。functionvoid(const string) m_callback; // 回调函数对象。
public:// 注册回调函数回调函数只有一个参数消费者接收到的数据。templatetypename Fn, typename ...Argsvoid callback(Fn fn, Args...args) {m_callback bind(forwardFn(fn), forwardArgs(args)..., std::placeholders::_1); // 绑定回调函数。}void incache(int num) // 生产数据num指定数据的个数。{lock_guardmutex 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_lockmutex并申请加锁。unique_lockmutex 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 iostream // 包含头文件。
#include functional
using namespace std;struct Hero { // 英雄基类//virtual void show() { cout 英雄释放了技能。\n; }functionvoid() m_callback; // 用于绑定子类的成员函数。// 注册子类成员函数子类成员函数没有参数。templatetypename Fn, typename ...Argsvoid callback(Fn fn, Args...args) {m_callback bind(forwardFn(fn), forwardArgs(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_castXS*(ptr)); // 注册子类成员函数。}else if (id 2) { // 2-韩信ptr new HX;ptr-callback(HX::show, static_castHX*(ptr)); // 注册子类成员函数。}if (ptr ! nullptr) {ptr-show(); // 调用子类的成员函数。delete ptr; // 释放派生类对象。}
}
