【STL十六】函数对象：包装器(std::function）——绑定器（std::bind）——函数适配器
- 一、包装器(std::function）
- 1、简介
- 2、头文件
- 3、构造函数
- 4、demo
- 5、异常
- 二、绑定器（std::bind）
- 1、简介
- 2、头文件
- 3、构造函数
- 4、demo:简单场景
- 5、demo:值传递、引用传递
- 6、demo:绑定6种可调用对象
- 三、函数适配器
- 1、函数适配器（function adapters)
- 2、很多函数适配器在c++17就被废弃了
- 3、bind就是一种函数适配器（绑定器）
一、包装器(std::function）
1、简介
- std::function模板类是一个通用的可调用对象的包装器，
- 作用：简单的、统一的方式处理可调用对象。
std::function 的实例能存储、复制及调用任何可调用 (Callable) 目标——函数、 lambda 表达式、 bind 表达式或其他函数对象，还有指向成员函数指针和指向数据成员指针。存储的可调用对象被称为 std::function 的目标。
若 std::function 不含目标，则称它为空。调用空 std::function 的目标导致抛出 std::bad_function_call 异常。
2、头文件
#include <functional>
3、构造函数
template< class >
class function;
4、demo
#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。等价于 function<Fun> fn1 = 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 << "lambda表达式" << 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对象调用它。
}
输出
普通函数1，大唐不夜城。
普通函数1，大唐不夜城。
成员函数2，古城濮阳。
成员函数2，古城濮阳。
仿函数 3，古城西安。
仿函数 3，古城西安。
lambda表达式4，古城咸阳。
lambda表达式4，古城咸阳。
成员函数5，咸阳秦始皇。
成员函数5，咸阳秦始皇。
普通函数6，钟楼。
普通函数6，钟楼。
5、异常
- std::function对象未包装可调用对象，使用std::function对象将抛出std::bad_function_call异常
- demo
#include <iostream>
#include <functional>
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; // 返回普通函数show的地址。
}
};
int main()
{
DD dd;
function<void(int, const string&)> fx /*= dd*/;
try {
fx(1, "xxxxxxxxxxxxxx。");
}
catch (std::bad_function_call e) {
cout << "抛出了std::bad_function_call异常。";
}
}
输出
抛出了std::bad_function_call异常。
二、绑定器（std::bind）
1、简介
- std::bind()模板函数是一个通用的函数适配器（绑定器），
- 它用一个可调用对象及其参数，生成一个新的可调用对象，以适应模板。
- 接收一个函数名作为参数，生成一个新的函数。
使用std::bind可以将可调用对象和参数一起绑定，绑定后的结果使用std::function进行保存，并延迟调用到任何我们需要的时候。
2、头文件
#include <functional>
3、构造函数
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()的本质是仿函数。
4、demo:简单场景
- bind场景：普通函数绑定、参数位置不同、少一个参数、多一个参数；
- _1，_n在命名空间std::placeholders内
#include <iostream>
#include <functional>
using namespace std;
// 普通函数
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, "hello 西安。");
fn2(2, "hello 西安。");
// 调用参数位置
function<void(const string&, int)> fn3 = bind(show, placeholders::_2, placeholders::_1);
fn3("hello 西安。", 3);
// 少一个参数
function<void(const string&)> fn4 = bind(show, 4, placeholders::_1);
fn4("hello 西安。");
// 多一个参数
function<void(int, const string&, int)> fn5 = bind(show, placeholders::_1, placeholders::_2);
fn5(5, "hello 西安。", 88);
}
输出
第1个，hello 西安。
第2个，hello 西安。
第3个，hello 西安。
第4个，hello 西安。
第5个，hello 西安。
5、demo:值传递、引用传递
- 值传递
#include <iostream>
#include <functional>
using namespace std;
// 普通函数
void show(int bh, const string& message) {
cout << "第" << bh << "个，" << message << endl;
}
int main()
{
// 少一个参数
int n = 1;
function<void(const string&)> fn1 = bind(show, n, placeholders::_1);
fn1("hello 西安。");
n = 2;
fn1("hello 西安。");
}
输出
第1个，hello 西安。
第1个，hello 西安。
- 引用传递
#include <iostream>
#include <functional>
using namespace std;
// 普通函数
void show(int bh, const string& message) {
cout << "第" << bh << "个，" << message << endl;
}
int main()
{
// 少一个参数
int n = 1;
function<void(const string&)> fn1 = bind(show, std::ref(n), placeholders::_1);
fn1("hello 西安。");
n = 2;
fn1("hello 西安。");
}
输出
第1个，hello 西安。
第2个，hello 西安。
6、demo:绑定6种可调用对象
- bind 可以把六种可调用对象的调用方式统一起来
#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()
{
// 普通函数。
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个，长安归故里。
第2个，长安归故里。
第3个，长安归故里。
第4个，长安归故里。
第5个，长安归故里。
第6个，长安归故里。
三、函数适配器
我们在【STL十二】适配器——容器适配器介绍过：stl适配器分为 、容器适配器、迭代器适配器、函数适配器（function adapters)。
1、函数适配器（function adapters)
- 函数适配器：通过转换或者修改其他函数对象使其功能得到扩展。可以将预先定义的仿函数和其他数值结合在一起。
- 函数适配器种类
- 否定器
- 绑定器
- 函数指针适配器
2、很多函数适配器在c++17就被废弃了
从c++标准相关网站我们可以看到，比如，1、C++ STL 容器库 中文文档，很多函数适配器在c++17开始，就被废弃了。所以我们就不再介绍了。
3、bind就是一种函数适配器（绑定器）
参考
1、C++ STL 容器库 中文文档
2、STL教程：C++ STL快速入门
3、https://www.apiref.com/cpp-zh/cpp/header.html
4、https://en.cppreference.com/w/cpp/container
5、WIKI教程_C ++标准库_C++ Library - <iterator>
6、哔哩哔哩_系统化学习C++_C++11神器之可调用对象包装器和绑定器
