C++ STL：适配器

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

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

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;

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 11 12 13

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 绑定参数采用值传递。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));