反向迭代器reverse_iterator模拟实现_reverse_iterator 头文件

准备工作

1. 相同的命名空间可以分割在不同的文件中,编译器最后都会合成在同一个命名空间下。
2. 我们的reverse_iterator是个适配器，为什么叫适配器，是因为它需用正向迭代器做适配。简言之，反向迭代器通过正向迭代器做实例化会减少很多冗余且方便很多。
3. 把reverse_iterator放在另外一个.h头文件中，而我们将把这个头文件引入到list.h中，给list造一个反向迭代器。

反向迭代器模拟实现

• 反向迭代器与正向迭代器的关系：
  STL源码中如下：
  
  正向和反向迭代器的begin()和end()相反，是对称的，这种关系使得反向迭代器解引用时，我们应该往前倒一下，再解引用。

• 模板使用
  因为需要用正向迭代器来适配，此外还要考虑==const类型反向迭代器（因为像重载解引用函数和重载->不能构成函数重载，因为这里不传参，只是返回值类型不同）。==所以参数为：正向迭代器、引用、指针。

• 成员变量：
  显然，它需要一个正向迭代器作为成员变量，我们的构造函数就以正向迭代器来初始反向迭代器。做成员变量的赋值即可。

• operator*()
  我们要的是解引用当前迭代器，应该返回引用，因为需要有修改值本身的权限，且正向迭代器返回重载*返回的也是引用，所以这里继续用引用Ref，此外。此外，因为和正向迭代器相反，解引用应该给前面倒一个。

Ref operator*()
{
	Iterator tmp = _it;
	return *(--tmp);
}
1
2
3
4
5

• operator->()
  指向节点存着对象时，我们要对象指针，也就是对象地址，所以要先解引用再取&。

Ptr operator->()
{
	return &(operator*());
}
1
2
3
4

• operator++()
  ++反向迭代器我们应该让成员变量正向迭代器做–。（我之前发现运行出错是因为我的正向迭代器–写错了），先–，再解引用，要的是迭代器对象，所以返回*this，用引用类型接收。

Self& operator++()
{
	--_it;
	return *this;
}
1
2
3
4
5

• operator–()
  同++相反

Self& operator--()
{
	++_it;
	return *this;
}
1
2
3
4
5

#pragma once
#include<iostream>
using namespace std;

// 在别的文件中也可以起同名的命名空间，且在别的文件中兼容
namespace lz
{
	// 适配器 -- 复用	：在声明处给的iterator 比如list那里的iterator
	/* 
		在list中 有如下的情况 
	// 反向迭代器也分普通和cosnt类型
        typedef ListIterator<iterator, T&, T*> riterator;
        typedef ListIterator<const_iterator, const T&, const T&> const_riterator;
	*/
	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)
		{}

		// 使用模板还是为了区分const和普通类型迭代器，因为无参 所以不能通过传参构成重载
		// 因为返回的是解引用，正向迭代器解引用返回的是&类型，所以这里引用接可以 且就是要修改，得引用，且这里是迭代器
		Ref operator*()
		{
			Iterator tmp = _it;
			return *(--tmp);
		}

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

		// Self：因为++、--运算要返回迭代器对象
		// 引用：因为需要要对存的值有修改权限	且是*this，它配
		// 返回迭代器对象	反向的++，需要对正向--，再解引用
		Self& operator++()
		{
			--_it;
			return *this;
		}

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

		bool operator!=(const Self& s)
		{
			return _it != s._it;
		}
	};
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

调用方：list代码节选

• 分析：

1. 关于typedef：如下我们需要利用riterator，这里Reverse_iterator虽然在不同.h文件，但是我们写同一个命名空间lz，运行起来就会合并，所以这里我看的视频里面没有报错，而我先报错了，因为我写了两个不同命名空间。
2. rbegin()：
   反向迭代器类型的函数，我们返回反向迭代器类型rit，但是是要用正向迭代器来实例化反向迭代器，而直接给end()即可，因为对称。STL源码中就是这样的设计，巧妙的设计使得代码简单优雅。
3. rend()：
   同rbegin()，但是以正向迭代器的begin()方法初始化即可。

public:
        // 两个的作用
        typedef ListIterator<T, T&, T*> iterator;

        typedef ListIterator<T, const T&, const T&> const_iterator;

        // 反向迭代器也分普通和cosnt类型
        typedef Reverse_iterator<iterator, T&, T*> riterator;

        typedef Reverse_iterator<const_iterator, const T&, const T&> const_riterator;
==下面是begin和end==
iterator begin()
        {
            return iterator(_pHead->_pNext);
        }

        // list的end()其实是头节点，这里不存值。
        // 不用引用，因为返回的是临时变量。不是类成员变量，只有类成员变量，才有资格。如：*this等
        iterator end()
        {
            return iterator(_pHead);
        }
// =====    反向迭代器：普通和const可以重载，因为参数后面加了const，符合重载条件    =======
        riterator rbegin()
        {
            return riterator(end());
        }

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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

• 分析：

运行效果：