C++中的反向迭代器
C++中的反向迭代器
为啥反向迭代器的讲解要单独拎出来讲，没有在讲各个容器的时候顺手讲了呢？ 主要是因为c++中的反向迭代器和正向迭代器的实现不太一样。
它思想不复杂，主要是巧。
来，我们按照我们刚刚的想法把代码写出来
#pragma once
#include<cassert>namespace lx
{template <class T>struct ListNode{ListNode<T>* next;ListNode<T>* prev;T data;ListNode(const T& x=T()):next(nullptr),prev(nullptr),data(x){}};template <class T, class Ref, class Ptr>struct __list_iterator{typedef __list_iterator<T, const T&, const T*> const_iterator;typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<T, Ref, Ptr> Self;typedef ListNode<T>* Node;Node _node;__list_iterator(Node node) : _node(node) {}__list_iterator() {}__list_iterator(const iterator& x) : _node(x._node) {}//重载bool operator==(const Self& x) const{return _node == x._node;}bool operator!=(const Self& x) const{return _node != x._node;}//解引用重载Ref operator*() const{return _node->data;}//箭头重载Ptr operator->(){return &(_node->data);//return &(operator*());}//前置++Self& operator++(){_node = _node->next;return *this;}//后置++Self operator++(int){Self tmp = *this;++ *this;return tmp;}//前置--Self& operator--(){_node = _node->prev;return *this;}//后置--Self operator--(int){Self tmp = *this;-- *this;return tmp;}};template <class T, class Ref, class Ptr>struct reverse__iterator{typedef reverse__iterator<T, const T&, const T*> const_reverse_iterator;typedef reverse__iterator<T, T&, T*> reverse_iterator;typedef reverse__iterator<T, Ref, Ptr> Self;typedef ListNode<T>* Node;Node _node;reverse__iterator(Node node) : _node(node) {}reverse__iterator() {}reverse__iterator(const reverse_iterator& x) : _node(x._node) {}//重载bool operator==(const Self& x) const{return _node == x._node;}bool operator!=(const Self& x) const{return _node != x._node;}//解引用重载Ref operator*() const{return _node->data;}//箭头重载Ptr operator->(){return &(_node->data);//return &(operator*());}//前置++Self& operator++(){_node = _node->prev;return *this;}//后置++Self operator++(int){Self tmp = *this;++* this;return tmp;}//前置--Self& operator--(){_node = _node->next;return *this;}//后置--Self operator--(int){Self tmp = *this;--* this;return tmp;}};template <class T>class list{public:typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<T, const T&, const T*> const_iterator;typedef reverse__iterator<T, const T&, const T*> const_reverse_iterator;typedef reverse__iterator<T, T&, T*> reverse_iterator;void empty_init(){_head = new node;_head->next = _head;_head->prev = _head;}list(){empty_init();}~list(){clear();delete _head;_head = nullptr;}list(const list<T>& x){empty_init();/*iterator it = x.begin();while (it != x.end()){push_back(*it);}*/for (const auto& e : x){push_back(e);}}/*list<T>& operator=(const list<T>& x){if (this != &x){clear();for (const auto& e : x){push_back(e);}}return *this;}*/list<T>& operator=(list<T> x){swap(x);return *this;}//iterator begin(){//return iterator(_head->next);return _head->next;}iterator end(){//return iterator(_head);return _head;}reverse_iterator rbegin(){//return iterator(_head->next);return _head->prev;}reverse_iterator rend(){//return iterator(_head);return _head;}const_iterator begin() const{//return iterator(_head->next);return _head->next;}const_iterator end() const{//return iterator(_head);return _head;}//bool empty() const{//return _head->prev == _head;return _head->next == _head;}size_t size() const{size_t count = 0;const_iterator it = begin();while (it != end()){++count;++it;}return count;}//T& front(){return *(begin());}const T& front() const{return *(begin());}T& back(){return *(--end());}const T& back() const{return *(--end());}//void swap(list<T>& x){std::swap(_head, x._head);}iterator insert(iterator position, const T& val){assert(position._node);node* cur = position._node;node* prev = cur->prev;node* newnode = new node(val);prev->next = newnode;newnode->prev = prev;newnode->next = cur;cur->prev = newnode;//return iterator(newnode);return newnode;}iterator erase(iterator position){assert(position._node);assert(!empty());node* cur = position._node;node* next = cur->next;node* prev = cur->prev;delete cur;prev->next = next;next->prev = prev;//return iterator(next);return next;}void push_back(const T& val){node* tail = _head->prev;node* newnode = new node(val);tail->next = newnode;newnode->prev = tail;newnode->next = _head;_head->prev = newnode;}/*void push_back(const T& val){insert(end(), val);}*/void push_front(const T& val){node* cur = begin()._node;node* newnode = new node(val);_head->next = newnode;newnode->prev = _head;newnode->next = cur;cur->prev = newnode;}/*void push_front(const T& val){insert(begin(), val);}*/void pop_back(){assert(!empty());node* cur = _head->prev;node* prev = cur->prev;delete cur;prev->next = _head;_head->prev = prev;}/*void pop_back(){erase(--end());}*/void pop_front(){assert(!empty());node* cur = begin()._node;node* next = cur->next;delete cur;_head->next = next;next->prev = _head;}/*void pop_front(){erase(begin());}*/void resize(size_t n, T val = T()){if (n != size()){if (n > size()){size_t len = n - size();for (size_t i = 0; i < len; i++){push_back(val);}}else{size_t len = size() - n;for (size_t i = 0; i < len; i++){pop_back();}}} }void clear(){assert(!empty());iterator it = begin();while (it != end()){it=erase(it);}}private:typedef ListNode<T> node;node* _head;};}
test.cpp//测试代码
#include<iostream>
using namespace std;#include"list.h"namespace lx
{void test2(){list<int> l1;l1.push_back(1);l1.push_back(2);l1.push_back(3);l1.push_back(4);l1.push_back(5);auto rit = l1.rbegin();while (rit != l1.rend()){cout << *rit << " ";++rit;}cout << endl;}
}int main()
{lx::test2();return 0;
}
来，我们看重点部分哈。
template <class T, class Ref, class Ptr>struct __list_iterator//正向迭代器的封装{typedef __list_iterator<T, const T&, const T*> const_iterator;typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<T, Ref, Ptr> Self;typedef ListNode<T>* Node;Node _node;__list_iterator(Node node) : _node(node) {}__list_iterator() {}__list_iterator(const iterator& x) : _node(x._node) {}//重载bool operator==(const Self& x) const{return _node == x._node;}bool operator!=(const Self& x) const{return _node != x._node;}//解引用重载Ref operator*() const{return _node->data;}//箭头重载Ptr operator->(){return &(_node->data);//return &(operator*());}//前置++Self& operator++(){_node = _node->next;return *this;}//后置++Self operator++(int){Self tmp = *this;++ *this;return tmp;}//前置--Self& operator--(){_node = _node->prev;return *this;}//后置--Self operator--(int){Self tmp = *this;-- *this;return tmp;}};template <class T, class Ref, class Ptr>struct reverse__iterator//反向迭代器的封装{typedef reverse__iterator<T, const T&, const T*> const_reverse_iterator;typedef reverse__iterator<T, T&, T*> reverse_iterator;typedef reverse__iterator<T, Ref, Ptr> Self;typedef ListNode<T>* Node;Node _node;reverse__iterator(Node node) : _node(node) {}reverse__iterator() {}reverse__iterator(const reverse_iterator& x) : _node(x._node) {}//重载bool operator==(const Self& x) const{return _node == x._node;}bool operator!=(const Self& x) const{return _node != x._node;}//解引用重载Ref operator*() const{return _node->data;}//箭头重载Ptr operator->(){return &(_node->data);//return &(operator*());}//前置++Self& operator++(){_node = _node->prev;//这里不一样return *this;}//后置++Self operator++(int){Self tmp = *this;++* this;return tmp;}//前置--Self& operator--(){_node = _node->next;//这里不一样return *this;}//后置--Self operator--(int){Self tmp = *this;--* this;return tmp;}};
来，我们按照刚刚的思想重新写一遍代码。
reverse_iterator.h
#pragma once
namespace lx
{template<class iterator_type,class Ref,class Ptr>struct reverse__iterator{public:typedef reverse__iterator<iterator_type, Ref, Ptr> Self;reverse__iterator(const iterator_type& it):_it(it){}//重载bool operator==(const Self& x) const{return _it == x._it;}bool operator!=(const Self& x) const{return _it != x._it;}//解引用重载Ref operator*() const{return *_it;}//箭头重载Ptr operator->(){return &(operator*());}//前置++Self& operator++(){--_it;return *this;}//后置++Self operator++(int){Self tmp = *this;++* this;return tmp;}//前置--Self& operator--(){++_it;return *this;}//后置--Self operator--(int){Self tmp = *this;--* this;return tmp;}private:iterator_type _it;};
}
list.h
#pragma once
#include<cassert>
#include"reverse_iterator.h"
namespace lx
{template <class T>struct ListNode{ListNode<T>* next;ListNode<T>* prev;T data;ListNode(const T& x=T()):next(nullptr),prev(nullptr),data(x){}};template <class T, class Ref, class Ptr>struct __list_iterator{typedef __list_iterator<T, const T&, const T*> const_iterator;typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<T, Ref, Ptr> Self;typedef ListNode<T>* Node;Node _node;__list_iterator(Node node) : _node(node) {}__list_iterator() {}__list_iterator(const iterator& x) : _node(x._node) {}//重载bool operator==(const Self& x) const{return _node == x._node;}bool operator!=(const Self& x) const{return _node != x._node;}//解引用重载Ref operator*() const{return _node->data;}//箭头重载Ptr operator->(){return &(_node->data);//return &(operator*());}//前置++Self& operator++(){_node = _node->next;return *this;}//后置++Self operator++(int){Self tmp = *this;++ *this;return tmp;}//前置--Self& operator--(){_node = _node->prev;return *this;}//后置--Self operator--(int){Self tmp = *this;-- *this;return tmp;}};//template <class T, class Ref, class Ptr>//struct reverse__iterator//{// typedef reverse__iterator<T, const T&, const T*> const_reverse_iterator;// typedef reverse__iterator<T, T&, T*> reverse_iterator;// typedef reverse__iterator<T, Ref, Ptr> Self;// typedef ListNode<T>* Node;// Node _node;// reverse__iterator(Node node) : _node(node) {}// reverse__iterator() {}// reverse__iterator(const reverse_iterator& x) : _node(x._node) {}// //重载// bool operator==(const Self& x) const// {// return _node == x._node;// }// bool operator!=(const Self& x) const// {// return _node != x._node;// }// //解引用重载// Ref operator*() const// {// return _node->data;// }// //箭头重载// Ptr operator->()// {// return &(_node->data);// //return &(operator*());// }// //前置++// Self& operator++()// {// _node = _node->prev;// return *this;// }// //后置++// Self operator++(int)// {// Self tmp = *this;// ++* this;// return tmp;// }// //前置--// Self& operator--()// {// _node = _node->next;// return *this;// }// //后置--// Self operator--(int)// {// Self tmp = *this;// --* this;// return tmp;// }//};template <class T>class list{public:typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<T, const T&, const T*> const_iterator;typedef reverse__iterator<iterator, T&, T*> reverse_iterator;typedef reverse__iterator<const_iterator, const T&, const T*> const_reverse_iterator;void empty_init(){_head = new node;_head->next = _head;_head->prev = _head;}list(){empty_init();}~list(){clear();delete _head;_head = nullptr;}list(const list<T>& x){empty_init();/*iterator it = x.begin();while (it != x.end()){push_back(*it);}*/for (const auto& e : x){push_back(e);}}/*list<T>& operator=(const list<T>& x){if (this != &x){clear();for (const auto& e : x){push_back(e);}}return *this;}*/list<T>& operator=(list<T> x){swap(x);return *this;}//iterator begin(){//return iterator(_head->next);return _head->next;}iterator end(){//return iterator(_head);return _head;}reverse_iterator rbegin(){return reverse_iterator(--end());}reverse_iterator rend(){return reverse_iterator(end());}const_iterator begin() const{//return iterator(_head->next);return _head->next;}const_iterator end() const{//return iterator(_head);return _head;}const_reverse_iterator rbegin() const{return reverse_iterator(--end());}const_reverse_iterator rend() const{return reverse_iterator(end());}//bool empty() const{//return _head->prev == _head;return _head->next == _head;}size_t size() const{size_t count = 0;const_iterator it = begin();while (it != end()){++count;++it;}return count;}//T& front(){return *(begin());}const T& front() const{return *(begin());}T& back(){return *(--end());}const T& back() const{return *(--end());}//void swap(list<T>& x){std::swap(_head, x._head);}iterator insert(iterator position, const T& val){assert(position._node);node* cur = position._node;node* prev = cur->prev;node* newnode = new node(val);prev->next = newnode;newnode->prev = prev;newnode->next = cur;cur->prev = newnode;//return iterator(newnode);return newnode;}iterator erase(iterator position){assert(position._node);assert(!empty());node* cur = position._node;node* next = cur->next;node* prev = cur->prev;delete cur;prev->next = next;next->prev = prev;//return iterator(next);return next;}void push_back(const T& val){node* tail = _head->prev;node* newnode = new node(val);tail->next = newnode;newnode->prev = tail;newnode->next = _head;_head->prev = newnode;}/*void push_back(const T& val){insert(end(), val);}*/void push_front(const T& val){node* cur = begin()._node;node* newnode = new node(val);_head->next = newnode;newnode->prev = _head;newnode->next = cur;cur->prev = newnode;}/*void push_front(const T& val){insert(begin(), val);}*/void pop_back(){assert(!empty());node* cur = _head->prev;node* prev = cur->prev;delete cur;prev->next = _head;_head->prev = prev;}/*void pop_back(){erase(--end());}*/void pop_front(){assert(!empty());node* cur = begin()._node;node* next = cur->next;delete cur;_head->next = next;next->prev = _head;}/*void pop_front(){erase(begin());}*/void resize(size_t n, T val = T()){if (n != size()){if (n > size()){size_t len = n - size();for (size_t i = 0; i < len; i++){push_back(val);}}else{size_t len = size() - n;for (size_t i = 0; i < len; i++){pop_back();}}} }void clear(){assert(!empty());iterator it = begin();while (it != end()){it=erase(it);}}private:typedef ListNode<T> node;node* _head;};}
test.cpp//测试代码
#include<iostream>
using namespace std;
#include"reverse_iterator.h"
#include"list.h"
namespace lx
{void test2(){list<int> l1;l1.push_back(1);l1.push_back(2);l1.push_back(3);l1.push_back(4);l1.push_back(5);auto rit = l1.rbegin();while (rit != l1.rend()){cout << *rit << " ";++rit;}cout << endl;}
}int main()
{lx::test2();return 0;
}
那么重点部分肯定就是reverse_iterator.h
#pragma once
namespace lx
{template<class iterator_type,class Ref,class Ptr>struct reverse__iterator{public:typedef reverse__iterator<iterator_type, Ref, Ptr> Self;reverse__iterator(const iterator_type& it):_it(it){}//重载bool operator==(const Self& x) const{return _it == x._it;}bool operator!=(const Self& x) const{return _it != x._it;}//解引用重载Ref operator*() const{return *_it;}//箭头重载Ptr operator->(){return &(operator*());}//前置++Self& operator++(){--_it;return *this;}//后置++Self operator++(int){Self tmp = *this;++* this;return tmp;}//前置--Self& operator--(){++_it;return *this;}//后置--Self operator--(int){Self tmp = *this;--* this;return tmp;}private:iterator_type _it;};
}
如果按照源码那样设计，代码就得写成这样：（变动的地方我都在旁边注释出来了。大家简单画一下图就能明白遍历逻辑了）
reverse_iterator.h
#pragma once
//namespace lx
//{
//
// template<class iterator_type,class Ref,class Ptr>
// struct reverse__iterator
// {
// public:
// typedef reverse__iterator<iterator_type, Ref, Ptr> Self;
//
// reverse__iterator(const iterator_type& it)
// :_it(it)
// {}
//
// //重载
// bool operator==(const Self& x) const
// {
// return _it == x._it;
// }
// bool operator!=(const Self& x) const
// {
// return _it != x._it;
// }
//
// //解引用重载
// Ref operator*() const
// {
// return *_it;
// }
// //箭头重载
// Ptr operator->()
// {
// return &(operator*());
// }
//
// //前置++
// Self& operator++()
// {
// --_it;
// return *this;
// }
// //后置++
// Self operator++(int)
// {
// Self tmp = *this;
// ++* this;
// return tmp;
// }
//
// //前置--
// Self& operator--()
// {
// ++_it;
// return *this;
// }
// //后置--
// Self operator--(int)
// {
// Self tmp = *this;
// --* this;
// return tmp;
// }
// private:
// iterator_type _it;
// };
//}namespace lx
{template<class iterator_type, class Ref, class Ptr>struct reverse__iterator{public:typedef reverse__iterator<iterator_type, Ref, Ptr> Self;reverse__iterator(const iterator_type& it):_it(it){}//重载bool operator==(const Self& x) const{return _it == x._it;}bool operator!=(const Self& x) const{return _it != x._it;}//解引用重载Ref operator*() const//这里变动了{iterator_type tmp = _it;--tmp;return *tmp;}//箭头重载Ptr operator->(){return &(operator*());}//前置++Self& operator++(){--_it;return *this;}//后置++Self operator++(int){Self tmp = *this;++* this;return tmp;}//前置--Self& operator--(){++_it;return *this;}//后置--Self operator--(int){Self tmp = *this;--* this;return tmp;}private:iterator_type _it;};
}
list.h
#pragma once
#include<cassert>
#include"reverse_iterator.h"
namespace lx
{template <class T>struct ListNode{ListNode<T>* next;ListNode<T>* prev;T data;ListNode(const T& x=T()):next(nullptr),prev(nullptr),data(x){}};template <class T, class Ref, class Ptr>struct __list_iterator{typedef __list_iterator<T, const T&, const T*> const_iterator;typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<T, Ref, Ptr> Self;typedef ListNode<T>* Node;Node _node;__list_iterator(Node node) : _node(node) {}__list_iterator() {}__list_iterator(const iterator& x) : _node(x._node) {}//重载bool operator==(const Self& x) const{return _node == x._node;}bool operator!=(const Self& x) const{return _node != x._node;}//解引用重载Ref operator*() const{return _node->data;}//箭头重载Ptr operator->(){return &(_node->data);//return &(operator*());}//前置++Self& operator++(){_node = _node->next;return *this;}//后置++Self operator++(int){Self tmp = *this;++ *this;return tmp;}//前置--Self& operator--(){_node = _node->prev;return *this;}//后置--Self operator--(int){Self tmp = *this;-- *this;return tmp;}};//template <class T, class Ref, class Ptr>//struct reverse__iterator//{// typedef reverse__iterator<T, const T&, const T*> const_reverse_iterator;// typedef reverse__iterator<T, T&, T*> reverse_iterator;// typedef reverse__iterator<T, Ref, Ptr> Self;// typedef ListNode<T>* Node;// Node _node;// reverse__iterator(Node node) : _node(node) {}// reverse__iterator() {}// reverse__iterator(const reverse_iterator& x) : _node(x._node) {}// //重载// bool operator==(const Self& x) const// {// return _node == x._node;// }// bool operator!=(const Self& x) const// {// return _node != x._node;// }// //解引用重载// Ref operator*() const// {// return _node->data;// }// //箭头重载// Ptr operator->()// {// return &(_node->data);// //return &(operator*());// }// //前置++// Self& operator++()// {// _node = _node->prev;// return *this;// }// //后置++// Self operator++(int)// {// Self tmp = *this;// ++* this;// return tmp;// }// //前置--// Self& operator--()// {// _node = _node->next;// return *this;// }// //后置--// Self operator--(int)// {// Self tmp = *this;// --* this;// return tmp;// }//};template <class T>class list{public:typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<T, const T&, const T*> const_iterator;typedef reverse__iterator<iterator, T&, T*> reverse_iterator;typedef reverse__iterator<const_iterator, const T&, const T*> const_reverse_iterator;void empty_init(){_head = new node;_head->next = _head;_head->prev = _head;}list(){empty_init();}~list(){clear();delete _head;_head = nullptr;}list(const list<T>& x){empty_init();/*iterator it = x.begin();while (it != x.end()){push_back(*it);}*/for (const auto& e : x){push_back(e);}}/*list<T>& operator=(const list<T>& x){if (this != &x){clear();for (const auto& e : x){push_back(e);}}return *this;}*/list<T>& operator=(list<T> x){swap(x);return *this;}//iterator begin(){//return iterator(_head->next);return _head->next;}iterator end(){//return iterator(_head);return _head;}/*reverse_iterator rbegin(){return reverse_iterator(--end());}reverse_iterator rend(){return reverse_iterator(end());}*/reverse_iterator rbegin(){return reverse_iterator(end());//这里变动了}reverse_iterator rend(){return reverse_iterator(begin());//这里变动了}const_iterator begin() const{//return iterator(_head->next);return _head->next;}const_iterator end() const{//return iterator(_head);return _head;}/*const_reverse_iterator rbegin() const{return reverse_iterator(--end());}const_reverse_iterator rend() const{return reverse_iterator(end());}*/const_reverse_iterator rbegin() const{return reverse_iterator(end());//这里变动了}const_reverse_iterator rend() const{return reverse_iterator(begin());//这里变动了}//bool empty() const{//return _head->prev == _head;return _head->next == _head;}size_t size() const{size_t count = 0;const_iterator it = begin();while (it != end()){++count;++it;}return count;}//T& front(){return *(begin());}const T& front() const{return *(begin());}T& back(){return *(--end());}const T& back() const{return *(--end());}//void swap(list<T>& x){std::swap(_head, x._head);}iterator insert(iterator position, const T& val){assert(position._node);node* cur = position._node;node* prev = cur->prev;node* newnode = new node(val);prev->next = newnode;newnode->prev = prev;newnode->next = cur;cur->prev = newnode;//return iterator(newnode);return newnode;}iterator erase(iterator position){assert(position._node);assert(!empty());node* cur = position._node;node* next = cur->next;node* prev = cur->prev;delete cur;prev->next = next;next->prev = prev;//return iterator(next);return next;}void push_back(const T& val){node* tail = _head->prev;node* newnode = new node(val);tail->next = newnode;newnode->prev = tail;newnode->next = _head;_head->prev = newnode;}/*void push_back(const T& val){insert(end(), val);}*/void push_front(const T& val){node* cur = begin()._node;node* newnode = new node(val);_head->next = newnode;newnode->prev = _head;newnode->next = cur;cur->prev = newnode;}/*void push_front(const T& val){insert(begin(), val);}*/void pop_back(){assert(!empty());node* cur = _head->prev;node* prev = cur->prev;delete cur;prev->next = _head;_head->prev = prev;}/*void pop_back(){erase(--end());}*/void pop_front(){assert(!empty());node* cur = begin()._node;node* next = cur->next;delete cur;_head->next = next;next->prev = _head;}/*void pop_front(){erase(begin());}*/void resize(size_t n, T val = T()){if (n != size()){if (n > size()){size_t len = n - size();for (size_t i = 0; i < len; i++){push_back(val);}}else{size_t len = size() - n;for (size_t i = 0; i < len; i++){pop_back();}}} }void clear(){assert(!empty());iterator it = begin();while (it != end()){it=erase(it);}}private:typedef ListNode<T> node;node* _head;};}
test.cpp//这个没变
#include<iostream>
using namespace std;
#include"reverse_iterator.h"
#include"list.h"namespace lx
{void test2(){list<int> l1;l1.push_back(1);l1.push_back(2);l1.push_back(3);l1.push_back(4);l1.push_back(5);auto rit = l1.rbegin();while (rit != l1.rend()){cout << *rit << " ";++rit;}cout << endl;}
}int main()
{lx::test2();return 0;
}
同理在vector容器中也是一样：也就是我说的使用容器适配器思想写一个“万能的”反向迭代器。
reverse_iterator.h
#pragma once
//namespace lx
//{
//
// template<class iterator_type,class Ref,class Ptr>
// struct reverse__iterator
// {
// public:
// typedef reverse__iterator<iterator_type, Ref, Ptr> Self;
//
// reverse__iterator(const iterator_type& it)
// :_it(it)
// {}
//
// //重载
// bool operator==(const Self& x) const
// {
// return _it == x._it;
// }
// bool operator!=(const Self& x) const
// {
// return _it != x._it;
// }
//
// //解引用重载
// Ref operator*() const
// {
// return *_it;
// }
// //箭头重载
// Ptr operator->()
// {
// return &(operator*());
// }
//
// //前置++
// Self& operator++()
// {
// --_it;
// return *this;
// }
// //后置++
// Self operator++(int)
// {
// Self tmp = *this;
// ++* this;
// return tmp;
// }
//
// //前置--
// Self& operator--()
// {
// ++_it;
// return *this;
// }
// //后置--
// Self operator--(int)
// {
// Self tmp = *this;
// --* this;
// return tmp;
// }
// private:
// iterator_type _it;
// };
//}namespace lx
{template<class iterator_type, class Ref, class Ptr>struct reverse__iterator{public:typedef reverse__iterator<iterator_type, Ref, Ptr> Self;reverse__iterator(const iterator_type& it):_it(it){}//重载bool operator==(const Self& x) const{return _it == x._it;}bool operator!=(const Self& x) const{return _it != x._it;}//解引用重载Ref operator*() const{iterator_type tmp = _it;--tmp;return *tmp;}//箭头重载Ptr operator->(){return &(operator*());}//前置++Self& operator++(){--_it;return *this;}//后置++Self operator++(int){Self tmp = *this;++* this;return tmp;}//前置--Self& operator--(){++_it;return *this;}//后置--Self operator--(int){Self tmp = *this;--* this;return tmp;}private:iterator_type _it;};
}
vector.h
#pragma once
#include<cassert>
#include"reverse_iterator.h"
namespace lx
{template<class T>class vector{public:typedef T* iterator;typedef const T* const_iterator;typedef reverse__iterator<iterator, T&, T*> reverse_iterator;typedef reverse__iterator<const_iterator, const T&, const T*> const_reverse_iterator;/*vector():_start(nullptr), _finish(nullptr), _end_of_storage(nullptr){}*///因为我们在成员变量那里给了缺省值，这个缺省值就是给初始化列表使用的//所以我们就可以写成下面那样，简洁些。当然，你也可以写成上面那样。vector() {}//默认构造~vector(){if (_start){delete[] _start;_start = nullptr;_finish = nullptr;_end_of_storage = nullptr;}}/*vector(const vector& x)//拷贝构造传统写法{size_t x_size = x.size();size_t x_capacity = x.capacity();_start = new T[x_capacity];_finish = _start + x_size;_end_of_storage = _start + x_capacity;for (size_t i = 0; i < x_size; i++){_start[i] = x[i];}}*/vector(const vector& x)//拷贝构造现代写法{reserve(x.capacity());/*for (size_t i = 0; i < x.size(); i++){push_back(x[i]);}*/for (const auto& e : x){push_back(e);}}template <class InputIterator>vector(InputIterator first, InputIterator last){while (first != last){push_back(*first);++first;}}vector(size_t n, const T& val = T()){resize(n, val);}vector(int n, const T& val = T()){resize(n, val);}vector<T>& operator=(const vector<T>& x)//赋值重载传统写法{size_t x_size = x.size();size_t x_capacity = x.capacity();delete[] _start;_start = new T[x_capacity];_finish = _start + x_size;_end_of_storage = _start + x_capacity;for (size_t i = 0; i < x_size; i++){_start[i] = x[i];}return *this;}//vector<T>& operator=(vector<T> x)//赋值重载现代写法//{// swap(x);// return *this;//}//Iterators:iterator begin(){return _start;}const_iterator begin() const{return _start;}iterator end(){return _finish;}const_iterator end() const{return _finish;}//这里是反向迭代器reverse_iterator rbegin(){return reverse_iterator(end());}reverse_iterator rend(){return reverse_iterator(begin());}const_reverse_iterator rbegin() const{return reverse_iterator(end());}const_reverse_iterator rend() const{return reverse_iterator(begin());}//Capacity:size_t size() const{return size_t(end() - begin());}size_t capacity() const{return size_t(_end_of_storage - begin());}bool empty() const{return begin() == end();}void reserve(size_t n){if (n > capacity()){size_t old_size = size();T* tmp = new T[n];for (size_t i = 0; i < old_size; i++){tmp[i] = _start[i];}delete[] _start;_start = tmp;_finish = _start + old_size;_end_of_storage = _start + n;}}void resize(size_t n, T val = T()){size_t old_size = size();if (n > old_size){reserve(n);for (size_t i = old_size; i < n; i++){_start[i] = val;++_finish;}}else{//_finish = _finish - (old_size - n);_finish = _start + n;}}/*void resize(size_t n, T val = T()){if (n > size()){reserve(n);while (_finish < _start + n){*_finish = val;++_finish;}}else{_finish = _start + n;}}*///Element access://元素访问T& front(){return *begin();}const T& front() const{return *begin();}T& back(){return *(end() - 1);}const T& back() const{return *(end() - 1);}T& operator[](size_t n){return *(begin() + n);}const T& operator[](size_t n) const{return *(begin() + n);}//Modifiers:void push_back(const T& val){if (end() == _end_of_storage){size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;reserve(newcapacity);}//_start[size()] = val;*_finish = val;++_finish;}void pop_back(){assert(!empty());--_finish;}iterator insert(iterator position, const T& val){assert(position <= _finish);assert(position >= _start);if (end() == _end_of_storage){size_t len = position - _start;size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;reserve(newcapacity);position = _start + len;}iterator finish = end();while (finish != position){*finish = *(finish - 1);--finish;}*position = val;++_finish;return position;}iterator erase(iterator position){assert(position <= _finish);assert(position >= _start);assert(!empty());iterator pos = position;while (pos != end()){*pos = *(pos + 1);++pos;}--_finish;return position;}void swap(vector<T>& x){std::swap(_start, x._start);std::swap(_finish, x._finish);std::swap(_end_of_storage, x._end_of_storage);}private:iterator _start = nullptr;iterator _finish = nullptr;iterator _end_of_storage = nullptr;};}
test.cpp
#include<iostream>
using namespace std;
#include"reverse_iterator.h"
#include"vector.h"
namespace lx
{void test3(){vector<int> l1;l1.push_back(1);l1.push_back(2);l1.push_back(3);l1.push_back(4);l1.push_back(5);auto rit = l1.rbegin();while (rit != l1.rend()){cout << *rit << " ";++rit;}cout << endl;}
}int main()
{lx::test3();return 0;
}