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;
}