【C++】33：反向迭代器的实现（扩展）

目录

一、源码及框架分析

二、实现反向迭代器

[2.1 反向迭代器的结构](#2.1 反向迭代器的结构)

[2.2 反向迭代器的运算符重载](#2.2 反向迭代器的运算符重载)

三、List实现反向迭代器

[3.1 List.h代码](#3.1 List.h代码)

[3.2 Iterator.h代码](#3.2 Iterator.h代码)

[3.3 test.cpp代码](#3.3 test.cpp代码)

四、vector实现反向迭代器

[4.1 vector.h代码](#4.1 vector.h代码)

[4.2 Iterator.h代码](#4.2 Iterator.h代码)

[4.3 test.cpp代码](#4.3 test.cpp代码)

---

一、源码及框架分析

// stl_list.h
template <class T, class Alloc = alloc>
class list {
public:
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef reverse_iterator<iterator> reverse_iterator;
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_bidirectional_iterator<const_iterator, value_type,
const_reference, difference_type> const_reverse_iterator;
typedef reverse_bidirectional_iterator<iterator, value_type, reference,
difference_type> reverse_iterator;
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
iterator begin() { return (link_type)((*node).next); }
const_iterator begin() const { return (link_type)((*node).next); }
iterator end() { return node; }
const_iterator end() const { return node; }

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());}
};
// stl_vector.h
template <class T, class Alloc = alloc>
class vector {
public:
typedef T value_type;
typedef value_type* iterator;

#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef reverse_iterator<iterator> reverse_iterator;
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_iterator<const_iterator, value_type, const_reference,
difference_type> const_reverse_iterator;
typedef reverse_iterator<iterator, value_type, reference, difference_type>
reverse_iterator;
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
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()); }
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());}
};
// stl_iterator.h
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
// This is the new version of reverse_iterator, as defined in the
// draft C++ standard. It relies on the iterator_traits template,
// which in turn relies on partial specialization. The class
// reverse_bidirectional_iterator is no longer part of the draft
// standard, but it is retained for backward compatibility.
template <class Iterator>
class reverse_iterator
{
protected:
Iterator current;
public:
typedef typename iterator_traits<Iterator>::iterator_category
iterator_category;
typedef typename iterator_traits<Iterator>::value_type
value_type;
typedef typename iterator_traits<Iterator>::difference_type
difference_type;
typedef typename iterator_traits<Iterator>::pointer
pointer;
typedef typename iterator_traits<Iterator>::reference
reference;
typedef Iterator iterator_type;
typedef reverse_iterator<Iterator> self;
public:
reverse_iterator() {}
explicit reverse_iterator(iterator_type x) : current(x) {}
reverse_iterator(const self& x) : current(x.current) {}
#ifdef __STL_MEMBER_TEMPLATES
template <class Iter>
reverse_iterator(const reverse_iterator<Iter>& x) : current(x.current) {}
#endif /* __STL_MEMBER_TEMPLATES */

iterator_type base() const { return current; }
reference operator*() const {
Iterator tmp = current;
return *--tmp;
}
#ifndef __SGI_STL_NO_ARROW_OPERATOR
pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
self& operator++() {
--current;
return *this;
}
self operator++(int) {
self tmp = *this;
--current;
return tmp;
}
self& operator--() {
++current;
return *this;
}
self operator--(int) {
self tmp = *this;
++current;
return tmp;
}
self operator+(difference_type n) const {
return self(current - n);
}
self& operator+=(difference_type n) {
current -= n;
return *this;
}
self operator-(difference_type n) const {
return self(current + n);
}
self& operator-=(difference_type n) {
current += n;
return *this;
}
reference operator[](difference_type n) const { return *(*this + n); }
};
template <class Iterator>
inline bool operator==(const reverse_iterator<Iterator>& x,
const reverse_iterator<Iterator>& y) {
return x.base() == y.base();
}
template <class Iterator>
inline bool operator<(const reverse_iterator<Iterator>& x,
const reverse_iterator<Iterator>& y) {
return y.base() < x.base();
}
template <class Iterator>
inline typename reverse_iterator<Iterator>::difference_type
operator-(const reverse_iterator<Iterator>& x,
const reverse_iterator<Iterator>& y) {
return y.base() - x.base();
}
template <class Iterator>
inline reverse_iterator<Iterator>
operator+(reverse_iterator<Iterator>::difference_type n,
const reverse_iterator<Iterator>& x) {
return reverse_iterator<Iterator>(x.base() - n);
}
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
// This is the old version of reverse_iterator, as found in the original
// HP STL. It does not use partial specialization.
template <class BidirectionalIterator, class T, class Reference = T&,
class Distance = ptrdiff_t>
class reverse_bidirectional_iterator {
typedef reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
Distance> self;
protected:
BidirectionalIterator current;
public:
typedef bidirectional_iterator_tag iterator_category;
typedef T value_type;
typedef Distance difference_type;
typedef T* pointer;
typedef Reference reference;
reverse_bidirectional_iterator() {}
explicit reverse_bidirectional_iterator(BidirectionalIterator x)
: current(x) {}
BidirectionalIterator base() const { return current; }
Reference operator*() const {
BidirectionalIterator tmp = current;
return *--tmp;
}
#ifndef __SGI_STL_NO_ARROW_OPERATOR
pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
self& operator++() {
--current;
return *this;
}
self operator++(int) {
self tmp = *this;
--current;
return tmp;
}
self& operator--() {
++current;
return *this;
}
self operator--(int) {
self tmp = *this;
++current;
return tmp;
}
};
template <class RandomAccessIterator, class T, class Reference = T&,
class Distance = ptrdiff_t>
class reverse_iterator {
typedef reverse_iterator<RandomAccessIterator, T, Reference, Distance>
self;
protected:
RandomAccessIterator current;
public:
typedef random_access_iterator_tag iterator_category;
typedef T value_type;
typedef Distance difference_type;
typedef T* pointer;
typedef Reference reference;
reverse_iterator() {}
explicit reverse_iterator(RandomAccessIterator x) : current(x) {}
RandomAccessIterator base() const { return current; }
Reference operator*() const { return *(current - 1); }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
self& operator++() {
--current;
return *this;
}
self operator++(int) {
self tmp = *this;
--current;
return tmp;
}
self& operator--() {
++current;
return *this;
}
self operator--(int) {
self tmp = *this;
++current;
return tmp;
}
self operator+(Distance n) const {
return self(current - n);
}
self& operator+=(Distance n) {
current -= n;
return *this;
}
self operator-(Distance n) const {
return self(current + n);
}
self& operator-=(Distance n) {
current += n;
return *this;
}
Reference operator[](Distance n) const { return *(*this + n); }
};
#endif //__STL_CLASS_PARTIAL_SPECIALIZATION

• 源码中我们可以看到reverse_iterator实现了两个版本，通过__STL_CLASS_PARTIAL_SPECIALIZATION条件编译控制使用哪个版本，简单点说就是支持偏特化的迭代器萃取以后，反向迭代器使用的是这个版本，template<class Iterator>class reverse_iterator;之前使用的是template <class BidirectionalIterator,class T，class Reference,class Distance>class reverse_bidirectional_iterator;template <class RandomAccessIterator,classT, classReference,class Distance>class reverse_iterator;
• 可以看到他们的差别主要是在模板参数是否传递迭代器指向的数据类型，支持偏特化的迭代器萃取以后就不需要给了，因为reverse_iterator内部可以通过迭代器萃取获取数据类型。迭代器萃取的本质是一个特化，这个还有有些小复杂且不影响我们学习主线内容，这里我们就不讲解了，有兴趣且基础功底好的同学想了解可以去看源码，有问题再跟老师讨论。这个我们主要使用模版参数传递数据类型的方式实现。
• 反向迭代器本质是一个适配器，使用模版实现，传递哪个容器的迭代器就可以封装适配出对应的反向迭代器。因为反向迭代器的功能跟正向的迭代器功能高度相似，只是遍历的方向相反，类似operator++底层调用迭代器的operator--等，所以封装一下就可以实现。
• 比较奇怪的是operator*的实现，内部访问的是迭代器当前位置的前一个位置。这个要结合容器中rbegin和rend实现才能看懂，rbegin返回的是封装end位置的反向迭代器，rend返回的是封装begin位置迭代器的反向迭代器，这里是为了实现出一个对称，所以解引用访问的是当前位置的前一个位置。

二、实现反向迭代器

2.1 反向迭代器的结构

namespace zx
{
	template<class Iterator,class Ref,class Ptr>
	struct ReverseIterator
	{
		ReverseIterator(Iterator it)
			:_it(it)
		{ }
		typedef ReverseIterator<Iterator, Ref, Ptr> Self;
		//适配器模式，反向迭代器里面有一个正向迭代器
		Iterator _it;
	};
}

2.2 反向迭代器的运算符重载

Ref operator*()
{
	Iterator tmp = _it;
	--tmp;
	return *tmp;
}
Ptr operator->()
{
	return &(operator*());
}
Self& operator++()
{
	--_it;
	return *this;
}
Self& operator--()
{
	++_it;
	return *this;
}
bool operator!=(const Self& s)
{
	return _it != s._it;
}
bool operator==(const Self& s)
{
	return _it == s._it;
}

三、List实现反向迭代器

List模拟实现

3.1 List.h代码

#pragma once
#include<iostream>
using namespace std;
#include<assert.h>
#include"Iterator.h"
namespace zx {
	template<class T>
	struct list_node
	{
		T _data;            //节点的数据
		list_node<T>* _prev; //节点的前指针
		list_node<T>* _next; //节点的后指针
		list_node(const T& x = T())//初始化列表进行初始化
			:_data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};

	template<class T, class Ref, class Ptr>
	struct list_iterator {
		typedef list_node<T> Node;
		typedef list_iterator<T, Ref, Ptr> Self;
		list_iterator(Node* node)
			:_node(node)
		{
		}
		Node* _node;
		Ref operator*() {
			return _node->_data;
		}
		Ptr operator->() {
			return &_node->_data;
		}
		Self& operator++() {
			_node = _node->_next;
			return *this;
		}
		Self& operator--() {
			_node = _node->_prev;
			return *this;
		}

		Self operator++(int) {
			//使用了拷贝构造，我们没有写拷贝构造，编译器会默认生成一个浅拷贝的拷贝构造，
			//我们新创建一个iteartor对象也是需要指向这个对象的，使用浅拷贝也能完成
			//并不是有指针就需要深拷贝，而是看指针指向的资源是不是属于我的，指针指向的资源是属于链表的
			Self tmp(*this);
			_node = _node->_next;
			return tmp;
		}
		Self operator--(int) {
			Self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}
		bool operator!=(const Self& s) const
		{
			return _node != s._node;
		}
		bool operator==(const Self& s) const
		{
			return _node == s._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;//const迭代器
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;  //反向迭代器
		typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;//const反向迭代器

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

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

		iterator begin()
		{
			return _head->_next;
		}
		iterator end()
		{
			return _head;
		}
		const_iterator begin() const
		{
			return _head->_next;
		}
		const_iterator end() const
		{
			return _head;
		}
		void empty_init()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
		list()
		{
			empty_init();
		}
		//用n个val个构造      			   
		list(int n, const T& val = T())
		{
			empty_init();
			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		//迭代器区间构造
		template<class iterator>
		list(iterator first, iterator last)
		{
			empty_init();
			while (first != last)
			{
				push_back(*first);//尾插数据，会根据不同类型的迭代器进行调用
				++first;
			}
		}
		//initializer_list构造
		list(initializer_list<int> il)
		{
			empty_init();
			for (auto& e : il) {
				push_back(e);
			}
		}
		//lt2<lt1>,拷贝构造函数
		list(const list<T>& lt)
		{
			empty_init();
			for (auto& e : lt) {
				push_back(e);
			}
		}
		//lt1=lt3 赋值运算符重载
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}
		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}
		void clear()
		{
			auto it = begin();
			while (it != end()) {
				it = erase(it);
			}
		}
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		void push_back(const T& x)
		{
			insert(end(), x);
		}
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
		void insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;

			Node* newnode = new Node(x);
			newnode->_next = cur;
			newnode->_prev = prev;
			prev->_next = newnode;
			cur->_prev = newnode;
			++_size;
		}
		void pop_back()
		{
			erase(--end());
		}
		void pop_front()
		{
			erase(begin());
		}
		iterator erase(iterator pos)
		{
			assert(pos != end());
			Node* prev = pos._node->_prev;
			Node* next = pos._node->_next;

			prev->_next = next;
			next->_prev = prev;
			delete pos._node;
			--_size;
			return iterator(next);
		}
		size_t size() const
		{
			return _size;
		}
		size_t empty() const
		{
			return _size == 0;
		}
	private:
		Node* _head;
		size_t _size;
	};
}

3.2 Iterator.h代码

#pragma once

namespace zx
{
	template<class Iterator,class Ref,class Ptr>
	struct ReverseIterator
	{
		typedef ReverseIterator<Iterator, Ref, Ptr> Self;

		ReverseIterator(Iterator it)
			:_it(it)
		{ }
		Ref operator*()
		{
			Iterator tmp = _it;
			--tmp;
			return *tmp;
		}
		Ptr operator->()
		{
			return &(operator*());
		}
		Self& operator++()
		{
			--_it;
			return *this;
		}
		Self& operator--()
		{
			++_it;
			return *this;
		}
		bool operator!=(const Self& s)
		{
			return _it != s._it;
		}
		bool operator==(const Self& s)
		{
			return _it == s._it;
		}
		//适配器模式，反向迭代器里面有一个正向迭代器
		Iterator _it;
	};
}

3.3 test.cpp代码

#include"List.h"

int main()
{
	//测试lt
	zx::list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	zx::list<int>::reverse_iterator rit = lt.rbegin();
	while (rit != lt.rend())
	{
		*rit += 2;
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

	//测试const lt
	const zx::list<int> lt1(lt);
	zx::list<int>::const_reverse_iterator rit1 = lt1.rbegin();
	while (rit1 != lt1.rend())
	{
		//*rit1 += 2; 报错
		cout << *rit1 << " ";
		++rit1;
	}
	return 0;
}

四、vector实现反向迭代器

vector模拟实现

4.1 vector.h代码

#pragma once
#include<iostream>
using namespace std;
#include<assert.h>
#include<string.h>
#include<string>
#include"Iterator.h"
namespace zx
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;

		reverse_iterator rbegin() {
			return reverse_iterator(end());
		}
		reverse_iterator rend() {
			return reverse_iterator(begin());
		}
		const_reverse_iterator rbegin() const
		{
			return const_reverse_iterator(end());
		}
		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(begin());
		}

		iterator begin() {
			return _start;
		}
		iterator end() {
			return _finish;
		}
		const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}
		vector() {}
		vector(const vector<T>& v)
		{
			reserve(v.size());
			for (auto& e : v) {
				push_back(e);
			}
		}
		~vector()
		{
			if (_start) {
				delete[] _start;
				_start = _finish = _end_of_storage = nullptr;
			}
		}
		void clear() {
			_finish = _start;
		}

		void swap(vector<T>& v) {
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_of_storage, v._end_of_storage);
		}
		vector<T>& operator=(vector<T> v) {
			swap(v);
			return *this;
		}

		template<class InputIterator>
		vector(InputIterator first, InputIterator last) {
			while (first != last) {
				push_back(*first);
				++first;
			}
		}
		vector(size_t n, const T& val = T()) {
			reserve(n);
			for (size_t i = 0; i < n; i++) {
				push_back(val);
			}
		}
		vector(int n, const T& val = T()) {
			reserve(n);
			for (int i = 0; i < n; i++) {
				push_back(val);
			}
		}
		
		size_t size() const
		{
			return _finish - _start;
		}
		size_t capacity() const
		{
			return _end_of_storage - _start;
		}
		T& operator[](size_t i) {
			assert(i < size());
			return _start[i];
		}
		const T& operator[](size_t i) const
		{
			assert(i < size());
			return _start[i];
		}
		void reserve(size_t n) {
			if (n > capacity()) {
				T* tmp = new T[n];
				size_t old_size = size();
				//memcpy(tmp, _start, size() * sizeof(T));
				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 push_back(const T& x) {
			//满了，需要扩容
			if (_finish == _end_of_storage) {
				reserve(capacity() == 0 ? 4 : 2 * capacity());
			}
			*_finish = x;
			_finish++;
		}
		bool empty() {
			return _start == _finish;
		}
		void pop_back() {
			assert(!empty());
			--_finish;
		}
		iterator  insert(iterator pos, const T& x) {
			if (_finish == _end_of_storage) {
				//记录相对位置
				size_t relative = pos - _start;
				reserve(capacity() == 0 ? 4 : 2 * capacity());
				pos = _start + relative;
			}
			iterator end = _finish - 1;
			while (end >= pos) {
				*(end + 1) = *end;
				end--;
			}
			*pos = x;
			_finish++;
			return pos;
		}
		iterator erase(iterator pos) {
			assert(pos >= _start);
			assert(pos < _finish);
			iterator it = pos + 1;
			while (it != end()) {
				*(it - 1) = *it;
				it++;
			}
			_finish--;
			return pos;
		}
		void resize(size_t n, T val = T())
		{
			if (n < size()) {
				_finish = _start + n;
			}
			else {
				reserve(n);
				while (_finish < _start + n) {
					*_finish = val;
					_finish++;
				}
			}
		}
	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

4.2 Iterator.h代码

#pragma once

namespace zx
{
	template<class Iterator,class Ref,class Ptr>
	struct ReverseIterator
	{
		typedef ReverseIterator<Iterator, Ref, Ptr> Self;

		ReverseIterator(Iterator it)
			:_it(it)
		{ }
		Ref operator*()
		{
			Iterator tmp = _it;
			--tmp;
			return *tmp;
		}
		Ptr operator->()
		{
			return &(operator*());
		}
		Self& operator++()
		{
			--_it;
			return *this;
		}
		Self& operator--()
		{
			++_it;
			return *this;
		}
		bool operator!=(const Self& s)
		{
			return _it != s._it;
		}
		bool operator==(const Self& s)
		{
			return _it == s._it;
		}
		//适配器模式，反向迭代器里面有一个正向迭代器
		Iterator _it;
	};
}

4.3 test.cpp代码

#include"vector.h"

int main()
{
	zx::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);

	zx::vector<int>::reverse_iterator it = v1.rbegin();
	while (it != v1.rend())
	{
		*it += 2;
		cout << *it << " ";
		++it;
	}
	cout << endl;
	cout << "-----------------" << endl;
	const zx::vector<int> v2(v1);
	zx::vector<int>::const_reverse_iterator it1 = v2.rbegin();
	while (it1 != v2.rend())
	{
		//*it1 += 2; 报错
		cout << *it1 << " ";
		++it1;
	}
	cout << endl;
	return 0;
}