反向迭代器---迭代器适配器

reverse_iterator认识

链接：文档

成员类型

迭 代
单相迭代器、双向迭代器类型、随机访问迭代器

功能类型参见下图：

reverse_iterator 模拟实现

链接：reverse_iterator 模拟实现代码
实现的方法
执行的操作：每当 递增时，其基迭代器就会减少，反之亦然。
意思就是复用正向迭代器。
具体代码如下：

#pragma once

namespace Ding
{
	template <class Iterator, class Ref, class Ptr>
	struct __reverse_iterator
	{
		Iterator _cur;
		typedef __reverse_iterator<Iterator, Ref, Ptr> RIterator;

		__reverse_iterator(Iterator it)
			: _cur(it)
		{}

		RIterator operator++()
		{
			--_cur;
			return *this;
		}

		RIterator operator--()
		{
			++_cur;
			return *this;
		}

		Ref operator*()
		{
			auto tmp(_cur);//解引用不改变位置
			--tmp;//反向迭代器开始的位置是正向迭代器结束的位置也就是最后一个元素的下一个位置；所以要--。
			return *tmp;
		}

		Ptr operator->()
		{
			//return _cur.operator->();//可以复用正向迭代器的->
			return &(operator*());
		}

		bool operator != (const RIterator& it)const
		{
			return _cur != it._cur;
		}

	};

}

注意：
->和*的重载…也就是迭代器存在的意义是不暴露底层实现细节的情况下提供了统一的方式去访问容器屏蔽底层实现细节，体现封装价值和力量。

reverse_iterator在list内部的使用

如图：

typedef  __reverse_iterator<iterator, T&, T*> reverse_iterator;
typedef  __reverse_iterator<iterator, const T&, const T*> const_reverse_iterator;

reverse_iterator rbegin()
{
	return reverse_iterator(end());//复用
}

const_reverse_iterator rbegin() const
{
	return const_reverse_iterator(end());
}

reverse_iterator rend()
{
	return reverse_iterator(begin());
}

const_reverse_iterator rend() const
{
	return const_reverse_iterator(begin());
}

list整体模拟实现的代码：

namespace Ding
{
	template <class T>
	struct list_node
	{
		T _date;
		list_node<T>* _prev;
		list_node<T>* _next;

		list_node(const T& x = T())
			: _date(x)
		, _prev(nullptr)
		, _next(nullptr)
		{}
		
	};

	/*List 的迭代器
		迭代器有两种实现方式，具体应根据容器底层数据结构实现：
		1. 原生态指针，比如：vector
		2. 将原生态指针进行封装，因迭代器使用形式与指针完全相同，因此在自定义的类中必须实现以下方法：
		1. 指针可以解引用，迭代器的类中必须重载operator * ()
		2. 指针可以通过->访问其所指空间成员，迭代器类中必须重载oprator->()
		3. 指针可以++向后移动，迭代器类中必须重载operator++()与operator++(int)
		至于operator--() / operator--(int)释放需要重载，根据具体的结构来抉择，双向链表可以向前             移动，所以需要重载，如果是forward_list就不需要重载--
		4. 迭代器需要进行是否相等的比较，因此还需要重载operator == ()与operator != ()*/

	template <class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> iterator;

		//find  编译器的检测
		typedef bidirectional_iterator_tag iterator_category;
		typedef T value_type;
		typedef Ptr pointer;
		typedef Ref reference;
		typedef ptrdiff_t difference_type;

		__list_iterator(Node* node = nullptr)
			:_node(node)
		{};


		// 具有指针类似行为
		Ref operator*()
		{
			return _node->_date;
		}

		Ptr operator->()
		{
			return &(operator*());
			//return &(*_node);
		}

		bool operator == (const iterator& it)const
		{
			return _node == it._node;
		}

		bool operator != (const iterator& it)const
		{
			return _node != it._node;
		}

		iterator& operator++()
		{
			_node = _node->_next;

			return *this;
		}

		iterator operator++(int)
		{
			iterator tmp(*this);
			_node = _node->_next;

			return tmp;
		}

		iterator& operator--()
		{
			_node = _node->_prev;

			return *this;
		}

		iterator operator--(int)
		{
			iterator tmp(*this);
			_node = _node->_prev;

			return tmp;
		}

		Node* _node;
	};

	template <class T>
	class list
	{
		typedef list_node<T> Node;
	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<iterator, const T&, const T*> const_reverse_iterator;


		//哨兵位头结点
		void CreateHead()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}

		list()
		{
			CreateHead();
		}

		iterator begin()
		{
			return iterator(_head->_next);
		}

		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}

		const_iterator end() const
		{
			return const_iterator(_head);
		}



		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

		const_reverse_iterator rbegin() const
		{
			return const_reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}

		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(begin());
		}




		void push_back(const T& x)
		{
			/*Node* tail = _head->_prev;
			Node* newnode = new Node(x);

			newnode->_prev = tail;
			newnode->_next = _head;
			tail->_next = newnode;
			_head->_prev = newnode;*/

			insert(end(), x);
		}

		void push_front(const T& x)
		{
			insert(begin(), x);
		}

		iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;

			Node* newnode = new Node(x);

			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			prev->_next = newnode;

			return iterator(newnode);
		}

		void pop_back()
		{
			erase(--end());
		}

		void pop_front()
		{
			erase(begin());
		}

		iterator erase(iterator pos)
		{
			assert(pos != end());

			Node* cur = pos._node;
			Node* next = cur->_next;
			Node* prev = cur->_prev;

			prev->_next = next;
			next->_prev = prev;
			delete cur;

			return iterator(next);
		}

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}

		}


		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}


		template <class Iterator>
		list(Iterator first, Iterator last)
		{
			CreateHead();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		void swap(list<T>& x)
		{
			std::swap(x._head, _head);
		}

		list(const list<T>& l)
		{
			CreateHead();

			// 用l中的元素构造临时的temp,然后与当前对象交换
			list<T> temp(l.begin(), l.end());
			swap(temp);
		}

		list<T>& operator=(list<T> l)
		{
			swap(l);
			return *this;
		}

	private:
		Node* _head;
	};

结果展示：

reverse_iterator在vector内部的使用

如图：

vector同样保持对称和镜像的“特点”

完整模拟代码：

#pragma once
#define _CRT_SECURE_NO_WARNINGS


#include
#include
#include
#include
#include

#include"reverse_iterator.h"

using namespace std;

namespace Ding
{
	template <class T>
	class vector
	{
	public:

		// Vector的迭代器是一个原生指针
		typedef T* iterator;
		typedef const T* const_iterator;

		typedef  __reverse_iterator<iterator, T&, T*> reverse_iterator;
		typedef  __reverse_iterator<iterator, const T&, const T*> const_reverse_iterator;
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

		const_reverse_iterator rbegin() const
		{
			return const_reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}

		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(begin());
		}


		//
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}

		vector(int n, const T& value = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			resize(n, value);
		}

		vector(size_t n, const T& value = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			resize(n, value);
		}

		template<class InputIterator>

		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(v.capacity());
			//一个一个数据的尾插。
			for (auto e : v)
			{
				push_back(e);
			}
		}

		vector<T>& operator= (vector<T> v)
		{
			swap(v);

			return *this;
		}

		~vector()
		{
			delete[] _start;
			_start = _finish = _end_of_storage = nullptr;
		}

		//
		size_t size() const
		{
			return _finish - _start;
		}

		size_t capacity() const
		{
			return _end_of_storage - _start;
		}

		bool empty() const
		{
			return _start == _finish;
		}

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();
				T* tmp = new T[n];

				if (_start)
				{
					//memcpy(tmp, _start, sz * sizeof(T)); //内部浅拷贝
					for (size_t i = 0; i < sz; ++i)
						tmp[i] = _start[i];

					//释放旧空间
					delete[] _start;
				}

				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}

		}

		void resize(size_t n, const T& value = T())
		{
			if (n > size())
			{
				// 2.空间不够则增容
				if (n > capacity())
					reserve(n);

				//插入
				size_t sz = size();
				for (size_t i = 0; i < n - sz; ++i)
				{
					*_finish = value;
					++_finish;
				}

			}
			else
			{
				//缩小
				_finish = _start + n;
			}
		}


		//
		T& operator[](size_t pos)
		{
			assert(pos < size());
			
			return _start[pos];
		}

		const T& operator[](size_t pos)const
		{
			assert(pos < size());

			return _start[pos];
		}

		T& front()
		{
			return *_start;
		}

		const T& front()const
		{
			return *_start;
		}

		T& back()
		{
			return *(_finish - 1);
		}

		const T& back()const
		{
			return *(_finish - 1);
		}

		// 
		void push_back(const T& x)
		{
			//if (_finish == _end_of_storage)
			//{
			//	//扩容
			//	size_t cap = capacity() == 0 ? 4 : capacity() * 2;
			//	rserve(cap);
			//}

			//*_finish = x;
			//++_finish;

			insert(end(), x);	//复用
		}

		void pop_back()
		{
			assert(_finish > _start);

			//erase(end() - 1); 复用erase
			--_finish;
		}

		void swap(vector<T>& v)
		{
			::swap(_start, v._start);
			::swap(_finish, v._finish);
			::swap(_end_of_storage, v._end_of_storage);
		}

		iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start);
			assert(pos <= _finish);

			if (_finish == _end_of_storage)
			{
				//扩容
				size_t len = pos - _start;
				size_t cap = capacity() == 0 ? 4 : capacity() * 2;//pos地址要改变
				reserve(cap);
				pos = _start + len;
			}

			//挪动数据
			T* end = _finish;
			while (end > pos)
			{
				*end = *(end - 1);
				--end;
			}
			//pos位置放数据
			//*end = x;
			*pos = x;

			++_finish;

			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);

			//删除数据
			iterator begin = pos + 1;
			while (begin < _finish)
			{
				*(begin - 1) = *begin;
				++begin;
			}
			--_finish;

			return pos;
		}



	private:
		iterator _start;  // 指向数据块的开始
		iterator _finish; // 指向有效数据的尾
		iterator _end_of_storage; // 指向存储容量的尾
	};
}

结果展示：