C++ 反向迭代器的模拟实现思路

目录

一 构造ReverseIterator

二 vectpr反向迭代器实现思路

三 List 反向迭代器实现思路

---

一 构造ReverseIterator

#pragma once

template<class Iterator, class Ref, class Ptr>

struct ReverseIterator
{
	typedef ReverseIterator<Iterator, Ref, Ptr> Self;
	Iterator cur;
	ReverseIterator(Iterator it)
		:cur(it)
	{}


	Self& operator++()
	{
		--cur;
		return *this;
	}

	Ref operator*()
	{
		Self tmp = cur;
		--tmp;
		return *tmp;
	}

	bool operator !=(const Self& s)
	{
		cur != s.cur;
	}

};

注意 *的操作方法为什么要--, 因为正向迭代器和反向迭代器是相反的, 前者如果是第一个, 那后者就是最后一个

二 vectpr反向迭代器实现思路

#pragma once
#include<assert.h>
#include"ReverseIterator.h"

namespace yf
{
	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;


		vector()
		{}

		// v2(v1)
		vector(const vector<T>& v)
		{
			reserve(v.capacity());
			for (const auto& e : v)
			{
				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);
		}

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

		// v1 = v3
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}

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

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

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

三 List 反向迭代器实现思路

#pragma once
#include<assert.h>
#include"ReverseIterator.h"

namespace yf
{
    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 ListNode<T> Node;
        typedef __list_iterator<T, Ref, Ptr> self;
        Node* _node;

        __list_iterator(Node* x)
            :_node(x)
        {}

        self& operator++()//前缀++
        {
            _node = _node->_next;
            return *this;
        }

        self operator++(int)//后缀++
        {
            self tmp(*this);
            _node = _node->_next;
            return tmp;
        }

        self& operator--()
        {
            _node = _node->_prev;
            return *this;
        }

        self operator--(int)
        {
            self tmp(*this);

            _node = _node->_prev;

            return tmp;
        }

        Ref operator*()
        {
            return _node->_data;
        }

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

        bool operator!=(const self& s)
        {
            return _node != s._node;
        }

        bool operator==(const self& s)
        {
            return _node == s._node;
        }
    };

    template<class T>
    class list
    {
        typedef ListNode<T> Node;
    public:
        typedef __list_iterator<T, T&, T*> iterator;
        typedef __list_iterator<T, const T&, const T*> const_iterator;

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

        //typedef __list_const_iterator<T> const_iterator;

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

        reverse_iterator rend()
        {
            return 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;
        }
    };
}

总结:

本节只是简要提供一下反向迭代器实现的思路, 以vector和list为例. 对思路扩展和编程思想有很大的提高