C++ STL：适配器-阿里云开发者社区

Part 3：适配器 Adapter

适配器就是接口，对容器、迭代器、算法进行包装，但其实质还是容器、迭代器和算法，只是不依赖于具体的标准容器、迭代器和算法类型。概念源于设计模式中的适配器模式：将一个类的接口转化为另一个类的接口，使原本不兼容而不能合作的类，可以一起运作。

容器适配器可以理解为容器的模板，迭代器适配器可理解为迭代器的模板，算法适配器可理解为算法的模板。

1、容器适配器

应用于容器，容器适配器包括：stack queue priority_queue

1.1、stack

stack 容器适配器，是 FILO（先进后出）的数据结构，底层容器deque，从容器的尾部（栈顶）推弹元素

template<class T, class Container = std::deque<T>> class stack;

1.2、queue

queue 容器适配器，是 FIFO （先进先出）数据结构，底层容器 deque，从容器尾部（队尾）推入元素，从容器头部（队头）弹出元素。

template<class T, class Container = std::deque<T>> class queue;

1.3、priority_queue

优先队列是容器适配器，提供常数时间的最值元素查找，对数时间的插入和删除。

底层容器vector
元素放入优先队列时，采用堆排序自动调整顺序
针对自定义类类型，需要重载比较方式class compare
默认情况下，std::less<T>，大顶堆。否则，std::greater<T>，小顶堆

template<class T, class Container = std::vector<T>, class Compare = std::less<typename Container::value_type>> class priority_queue;

（疑问：less，数组元素从小到大排列，访问数组尾部元素，大根堆？）

2、迭代器适配器

应用于迭代器。

插入迭代器：front_insert_iterator，back_insert_iterator，insert_iterator
反向迭代器：reverse_iterator
流迭代器：ostream_iterator，istream_iterator

2.1、插入迭代器

front_insert_iterator：在容器的尾部插入新元素，底层调用push_back()
back_insert_iterator：在容器的头部插入新元素，底层调用push_front()
insert_iterator：在容器指定位置插入新元素，底层调用insert()

容器使用插入迭代器时，底层必须实现对应的方法。

STL 为了提升使用的便利性，提供三个相应的函数，内部封装的是相应的插入迭代器

front_inserter
back_inserter
inserter

测试1：front_inserter | front_insert_iterator，输出结果：5 4 3 2 1 l1 l2 l3

vector<int> nums{1, 2, 3, 4, 5};
 list<int> ls{11, 12, 13};
 copy(nums.begin(), nums.end(), front_inserter(ls));
 // copy(nums.begin(), nums.end(), front_insert_iterator<list<int>>(ls));
 copy(ls.begin(), ls.end(), ostream_iterator<int>(cout, " "));
 cout << endl;

测试2：back_insert_iterator|，输出结果：11 12 13 1 2 3 4 5

vector<int> nums{1, 2, 3, 4, 5};
 list<int> ls{11, 12, 13};
 copy(nums.begin(), nums.end(), back_inserter(ls));
 // copy(nums.begin(), nums.end(), back_insert_iterator<list<int>>(ls));
 copy(ls.begin(), ls.end(), ostream_iterator<int>(cout, " "));
 cout << endl;

测试3：insert_iterator | inserter，输出结果：11 1 2 3 4 5 12 13

vector<int> nums{1, 2, 3, 4, 5};
 list<int> li {11, 12, 13};
 auto it = li.begin();
 ++it;
 copy(nums.begin(), nums.end(), inserter<list<int>>(li, it));
 // copy(nums.begin(), nums.end(), insert_iterator<li<int>>(li, it));
 copy(li.begin(), li.end(), ostream_iterator<int>(cout, " "));
 cout << endl;

2.2、反向迭代器

reverse_iterator，将迭代器的方向进行逆转，实现逆序遍历，底层是双向迭代器

测试：逆序输出结果：5 4 3 2 1

vector<int> nums{1, 2, 3, 4, 5};
 for (reverse_iterator rit = nums.rbegin(); rit != nums.rend(); ++rit) {
     cout << *rit << " ";
 }

2.3、流迭代器

ostream_iterator | inputIterator，可以将迭代器绑定到某个 iostream对象上，拥有输入输出功能。以此为基础，稍加修改，就可以适用于任何输入或输出装置上。例如：绑定到磁盘的某个目录上。原理就是把输入输出流当作容器（输入输出流拥有缓冲区），容器的访问需要迭代器。

测试1：ostream_iterator

vector<int> nums{1, 2, 3, 4, 5};
 // 将标准输出当成是容器，容器的访问就需要迭代器
 // 每次写操作后，写入可选的分隔符。
 // std::ostream_iterator<int> osi(cout, " ");
 // std::copy(nums.begin(), nums.end(), osi);
 copy(nums.begin(), nums.end(), ostream_iterator<int>(cout, " "));

测试2：istream_iterator

vector<int> nums;
 // 将标准输入流当成是容器，容器的访问就需要迭代器
 istream_iterator<int> isi(std::cin);
 // 匿名的 istream_iterator 对象，表示迭代器结束的位置，详见构造函数源码
 // 快捷键: ctrl + d 表示输入结束
 // 问题：nums 还没有申请空间，所以插入新的元素时，会出现 bug
 // copy(isi, istream_iterator<int>(), nums.begin()); // error
 // 插入元素时，需要使用插入迭代器来完成
 // back_insert  ==> 调用到push_back完成元素的添加
 copy(isi, istream_iterator<int>(), std::back_inserter(nums));

3、函数适配器

应用于仿函数。灵活度很高，可以配接，配接，再配接。通过它们之间的绑定、组合、修饰能力，可以无限制创造出各种可能的表达式。

包括

绑定 bind
否定 negate
组合 compose
修饰：通过修饰普通函数、成员函数，使之成为仿函数

**3.1、* bind**

bind 函数绑定多个实参到函数对象，函数原型：

/*
 返回值：函数对象
 参数：
 - f: 可调用 (Callable) 对象（函数对象、指向函数指针、函数引用、指向成员函数指针或指向数据成员指针）
 - args: 要绑定的参数列表，未绑定参数为命名空间 std::placeholders 的占位符 _1, _2, _3...所替换
 */
 template< class F, class... Args > 
 /*unspecified*/ bind( F&& f, Args&&... args );
 template< class R, class F, class... Args > 
 /*unspecified*/ bind( F&& f, Args&&... args );

bind 使用方法

bind 绑定类型

绑定普通函数。
绑定成员函数。成员函数隐含 this 指针，必须显示绑定
绑定数据成员。

若不想提前绑定参数，则使用占位符，占位符本身所在的位置是形参的位置，占位符的数字代表实参传递时候的位置，即函数调用时绑定实参列表中的对应实参位置。没有绑定的实参是无效参数。

bind 绑定参数采用值传递。

例如：

#include <functional>
 #include <iostream>
 using std::cout;
 using std::endl;
 using std::bind;
 using namespace std::placeholders;
 int add(int x, int y) {
     cout << "int add(int,int) = " << endl;
     cout << "(" << x << ", " << y << ")" << endl;
     return x + y;
 }
 struct MyTest {
     int add(int x, int y) { 
         cout << "MyTest::add(int,int)" << endl;
         return x + y + data;
     }
     int data = 1000; // C++11 特性
 };
 void func(int n1, int n2, int n3, const int & n4, int n5) {
     cout << "(" << n1 << "," << n2 << "," << n3 
          << "," << n4 << "," << n5 << ")" << endl;
 }
 void func(int n1, int n2, int n3, const int & n4, int n5) {
     cout << "(" << n1 << "," << n2 << "," << n3 
          << "," << n4 << "," << n5 << ")" << endl;
 }
 // 1、bind 绑定普通函数
 void test0() {
     // 1.1、绑定实参到函数对象，实参与形参必须一一对应
     auto f = std::bind(add, 1, 2);
     cout << f() << endl << endl;
     // 1.2、若不想提前绑定参数，使用占位符，表示调用时绑定实参列表的位置
     // 1.2.1、使用 bind 绑定 add 函数对象: arg1 = 1, 占位符 _1
     auto f1 = std::bind(add, 1, _1); 
     // 占位符 _1 表示绑定的是调用时实参列表的第一个位置, 即 (10, 11, 12) 中的 10
     // 输出结果：(1, 10), 11,12 为无效参数
     cout << f1(10, 11, 12) << endl; // 等价于 f1(10)
     // 1.2.2、使用 bind 绑定 add 函数对象: arg1 = 1，占位符 _2
     auto f2 = std::bind(add, 1, _2);
     // 占位符 _1 表示绑定的是调用时实参列表的第2个位置, 即 (10, 11, 12) 中的 11
     // 输出结果：(1, 11). 10, 12 为无效参数
     cout << f2(10, 11, 12) << endl; 
 } 
 // 2、bind 绑定成员函数和数据成员
 void test1() {
     MyTest mytest;
     // 2.1、绑定成员函数
     // 显示绑定 this 指针，需要保证其生命周期存在
     auto f = std::bind(&MyTest::add, &mytest, 1, 2);
     cout << f() << endl;        // 输出：3
     auto f1 = std::bind(&MyTest::add, &mytest, _1, 2);
     cout << f1(10) << endl;     // 输出 12
     auto f2 = std::bind(&MyTest::add, mytest, _1, _1);
     cout << f2(10, 20) << endl; // 输出 20
     // 2.2、绑定数据成员
     auto f3 = std::bind(&MyTest::data, mytest);
     cout << f3() << endl;       // 输出 1000
 }
 // 3、bind 绑定采用的是值传递
 void test2() {  
     int n = 100;
     // 值传递，传递对象时，会对对象本身进行复制
     auto f = std::bind(func, _2, 10, _1, std::cref(n), n);
     n = 111;  
     // 实参1对应形参_1，实参2对应形参_2，值传递 n 不变
     f(1, 2);  // 输出结果：(2,10,1,111,100)
 }
 int main(void) {
     test0(); 
     // test1();
     // test2(); 
     return 0;
 }

bind 简化原理

内部生成 Binder类，把要绑定的函数指针和函数参数提存储起来，并重载函数调用运算符

bind绑定普通函数

#include <functional>
 #include <iostream>
 using std::cout;
 using std::endl;
 int (* f)(int,int);              // 声明一个函数类型变量 f
 typedef int(*Function)(int,int);  // 声明一个函数类型
 int add(int x, int y) {
     int number ;
     cout << "int add(int,int)" << endl;
     cout << "(" << x << ", " << y << ")" << endl;
     return x + y;
 }
 int multiply(int x, int y) {    
     return x * y;   
 }
 // 1、C 语言的多态机制：函数指针
 // C 语言通过函数指针体现多态
 void test0() {
     // Function 是一个类型，func 是一个对象（变量）
     // 函数 add 和 multiply 是常量。编译完成后，函数入口地址就确定了
     Function func;
     // 1、注册回调函数 
     // 2、执行回调函数 
     func = add;    
     cout << func(1, 2) << endl;
     func = multiply;
     cout << func(3, 4) << endl;
 }
 // 类比：std::bind 绑定后，返回的函数对象
 struct Binder {
     Binder(int(*p)(int,int), int x, int y)
     : pFunc(p), a(x), b(y) {}
     int operator()() {
         return pFunc(a, b);
     }
     int (*pFunc)(int,int);
     int a;
     int b;
 };
 struct Binder mybind(int(*p)(int,int), int x, int y) {
     return Binder(p, x, y);
 }
 // 2、std::bind 绑定普通函数
 void test1() {
     auto f = std::bind(add, 1, 2);
     f();
     Binder binder(add, 1, 2);
     binder();
     auto f2 = mybind(add, 1, 2);
     f2();
 }

bind 绑定成员函数

struct Mytest {
     int add(int x, int y) {
         cout << "Mytest::aad(int,int)" << endl;
         return x + y;
     }
 };
 struct Mybinder {
     Mybinder(int(Mytest::*f)(int,int), Mytest t, int x, int y)
     : p(f), test(t), a(x), b(y) {}
     int operator()() {
         return (test.*p)(a, b);
     }
     int (Mytest::*p)(int,int);
     Mytest test;
     int a;
     int b;
 };
 // 2、std::bind 绑定成员函数
 void test2() {
     Mytest test;
     Mytest * ptest = &test;
      // 声明一个成员函数指针时，需要指定类作用域
      int (Mytest::*p)(int,int) = &Mytest::add;
      // 成员函数指针的调用形式
      // 2.1、通过对象调用成员函数指针, 采用 .*
      cout << (test.*p)(1, 2) << endl;
      // 2.2、通过对象的指针调用成员函数指针, 采用 ->*
      cout << (ptest->*p)(1, 2) << endl;
 }

3.2、mem_fn

成员函数绑定器

// 绑定成员函数，删除质数元素，并打印
 nums.erase(remove_if(nums.begin(), nums.end(), mem_fn(&Number::isPrime)), nums.end());
 std::for_each(nums.begin(), nums.end(), mem_fn(&Number::print));

C++ STL：适配器