C++:反向迭代器-reverse_iterator

目录

1.关于反向迭代器

2.反向迭代器的成员函数

1.构造

2.base

3.operator*

4.operator++

5.operator--

6.operator->

7.operator[]

3.反向迭代器的模拟实现

小结


1.关于反向迭代器

在C++中,可以使用反向迭代器来逆序遍历容器中的元素。反向迭代器是通过rbegin()和rend()方法来获取的,它们分别指向容器的最后一个元素和第一个元素的前一个位置。

此类反转双向或随机访问迭代器循环访问范围的方向。

原始迭代器(基础迭代器)的副本保留在内部,用于反映在reverse_iterator上执行的操作:每当reverse_iterator递增时,其基本迭代器就会减少,反之亦然。可以随时通过调用成员 base 获取具有当前状态的基迭代器的副本。

但请注意,当迭代器被反转时,反转的版本不会指向范围内的同一元素,而是指向它前面的元素。

反向迭代器的操作和正向迭代器大致相同,但是要特别注意++操作符,它会使反向迭代器指向前一个元素。

2.反向迭代器的成员函数

reverse_iterator的成员函数实现了反向迭代器的基本功能

C++:反向迭代器-reverse_iterator_第1张图片

下面介绍一些常用的功能:

1.构造

(1) 默认构造函数
构造一个不指向任何对象的反向迭代器。内部基迭代器是值初始化的。
(2) 初始化构造函数
从某个原始迭代器构造一个反向迭代器。构造对象的行为复制了原始对象,只是它以相反的顺序迭代其尖元素。
(3) 复制/类型转换构造函数
从其他反向迭代器构造反向迭代器。构造的对象保持与rev_it相同的迭代感。 

2.base

返回基迭代器的拷贝。

基迭代器是与用于构造reverse_iterator的迭代器类型相同的迭代器,但指向reverse_iterator当前指向的元素旁边的元素(reverse_iterator相对于其基迭代器的偏移量始终为 -1)。

// reverse_iterator::base example
#include      // std::cout
#include      // std::reverse_iterator
#include        // std::vector

int main () {
  std::vector myvector;
  for (int i=0; i<10; i++) myvector.push_back(i);

  typedef std::vector::iterator iter_type;

  std::reverse_iterator rev_end (myvector.begin());
  std::reverse_iterator rev_begin (myvector.end());

  std::cout << "myvector:";
  for (iter_type it = rev_end.base(); it != rev_begin.base(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

3.operator*

返回对迭代器指向的元素的引用。

在内部,该函数减少其基本迭代器的副本,并返回取消引用它的结果。

迭代器应指向某个对象,以便可取消引用。

4.operator++

将reverse_iterator提升一个位置。

在内部,预增量版本 (1) 递减对象保留的基本迭代器(就像对它应用运算符一样)。

递增版本 (2) 的实现行为等效于:

reverse_iterator operator++(int) {
  reverse_iterator temp = *this;
  ++(*this);
  return temp;
}

5.operator--

将reverse_iterator减少一个位置。

在内部,预递减版本 (1) 递增对象保留的基本迭代器(就像对其应用运算符 ++ 一样)。

递减后版本 (2) 的实现行为等效于:

reverse_iterator operator--(int) {
  reverse_iterator temp = *this;
  --(*this);
  return temp;
}

6.operator->

 返回指向迭代器指向的元素的指针(以便访问其成员之一)。

pointer operator->() const {
  return &(operator*());
}

7.operator[]

访问距离迭代器当前指向的元素 n 个位置的元素。

如果此类元素不存在,则会导致未定义的行为。

在内部,该函数访问其基本迭代器的适当元素,返回与:base()[-n-1] 相同的元素。

// reverse_iterator::operator[] example
#include      // std::cout
#include      // std::reverse_iterator
#include        // std::vector

int main () {
  std::vector myvector;
  for (int i=0; i<10; i++) myvector.push_back(i);  // myvector: 0 1 2 3 4 5 6 7 8 9

  typedef std::vector::iterator iter_type;

  std::reverse_iterator rev_iterator = myvector.rbegin();

  std::cout << "The fourth element from the end is: " << rev_iterator[3] << '\n';

  return 0;
}

3.反向迭代器的模拟实现

这里的反向迭代器与自定义的vector适配,定义了基本功能。

#pragma once
namespace wjc
{
	template
	struct Reverse_iterator
	{
		Iterator _it;
		typedef Reverse_iterator self;
		
		
		Reverse_iterator(Iterator it)
			:_it(it)
		{
		}

		Ref operator*()
		{
			Iterator tmp = _it;
			return *(--tmp);
		}

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

		self& operator++()//前置++
		{
			--_it;
			return *this;
		}
		self& operator++(int)//后置++
		{
			--_it;
			return *this;
		}
		self& operator--()//前置--
		{
			++_it;
			return *this;
		}
		self& operator--(int)//后置--
		{
			++_it;
			return *this;
		}
		bool operator!=(const self&s)
		{
			return _it != s._it;
		}
	};

	template 
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		typedef Reverse_iterator reverse_iterator;
		typedef Reverse_iterator const_reverse_iterator;
		const_reverse_iterator rebegin() const
		{
			return const_reverse_iterator(end());
		}

		const_reverse_iterator reend() const
		{
			return const_reverse_iterator(begin());
		}
		reverse_iterator rebegin() 
		{
			return reverse_iterator(end());
		}

		reverse_iterator reend() 
		{
			return reverse_iterator(begin());
		}
		vector()
			: _start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
		}
		vector(const vector& v)
		{
			reserve(v.capacity());
			for (const auto& e : v)
			{
				push_back(e);
			}
		}
		iterator begin()
		{
			return _start;
		}


		iterator end()
		{
			return _finish;
		}
		const_iterator begin() const
		{
			return _start;
		}


		const_iterator end() const
		{
			return _finish;
		}
		size_t capacity()const
		{
			return _endofstorage - _start;
		}
		size_t size()const
		{
			return  _finish - _start;
		}


		void push_back(const T& a)
		{
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = a;
			_finish++;
		}


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


		vector& operator=(vector v)
		{
			swap(v);
			return *this;
		}


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


		}
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldsize = size();
				T* tmp = new T[n];
				if (_start)
				{
					/*memcpy(tmp, _start, sizeof(T) * oldsize);*/
					for (size_t i = 0; i < oldsize; i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + oldsize;
				_endofstorage = _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;
			}
		}




		void pop_back()
		{
			assert(size() > 0);
			--_finish;
		}
		void insert(iterator pos, T x)
		{
			assert(pos <= _finish);
			assert(pos >= _start);
			size_t len = pos - _start;
			if (_finish == _endofstorage)
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);//pos 扩容失效
				//更新pos位置
				pos = _start + len;
			}
			memmove(pos + 1, pos, (_finish - pos) * sizeof(T));
			*pos = x;
			++_finish;
		}


		void erase(iterator pos)
		{
			assert(pos < _finish);
			assert(pos >= _start);
			iterator it = pos + 1;
			while (it < _finish)
			{
				*(it - 1) = *it;
				++it;
			}
			_finish--;
		}


		T& operator[](size_t pos)
		{
			assert(pos, size());
			return _start[pos];
		}
		const T& operator[](size_t pos)const
		{
			assert(pos, size());
			return _start[pos];
		}
		template
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
	private:


		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};




}

测试

#define  _CRT_SECURE_NO_WARNINGS
#include
using namespace std;
#include"iterator.h"

int main()
{
	wjc::vector v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);
	wjc::vector::reverse_iterator it = v.rebegin();
	while (it != v.reend())
	{
		cout << *it << " ";
		it++;
	}

	return 0;
}

 C++:反向迭代器-reverse_iterator_第2张图片

小结

        在使用反向迭代器时要注意迭代器的失效问题,特别是在进行插入和删除操作时,要小心迭代器的有效性。

        总之,反向迭代器是一个非常有用的工具,可以方便地逆序遍历容器中的元素,提供了在处理逆序数据时的便利。

 

你可能感兴趣的:(C++,c++,开发语言)