一、可调用对象
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-SF
ptr = new SF;
ptr->callback(&SF::show, dynamic_cast<SF*>(ptr)); // 注册子类成员函数。
}
else if (id == 2) { // 2-MK
ptr = new MK;
ptr->callback(&MK::show, dynamic_cast<MK*>(ptr)); // 注册子类成员函数。
}
if (ptr != nullptr) {
ptr->show(); // 调用子类的成员函数。
delete ptr; // 释放派生类对象。
}
}