C++学习笔记（22）

250、可调用对象
在 C++中，可以像函数一样调用的有：普通函数、类的静态成员函数、仿函数、lambda 函数、类
的非静态成员函数、可被转换为函数的类的对象，统称可调用对象或函数对象。
可调用对象有类型，可以用指针存储它们的地址，可以被引用（类的成员函数除外） 一、普通函数
普通函数类型可以声明函数、定义函数指针和函数引用，但是，不能定义函数的实体。
示例：
#include <iostream>
using namespace std;
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;
//}
二、类的静态成员函数
类的静态成员函数和普通函数本质上是一样的，把普通函数放在类中而已。
示例：
#include <iostream>
using namespace std;
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, "我是一只傻傻鸟。"); // 用函数引用调用静态成员函数。
}
三、仿函数
仿函数的本质是类，调用的代码像函数。
仿函数的类型就是类的类型。
示例：
#include <iostream>
using namespace std;
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, "我是一只傻傻鸟。"); // 用对象的引用调用仿函数。
}
四、lambda 函数
lambda 函数的本质是仿函数，仿函数的本质是类。
#include <iostream>
using namespace std;
int main()
{
// 创建 lambda 对象。
auto lb = [](int bh, const string& message) {
cout << "亲爱的" << bh << "，" << message << endl;
};
auto& lr = lb; // 引用 lambda 对象。
lb(1, "我是一只傻傻鸟。"); // 用 lambda 对象调用仿函数。
lr(2, "我是一只傻傻鸟。"); // 用 lambda 对象的引用调用仿函数。
}
五、类的非静态成员函数
类的非静态成员函数有地址，但是，只能通过类的对象才能调用它，所以，C++对它做了特别处理。
类的非静态成员函数只有指针类型，没有引用类型，不能引用。
示例：
#include <iostream>
using namespace std;
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, "我是一只傻傻鸟。"); // 用类成员函数的指针调用类的
成员函数。
}
六、可被转换为函数指针的类对象
类可以重载类型转换运算符 operator 数据类型() ，如果数据类型是函数指针或函数引用类型，那么
该类实例也将成为可调用对象。
它的本质是类，调用的代码像函数。
在实际开发中，意义不大。
示例：
#include <iostream>
using namespace std;
// 定义函数
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, "我是一只傻傻鸟。"); // 可以被转换为函数指针的类对象。
}
251、包装器 function
std::function 模板类是一个通用的可调用对象的包装器，用简单的、统一的方式处理可调用对象。
template<class _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, "我是一只傻傻鸟。"); // 用函数指针调用普通函数。
function<void(int, const string&)> fn1 = show; // 包装普通全局函数 show。
fn1(1, "我是一只傻傻鸟。"); // 用function对象调用普通
全局函数 show。
// 类的静态成员函数。
void(*fp3)(int, const string&) = AA::show; // 用函数指针指向类的静态成员函数。
fp3(2, "我是一只傻傻鸟。"); // 用函数指针调用类的静态成员函数。
function<void(int, const string&)> fn3 = AA::show; // 包装类的静态成员函数。
fn3(2, "我是一只傻傻鸟。"); // 用 function 对象
调用类的静态成员函数。
// 仿函数。
BB bb;
bb(3, "我是一只傻傻鸟。"); // 用仿函数对象调用仿函数。
function<void(int, const string&)> fn4 = BB(); // 包装仿函数。
fn4(3, "我是一只傻傻鸟。"); // 用function对象调用仿函
数。
// 创建 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 函数。
// 类的非静态成员函数。
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 对象
调用成员函数。
// 可以被转换为函数指针的类对象。
DD dd;
dd(6, "我是一只傻傻鸟。"); // 用可以被转换为函数指针的类对象调用普
通函数。
function<void(int, const string&)> fn12 = dd; // 包装可以被转换为函数指针的类。
fn12(6, "我是一只傻傻鸟。"); // 用 function 对象调用
它。
function<void(int, const string&)> fx=dd;
try {
if (fx) fx(6, "我是一只傻傻鸟。");
}
catch (std::bad_function_call e) {
cout << "抛出了 std::bad_function_call 异常。";
}
}