适配器及反向迭代器的理解

适配器及反向迭代器的理解

适配器

C++中的适配器模式借助一个类的接口将一个类转换为用户想要的类，类似手机充电线上的电源适配器，能够将插座上的电压功率转换为手机充电时需要的电压功率。

C++中经典的容器适配器就是stack和queue，这两个并不是容器，这是因为stack和queue只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque这个容器进行包装的。

deque这个容器是一个双端队列（双进双出）

为什么选择deque作为stack和queue的底层默认容器，这是因为deque的双端插入和删除效率高，而stack和queue都是只在双端进行操作的，故能充分利用deque的优点，而避开了deque的缺陷。

stack的模拟实现

#include<deque>
template<class T, class Con = deque<T>>//默认是deque，也可以自定义为其他容器
 //template<class T, class Con = vector<T>>
 //template<class T, class Con = list<T>>
 class stack
 {
 public:
 stack() {}
 void push(const T& x) {_c.push_back(x);}
 void pop() {_c.pop_back();}
 T& top() {return _c.back();}
 const T& top()const {return _c.back();}
 size_t size()const {return _c.size();}
 bool empty()const {return _c.empty();}
 private:
 Con _c;
 };

queue的模拟实现

#include<deque>
#include <list>
 template<class T, class Con = deque<T>> //默认是deque，也可以自定义为其他容器
 //template<class T, class Con = list<T>>
 class queue
 {
 public:
 queue() {}
 void push(const T& x) {_c.push_back(x);}
 void pop() {_c.pop_front();}
 T& back() {return _c.back();}
 const T& back()const {return _c.back();}
 T& front() {return _c.front();}
 const T& front()const {return _c.front();}
 size_t size()const {return _c.size();}
 bool empty()const {return _c.empty();}
 private:
 Con _c;
 };

注意：容器适配器的底层并不是什么容器都可以，能够实现适配器功能的容器才能做底层

反向迭代器

在C++的底层中，反向迭代器就是正向迭代器的一个包装，反向迭代器的++就是正向迭代器的–，反向迭代器的–就是正向迭代器的++。由于追求对称性，正向迭代器end()和反向迭代器rbegin()指向的位置一样，begin()和rend()指向的位置一样。

template<class Iterator>
class ReverseListIterator
{
 // 注意：此处typename的作用是明确告诉编译器，Ref是Iterator类中的类型，而不是静态成员变量
 // 否则编译器编译时就不知道Ref是Iterator中的类型还是静态成员变量
 // 因为静态成员变量也是按照 类名::静态成员变量名 的方式访问的
public:
 typedef typename Iterator::Ref Ref;
 typedef typename Iterator::Ptr Ptr;
 typedef ReverseListIterator<Iterator> Self;
public:
 ReverseListIterator(Iterator it): _it(it){}
 Ref operator*(){
     Iterator temp(_it);
     --temp;
     return *temp;
 }
 Ptr operator->(){ return &(operator*());}

 // 迭代器支持移动
 Self& operator++(){
     --_it;
     return *this;
 }
 Self operator++(int){
 	 Self temp(*this);
     --_it;
     return temp;
 }
 Self& operator--(){
     ++_it;
     return *this;
 }
 Self operator--(int)
 {
     Self temp(*this);
     ++_it;
     return temp;
 }

 // 迭代器支持比较
 bool operator!=(const Self& l)const{ return _it != l._it;}
 bool operator==(const Self& l)const{ return _it != l._it;}
 Iterator _it;
};