C++:反向迭代器-reverse_iterator

最新推荐文章于 2024-06-07 21:15:28 发布

Faiz..

最新推荐文章于 2024-06-07 21:15:28 发布

阅读量1.1k

点赞数 22

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/decade777555/article/details/135843567

版权

C++ 专栏收录该内容

28 篇文章 2 订阅

订阅专栏

1.关于反向迭代器

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

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

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

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

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

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

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

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

1.构造

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

2.base

返回基迭代器的拷贝。

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

// reverse_iterator::base example
#include <iostream>     // std::cout
#include <iterator>     // std::reverse_iterator
#include <vector>       // std::vector

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

  typedef std::vector<int>::iterator iter_type;

  std::reverse_iterator<iter_type> rev_end (myvector.begin());
  std::reverse_iterator<iter_type> 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 <iostream>     // std::cout
#include <iterator>     // std::reverse_iterator
#include <vector>       // std::vector

int main () {
  std::vector<int> 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<int>::iterator iter_type;

  std::reverse_iterator<iter_type> 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<class Iterator,class Ref,class Ptr>
	struct Reverse_iterator
	{
		Iterator _it;
		typedef Reverse_iterator<Iterator, Ref, Ptr> 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 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;
		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<T>& 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<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}


		vector<T>& operator=(vector<T> 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<class InputIterator>
		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<iostream>
using namespace std;
#include"iterator.h"

int main()
{
	wjc::vector<int> 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<int>::reverse_iterator it = v.rebegin();
	while (it != v.reend())
	{
		cout << *it << " ";
		it++;
	}

	return 0;
}

小结

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

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

Faiz..

关注

22
点赞
踩
19

收藏

觉得还不错? 一键收藏
1
评论
C++:反向迭代器-reverse_iterator

在C++中，可以使用反向迭代器来逆序遍历容器中的元素。反向迭代器是通过rbegin()和rend()方法来获取的，它们分别指向容器的最后一个元素和第一个元素的前一个位置。此类反转双向或随机访问迭代器循环访问范围的方向。原始迭代器（基础迭代器）的副本保留在内部，用于反映在reverse_iterator上执行的操作：每当reverse_iterator递增时，其基本迭代器就会减少，反之亦然。可以随时通过调用成员 base 获取具有当前状态的基迭代器的副本。
复制链接

扫一扫