list 的模拟实现

目录

[1. list 的实现框架](#1. list 的实现框架)

[2. push_back](#2. push_back)

[3. 迭代器](#3. 迭代器)

[4. constructor](#4. constructor)

[4.1. default](#4.1. default)

[4.2. fill](#4.2. fill)

[4.3. range](#4.3. range)

[4.4. initializer list](#4.4. initializer list)

[5. insert](#5. insert)

[6. erase](#6. erase)

[6.1. 迭代器失效问题](#6.1. 迭代器失效问题)

[7. clear 和 destructor](#7. clear 和 destructor)

[8. copy constructor](#8. copy constructor)

[9. operator=](#9. operator=)

[10. const_iterator](#10. const_iterator)

[10.1. 普通人的处理方案](#10.1. 普通人的处理方案)

[10.2. SGI-STL的处理方案](#10.2. SGI-STL的处理方案)

[11. operator->](#11. operator->)

[12. reverse_iterator](#12. reverse_iterator)

[13. 迭代器的分类](#13. 迭代器的分类)


1. list 的实现框架

cpp 复制代码
namespace Xq
{
	template <class T>
	struct list_node
	{
		T _data;
		list_node<T>* _left;
		list_node<T>* _right;

		// default 
		list_node(const T& x = T())
			:_data(x)
			, _prev(nullptr)
			, _next(nullptr)
		{}
	};

	// 带头双向循环链表
	template<class T>
	class list
	{
	private:
		typedef list_node<T> Node;
	public:

	private:
		Node* _head;  // 哨兵位头节点
	};
}

2. push_back

先搭个架子,跑起来再说,push_back 的实现很简单,如下:

cpp 复制代码
// 构造新节点
Node* BuildNewNode(const T& val)
{
	Node* newnode = new Node(val);
	return newnode;
}

// 尾插
void push_back(const T& val)
{
	// 1. 构造新节点
	Node* newnode = BuildNewNode(val);

	// 2. 找尾
	Node* tail = _head->_prev;

	// 3. 添加新节点
	tail->_next = newnode;
	newnode->_prev = tail;
	newnode->_next = _head;
	_head->_prev = newnode;
}

测试代码如下:

cpp 复制代码
void Test1(void)
{
	Xq::list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
}

可是我们发现一个问题,这咋遍历呢? 难道说,像C语言一样,写个 Print 函数,这也太挫了,因此,我们用容器统一访问元素的方式,通过迭代器访问,如下:

cpp 复制代码
void Test1(void)
{
	Xq::list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);

	Xq::list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		std::cout << *it << " ";
		++it;
	}
	std::cout << std::endl;
}

那么这个迭代器如何实现呢?

3. 迭代器

首先,在 string 和 vector 的模拟实现中,我们也使用过迭代器,但是它们两个的迭代器很特殊,因为它们存储的元素的地址是连续的,因此,它们的迭代器本质上就是原生指针,那 list 这里能不能也是原生指针呢?

答案:不可以,因为 list 底层的元素的地址可不是连续的,因此,不能是原生指针。

对于 string 和 vector, 因为存储的元素是连续存储的,故可以使用原生指针,同时,原生指针可以满足需求。

对于 list 来说,存储的元素的地址不是连续的,因此,不能使用原生指针,但是 list 又要求能够遍历元素,而元素就是一个一个的节点,即Node*,要遍历元素本质上就是要从当前节点去到下一个节点,既要重载 ++,-- 等操作,可是我们知道,指针属于内置类型,无法重载,因此只能将 Node* 封装到一个类中,这个类,人们起了一个名字,叫迭代器,通过重载迭代器这个类的 ++、-- 等操作,使得可以遍历节点,一般而言,这个自定义类型 (迭代器) 需要满足下面的操作:

加加 (++)、减减 (--)、解引用 (*)、访问成员 (->)、等于 (==)、不等于 (!=) 。
首先这个迭代器的框架如下:

cpp 复制代码
template <class T>
struct list_iterator
{
	typedef list_node<T> Node;
	Node* _node;
    
    // 下面就是迭代器所要支持的操作:
    // 加加 (++)、减减 (--)、解引用 (*)、
    // 访问成员 (->)、等于 (==)、不等于 (!=)
};

实现如下:

cpp 复制代码
template <class T>
struct list_iterator
{
	typedef list_node<T> Node;
	Node* _node;

	list_iterator(Node* node = nullptr) : _node(node) {}

	// 前置++, ++it
	list_iterator& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	// 后置++, it++
	list_iterator operator++(int)
	{
		// 后置++返回调用前的状态, 因此这里需要构造一个临时对象, 故只能传值返回
		// a. 可以使用构造一个迭代器
		// list_iterator ret(_node);
		// b. 也可以使用拷贝构造, 在这里, 默认生成的拷贝构造就满足需求
		// 因为在list_iterator类中,不需要释放这些资源 (_node),默认的析构不会对内置做处理
		list_iterator ret(*this);
		_node = _node->_next;
		return ret;
	}
	// 前置--, --it;
	list_iterator& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	// 后置--, it--
	list_iterator operator--(int)
	{
		// 与后置++一个思路, 但在这里使用构造函数
		list_iterator ret(_node);
		_node = _node->_prevc;
		return ret;
	}
	// *this != it;
	bool operator!=(const list_iterator& it)
	{
		return _node != it._node;
	}
	// *this == it;
	bool operator==(const list_iterator& it)
	{
		return _node == it._node;
	}
	// 返回对象的引用
	T& operator*()
	{
		return _node->_data;
	}
	// 返回对象的地址
	T* operator->()
	{
		// 复用 operator*
		return &(operator*());
	}

};

有了上面,还不足以支持用迭代器遍历数据,容器 (list) 自身也需要提供 begin、end等一些列函数,begin 和 end 在 list 中的位置如下:

下面是一些 list::begin 和 list::end 的相关实现:

cpp 复制代码
iterator begin()
{
	// 用第一个有效元素构造 begin 迭代器
	// 这里是单参数隐式类型转换
	// 先用节点构造迭代器, 在进行拷贝构造
	// 编译器优化为直接构造
	return _head->_next;   
}

iterator end()
{
	// 用最后一个有效元素的下一个位置构造 end 迭代器
	// 本质就是 _head
    // 这里是单参数隐式类型转换
	// 先用节点构造迭代器, 在进行拷贝构造
	// 编译器优化为直接构造
	return _head;
}

有了上面的支持,此时我们就可以用迭代器遍历链表了,测试用例如下:

cpp 复制代码
void Test1(void)
{
	Xq::list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);

	Xq::list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		std::cout << *it << " ";
		++it;
	}
	std::cout << std::endl;
}

现象如下:

上面是迭代器的初步实现的版本,后续还会有改进。
走到这里,转换一下思路,我们来实现一下 list 的构造函数,如下:

4. constructor

4.1. default

cpp 复制代码
// 构造一个哨兵位的头节点
void empty_initialize()
{
	_head = BuildNewNode(T());
	_head->_next = _head->_prev = _head;
}
// defalut
list()
{
	empty_initialize();
}

4.2. fill

cpp 复制代码
list(size_t n, const T& val)
{
	// 构造哨兵位头节点
	empty_initialize();
    // 复用push_back
	while (n--)
	{
		push_back(val);
	}
}

// 避免和 range constructor 冲突
list(int n, const T& val)
{
	// 构造哨兵位头节点
	empty_initialize();
    // 复用push_back
	while (n--)
	{
		push_back(val);
	}
}

4.3. range

cpp 复制代码
template<class InputIterator>
list(InputIterator first, InputIterator last)
{
	// 构造哨兵位头节点
	empty_initialize();
	// 通过一段区间构造一个list对象
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}

4.4. initializer list

cpp 复制代码
list(const std::initializer_list<T>& lt)
{
    // 构造哨兵位头节点
	empty_initialize();
    // 复用push_back
	for (auto& it : lt)
		push_back(it);
}

5. insert

实现这种函数,建议通过画图来进行编写代码,这样会事半功倍的,即便出错了,也能通过画图和调试很快锁定错误。

cpp 复制代码
iterator insert(iterator position, const T& val);

insert 在 position 位置之前插入特定节点,假如 position 是node3 的位置,先找到 position 位置之前的节点,在链入新节点,同时,返回值就是插入的新节点,如图所示:

代码如下:

cpp 复制代码
iterator insert(iterator pos, const T& val)
{
	// 得到pos位置的节点
	Node* cur = pos._node;
	// 找到pos节点之前的一个节点
	Node* cur_prev = cur->_prev;
	// 构造新节点
	Node* newnode = BuildNewNode(val);
	// 将新节点链入到list中
	cur_prev->_next = newnode;
	newnode->_prev = cur_prev;
	newnode->_next = cur;
	cur->_prev = newnode;
	// 返回新插入的节点
	return newnode;
}

有了insert,我们就可以通过 insert 实现 push_back 和 push_front。

push_back 是尾插,那么 position 就是在最后一个有效节点的下一个节点,最后一个有效节点的下一个节点不就是 end() 吗?如下所示:

cpp 复制代码
void push_back(const T& val)
{
	insert(end(), val);
}

push_front是头插,那么 position 就是第一个有效节点,第一个有效节点不就是 begin() 吗?如下所示:

cpp 复制代码
void push_front(const T& val)
{
	insert(begin(), val);
}

6. erase

cpp 复制代码
iterator erase (iterator position);

erase 是删除 position 位置的特定节点,并返回删除节点的下一个节点, 假如 position 是 node2,如下所示:

代码如下:

cpp 复制代码
iterator erase(iterator pos)
{
    // 空 list 不能erase
    assert(_head->_next != _head);

	// pos 不能是哨兵位头节点
	assert(pos != end());

	// 找到要删除的节点
	Node* del = pos._node;
	// 找到删除节点的前一个节点
	Node* del_prev = del->_prev;
	// 找到删除节点的后一个节点
	Node* del_next = del->_next;
	// 将删除节点从list移除
	del_prev->_next = del_next;
	del_next->_prev = del_prev;
	// 释放删除节点, 此时pos就迭代器失效了
	delete del;
	// 隐式类型转换
	return del_next;
}

有了erase,pop_back,pop_front 就简单多了。

pop_back,删除最后一个有效节点,那么最后一个有效节点不就是哨兵位头节点的前一个节点吗?如下所示:

cpp 复制代码
void pop_back()
{
	// 删除最后一个有效节点
	// 隐式类型转换
	erase(_head->_prev);
}

pop_front,删除第一个有效节点,那么第一个有效节点不就是哨兵位头节点的后一个节点吗?如下所示:

cpp 复制代码
void pop_front()
{
	// 删除第一个有效节点
	// 隐式类型转换
	erase(_head->_next);
}

6.1. 迭代器失效问题

迭代器失效即迭代器所指向的节点无效,即该节点被删除或者释放了。

因为list的底层结构为带哨兵位头节点的双向循环链表,因此在 list 中进行插入时是不会导致list 的迭代器失效的,只有在删除时才会失效,并且失效的只是指向被删除节点的迭代器,其他迭代器不会受到影响。
测试 demo 如下:

cpp 复制代码
void Test1(void)
{
	std::list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	for (auto e : lt)
		std::cout << e << " ";
	std::cout << std::endl;
	std::list<int>::iterator pos = lt.begin();
	if (pos != lt.end())
	{
		lt.erase(pos);
		// 预期: pos没有更新, pos失效
        // 此处就是非法访问pos, 进程crash
		std::cout << *pos << std::endl;
	}
}

现象如下:

如何解决这个问题呢?

正确的处理:erase 这个 pos 之后,此时这个 pos 已经失效,需要更新,具体如下:

cpp 复制代码
void Test1(void)
{
	std::list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	for (auto e : lt)
		std::cout << e << " ";
	std::cout << std::endl;
	std::list<int>::iterator pos = lt.begin();
	if (pos != lt.end())
	{
		// 更新 pos
		pos = lt.erase(pos);
		// 预期: pos 更新, 此时访问, success
		std::cout << *pos << std::endl;
	}
}

现象如下:

7. clear 和 destructor

clear 就是删除 list 的所有有效节点 (不包括哨兵位头节点),实现如下:

cpp 复制代码
void clear(void)
{
	Node* del = _head->_next;
	if (del == _head) return;
	while (del != _head)
	{
		Node* next = del->_next;
		erase(del);
		del = next;
	}
}

我们也可以用迭代器删除,如下:

cpp 复制代码
void clear(void)
{
	iterator it = begin();
	while (it != end())
		erase(it++);
}

destructor 在有了 clear 就简单多了,本质上就是调用 clear 释放所有有效节点,并将 list 的哨兵位头节点释放掉即可,实现如下:

cpp 复制代码
~list()
{
	clear();
	delete _head;
	_head = nullptr;
}

8. copy constructor

我们知道,如果我们没有显示定义copy constructor,那么编译器就会默认生成一份,默认生成的对内置类型和自定义类型都会处理,对内置类型按照浅拷贝的方式进行拷贝,对自定义类型会去调用它的copy constructor;对于list<T>来说,编译器默认生成的是不符合需求的的,它会带来两个问题:

  • 其中一个对象发生修改,另一个对象也会发生改变;
  • 当这两个对象生命周期结束时,会调用析构函数,同一空间被析构两次,进程crash。
    其中一个对象发生修改,另一个对象也会发生改变,如下 demo :
cpp 复制代码
void Test4(void)
{
	Xq::list<int> lt{ 1, 2, 3, 4 };
	Xq::list<int> copy(lt);
	std::cout << "original lt:";
	for (auto it : lt)
		std::cout << it << " ";
	std::cout << "\n";

	std::cout << "copy modify: ";
	for (auto& it : copy)
		std::cout << (it *= 2) << " ";
	std::cout << "\n";

	std::cout << "new lt:";
	for (auto it : lt)
		std::cout << it << " ";
	std::cout << "\n";
}

lt {1, 2, 3, 4},通过 it 拷贝构造得到 copy, copy {1, 2, 3, 4},copy 遍历一遍,每个元素 *= 2,即 copy {2, 4, 6, 8},那么此时 lt 是什么呢?

预期:因为是浅拷贝,此时 lt 也会变为 {2, 4, 6, 8},之所以这里没有崩溃,是因为我将析构给屏蔽了 (即此时析构什么事也不做),现象如下:

符合预期,如果我此时恢复析构函数,那么当这两个对象生命周期结束时,先后调用析构函数,同一空间被析构两次,进程崩溃,现象如下:

因此,针对 list ,用户需要自身以深拷贝的方式实现拷贝构造,实现如下:

cpp 复制代码
void swap(list<T>& tmp)
{
	// 交换两个哨兵位头节点
	// 即交换两个list对象
	std::swap(_head, tmp._head);
}
		
template<class InputIterator>
list(InputIterator first, InputIterator last)
{
	// 构造哨兵位头节点
	empty_initialize();
	// 通过一段区间构造一个list对象
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}		

list(const list<T>& copy)
{
	// 构造哨兵位头节点
	empty_initialize();
	// 通过 copy 构造 tmp
	list<T> tmp(copy.begin(), copy.end()); 
	// 再和tmp交换哨兵位的头节点
	swap(tmp);
	// tmp 生命周期结束, 自动调用析构, 释放哨兵位的头节点
}

上面这套方案,是不是有点繁琐? 用户也可以采用下面的方案:

cpp 复制代码
list(const list<T>& copy)
{
	// 构造哨兵位头节点
	empty_initialize();

	// 通过迭代器直接复用 push_back
	for (const auto& it : copy)
	{
		push_back(it);
	}
}

之所以上面可以,是因为有我们之前所做的努力,无非就是复用罢了。

9. operator=

同理,operator=是不是也存在着和拷贝构造同样的问题,因此我们也需要以深拷贝的方式实现operator=,实现如下:

cpp 复制代码
// 在类里面可以不写模板参数, 
// 但是建议不管是类外还是类内都把模板参数加上
// void swap(list& copy)   // 不建议

// 交换两个list的哨兵位的头节点
void swap(list<T>& copy)
{
	std::swap(_head, copy._head);
}

// 利用传值传参的特性 --- 会进行拷贝构造
list<T>& operator=(list<T> copy)
{
    // 交换 copy 和 *this 两个list的头节点
	swap(copy);
    // 返回赋值后的list对象
	return *this;
    // copy出了函数作用域, 会自动调用析构函数, 释放资源
}

10. const_iterator

我们上面不是已经实现了一个迭代器吗,为什么还要有 const_iterator 呢?

上面我们所实现的迭代器称之为普通迭代器,而在一些场景下,普通迭代器不能满足需求,比如下面这个例子:

cpp 复制代码
void print_list(const Xq::list<int>& tmp)
{
	Xq::list<int>::iterator it = tmp.begin();
	while (it != tmp.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

void Test5(void)
{
	Xq::list<int> lt{ 1, 2, 3, 4 };
	print_list(lt);
}

因为我们目前没有提供 const 迭代器,上面的代码会编译报错,如下:

那么如何解决呢? 很简单,我们提供一个const迭代器就OK了,但是不同的人会有不同的处理,在这里有两种处理方案:普通人的处理方案和SGI-STL的处理方案,具体如下:

10.1. 普通人的处理方案

作为普通人的我 (🐂🐎),我想到的就是这种方案 (惭愧~~~)。

处理很简单,照着普通迭代器的模样,再写一份 const 迭代器就OK了,如下:

cpp 复制代码
template <class T>
struct const_list_iterator
{
	typedef list_node<T> Node;
	Node* _node;

	const_list_iterator(Node* node = nullptr) : _node(node) {}

	// 前置++, ++it
	const_list_iterator& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	// 后置++, it++
	const_list_iterator operator++(int)
	{
		const_list_iterator ret(*this);
		_node = _node->_next;
		return ret;
	}
	// 前置--, --it;
	const_list_iterator& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	// 后置--, it--
	const_list_iterator operator--(int)
	{
		const_list_iterator ret(_node);
		_node = _node->_prevc;
		return ret;
	}

	bool operator!=(const const_list_iterator& it)
	{
		return _node != it._node;
	}

	bool operator==(const const_list_iterator& it)
	{
		return _node == it._node;
	}

	// 返回const 对象的引用
	const T& operator*()
	{
		return _node->_data;
	}

	// 返回const 对象的地址
	const T* operator->()
	{
		// 复用 operator*
		return &(operator*());
	}
};

上面是一份 const 迭代器,同时,容器自身也需要提供相应的begin和end,如下:

cpp 复制代码
const_iterator begin() const
{
	// 用第一个有效元素构造 begin 迭代器
	return _head->_next;
}

const_iterator end() const
{
	// 用最后一个有效元素的下一个位置构造 end 迭代器
	// 本质就是 _head
	return _head;
}

可能会有人有这样的疑惑,我们以 begin 举例,如下:

cpp 复制代码
iterator begin()
{
	return _head->_next;   
}

const_iterator begin() const
{
	return _head->_next;
}

这两个函数构成函数重载吗,答案,构成,为什么呢? 因为它们参数的类型不一样,因为每一个非静态的成员函数都有一个 this 指针。

  • 作为普通类型的 this 指针类型为:iterator* const this;
  • 作为const类型的 this 指针类型为: const const_iterator* const this。

因此,两个函数的this指针类型不一样,即参数类型不一样,故构成函数重载,end 同理。
这就是普通处理 const 迭代器的方案,粗暴的复用 (大量相同重复的逻辑),没有一点技术含量,非常挫,下面来看看高手怎么玩的呢?

10.2. SGI-STL的处理方案

就普通迭代器和const 迭代器,我们发现,这两个类除了类名不一样,其实核心点就在两个地方放生了改变,那两个地方呢?

一个就是 operator*()、另一个就是 operator->();
如果是普通迭代器的 operator* 和 operator->,如下:

cpp 复制代码
// 返回普通对象的引用
T& operator*()
{
	return _node->_data;
}

// 返回普通对象的地址  
T* operator->()
{
	// 复用 operator*
	return &(operator*());
}

如果是 const 迭代器的 operator* 和 operator->(),如下:

cpp 复制代码
// 返回const 对象的引用
const T& operator*()
{
	return _node->_data;
}

// 返回 const 对象的地址
const T* operator->()
{
	// 复用 operator*
	return &(operator*());
}

可以发现,它们的主要区别就在于返回值的类型不同罢了,因此,高手们就想到了用模板参数来解决这个问题,通过类模板参数,来进行泛型化,如下:

cpp 复制代码
template <class T, class Ref, class Ptr>
struct list_iterator
{
	// 返回对象的 Ref (reference)
	Ref operator*()
	{
		return _node->_data;
	}

	// 返回对象的 Ptr (pointer)
	Ptr operator->()
	{
		// 复用 operator*
		return &(operator*());
	}
};

在 list 容器中,通过迭代器的类型决定 Ref 和 Ptr 是什么,进而决定这个 list_iterator 类模板实例化成什么具体的模板类,具体来说:

  • 如果是普通类型的迭代器,那么Ref 就是 T&,Ptr 就是 T*;
  • 如果是 const 类型的迭代器,那么 Ref 就是 const T&, Ptr 就是 const T*。

用代码来说,如下所示:

cpp 复制代码
template<class T>
class list
{
public:
    // 如果你是普通迭代器, 那么Ref就是T&, Ptr就是T*
	typedef list_iterator<T, T&, T*> iterator;

    // 如果你是const迭代器, 那么Ref就是const T&, Ptr就是const T*    
	typedef list_iterator<T, const T&, const T*> const_iterator;;

    // ...
}

可以看到, iterator 和 const_iterator 这两个类,通过通过模板参数达到泛型化,进而解决了大量相符重复代码的问题,这就是高手的处理方案,很神奇。
我们也可以用下图来理解一下这个过程:

11. operator->

在这里需要强调一下operator->。

首先,为什么需要 operator-> 呢? -> 这个操作费我们是经常使用的,称之为访问成员操作符,在有些场景下,我们是需要通过 -> 访问成员的。
假如有这样的一个类型,如下:

cpp 复制代码
struct A
{
	A(int a = 0, int b = 0) :_a(a), _b(b) {}
	int _a;
	int _b;
};

场景如下:

cpp 复制代码
void Test6(void)
{
	Xq::list<A> lt{ { 1, 1 }, { 2, 2, }, { 3, 3, }, { 4, 4, } };

	for (const auto& it : lt)
	{
		std::cout << *it << std::endl;
	}
}

如果这个类型 (struct A),没有实现 operator<<,那么这里就会编译报错,因为 A 是一个自定义类型,如下:

如果不想实现 operator<< ,那么这里就可以用 ->,如下:

cpp 复制代码
void Test6(void)
{
	Xq::list<A> lt{ { 1, 1 }, { 2, 2, }, { 3, 3, }, { 4, 4, } };
	Xq::list<A>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << it->_a << " " << it->_b << endl;
		++it;
	}
	cout << endl;
}

那么 operator-> 如何实现呢?

operator-> 返回的是当前数据的指针,因此,我们可以复用 operator*,如下:

cpp 复制代码
template<class T, class Ref, class Ptr>
struct list_iterator
{
    // 返回数据的指针
    Ptr operator->()
    {
    	return &(operator*());
        //等价于return &(_node->_data);
    }
    
    // ...
};

不过要在这里解释一下,这里的 -> 是如何调用的:

cpp 复制代码
std::cout << it->_a << " " << it->_b << std::endl;
// 上面也可以这样写:
std::cout << it.operator->()->_a << " " << it.operator->()->_b << std::endl;

// it->_a 实际上是 it->->_a, 第一个 -> 是调用operator->, 第二个 -> 才是访问成员属性
// it-> 相当于 operator->, 返回一个Ptr, 返回迭代器里面数据的地址 (T* 或者 const T*)
// Ptr->_a 或者 Ptr->_b, 因此说 it->_a 实际上是 it->->_a
// 但是语法为了可读性, 编译器进行了特殊处理, 省略了一个->, 即 it->_a

12. reverse_iterator

反向迭代器也称之为迭代器适配器,它的底层采用的是正向迭代器,将正向迭代器类的接口转换为反向迭代器类的接口。
在实现反向迭代器之前,我们需要搞清楚反向迭代器的 rbegin 和 rend 的位置,我们采用 STL 标准库的实现,具体如下:
反向迭代器的位置:

我们再看看正向迭代器的位置:

可以看到,正向迭代器和反向迭代器的位置是对称的。具体来说, 正向迭代器的begin() 正好是反向迭代器 rend() 的位置,而正向迭代器的 end() 这是反向迭代器 rbegin() 的位置。至于 STL 为什么这样设计,是有它的原因的,后面解释。
因为反向迭代器底层采用了正向迭代器,因此它的框架如下:

cpp 复制代码
// 这里的 Ref 和 Ptr 是为了解决 const 反向迭代器, 这不重要
// 重要的是, 这里的Iterator, 它代表着是一个正向迭代器
template<class Iterator, class Ref, class Ptr>
class reverse_list_iterator
{
public:
	// 用一个正向迭代器来构造反向迭代器
	reverse_list_iterator(Iterator it) :_it(it) {}

private:
	Iterator _it;  //  一个正向迭代器
};

既然是迭代器,它是需要实现如下功能的:

加加 (++)、减减 (--)、解引用 (*)、访问成员 (->)、等于 (==)、不等于 (!=) 。
在这里,由于反向迭代器是一个迭代器适配器,因此,上面的接口逻辑不需要反向迭代器自己实现,而是通过复用正向迭代器的接口来实现上面的接口。

不过需要注意的是,正向迭代器是正向访问容器 (list) 元素,而反向迭代器需要逆向访问容器 (list) 元素,故在复用正向迭代器的接口时,逻辑上需要作出一些更改,具体如下:
我们先来两个简单的, 等于 (==)、不等于 (!=) ,实现如下:

cpp 复制代码
template<class Iterator, class Ref, class Ptr>
class reverse_list_iterator
{
public:
	// 用一个正向迭代器来构造反向迭代器
	reverse_list_iterator(Iterator it) :_it(it) {}
    
    // 复用正向迭代器的 operator==
	bool operator==(const reverse_list_iterator& cmp)
	{
		return _it == cmp._it;
	}
    
    // 复用正向迭代器的 operator!=
	bool operator!=(const reverse_list_iterator& cmp)
	{
		return _it != cmp._it;
	}

private:
	Iterator _it;  //  需要一个正向迭代器
};

接下来实现 ++、以及 -- 操作。
因为是逆向打印,因此这里的 ++ 操作对于容器中的元素而言是逆着走的。

举个例子:

cur++ ,会指向哪里呢? 注意,它是逆着走的,如下:

因此,我们发现,反向迭代器的 ++ 操作,正好对应正向迭代器的 -- 操作,因此,在实现反向迭代器的 ++ 操作时,我们就完全可以复用正向迭代器的 -- 操作。反向迭代器的--操作也是同理,也正因此,所以 STL 在设计 rbegin 和 rend 的位置时,才会采取和 begin 和 end 对称的方案。

有了上面的理解,那么 ++ 操作和 -- 操作的实现就自然而然出来了,如下:

cpp 复制代码
template<class Iterator, class Ref, class Ptr>
class reverse_list_iterator
{
public:
	// 用一个正向迭代器来构造反向迭代器
	reverse_list_iterator(Iterator it) :_it(it) {}
    
    // 前置++, 复用正向迭代器的--操作
	reverse_list_iterator& operator++()
	{
		--_it;
		return *this;
	}
    
    // 后置++, 复用正向迭代器的--操作
	reverse_list_iterator operator++(int)
	{
		reverse_list_iterator ret(_it);
		--_it;
		return ret;
	}

    // 前置--, 复用正向迭代器的++操作
	reverse_list_iterator& operator--()
	{
		++_it;
		return *this;
	}
    
    // 后置--, 复用正向迭代器的++操作
	reverse_list_iterator operator--(int)
	{
		reverse_list_iterator ret(_it);
		++_it;
		return ret;
	}

private:
	Iterator _it;  //  需要一个正向迭代器
};

接下来就只剩 operator*() 和 operator-> 操作的实现了。

在这之前,我们再来看看 rbegin() 和 rend() 的初始位置,如下:

我们发现一个事实,rbegin() 的初始位置,是指向哨兵位的头节点的。

而我们反向迭代器的遍历操作是如何进行的呢,如下:

cpp 复制代码
void Test8(void)
{
	std::list<int> lt{ 1, 2, 3, 4, 5 };
	std::list<int>::reverse_iterator rit = lt.rbegin();
	while (rit != lt.rend())
	{
		std::cout << *rit << " ";
		++rit;
	}
	std::cout << "\n";
}

我们发现,我们是解引用了 rbegin() 这个迭代器,但是,客观事实告诉我们,哨兵位的头节点不可以解引用,就算解引用了也没有任何意义,那么这里是如何实现的呢?

很简单,在调用 operator* 时,解引用的位置是当前位置的前一个位置。

举个例子:

此时解引用cur (*cur),而事实上,解引用的是 node4 这个节点, 因此,在 operator*() 内部实现中,我们需要先锁定位置 (当前节点的前一个节点),在进行解引用,实现如下:

cpp 复制代码
template<class Iterator, class Ref, class Ptr>
class reverse_list_iterator
{
public:
	// 用一个正向迭代器来构造反向迭代器
	reverse_list_iterator(Iterator it) :_it(it) {}

	// 返回数据的引用
	Ref operator*()
	{
        // 构造一个临时的正向迭代器
		Iterator tmp(_it);
        // 解引用的是当前位置的前一个节点
		return *--tmp;
	}
    // 返回数据的地址
	Ptr operator->()
	{
		return &(operator*());
    }
	
private:
	Iterator _it;  //  需要一个正向迭代器
};

至于这里为什么要用 Ref,Ptr 就不再解释了,至此,我们的反向迭代器的完整实现如下:

cpp 复制代码
template<class Iterator, class Ref, class Ptr>
class reverse_list_iterator
{
public:
	// 用一个正向迭代器来构造反向迭代器
	reverse_list_iterator(Iterator it) :_it(it) {}

	// 前置++, 复用正向迭代器的--操作
	reverse_list_iterator& operator++()
	{
		--_it;
		return *this;
	}

	// 后置++, 复用正向迭代器的--操作
	reverse_list_iterator operator++(int)
	{
		reverse_list_iterator ret(_it);
		--_it;
		return ret;
	}

	// 前置--, 复用正向迭代器的++操作
	reverse_list_iterator& operator--()
	{
		++_it;
		return *this;
	}

	// 后置--, 复用正向迭代器的++操作
	reverse_list_iterator operator--(int)
	{
		reverse_list_iterator ret(_it);
		++_it;
		return ret;
	}

	// 复用正向迭代器的 operator==
	bool operator==(const reverse_list_iterator& cmp)
	{
		return _it == cmp._it;
	}
    
    // 复用正向迭代器的 operator!=
	bool operator!=(const reverse_list_iterator& cmp)
	{
		return _it != cmp._it;
	}

	// 返回数据的引用
	Ref operator*()
	{
        // 构造一个临时的正向迭代器
		Iterator tmp(_it);
        // 解引用的是当前位置的前一个节点
		return *--tmp;
	}

    // 返回数据的地址
	Ptr operator->()
	{
		return &(operator*());
    }

private:
	Iterator _it;  //  需要一个正向迭代器
};

反向迭代器实现好后,容器 (list) 自身也需要提供相关接口,诸如 rbegin、rend 函数,实现如下:

cpp 复制代码
template<class T>
class list
{
public:
    // 如果你是普通反向迭代器, 那么Ref就是T&, Ptr就是T*
	typedef reverse_list_iterator<iterator, T&, T*> reverse_iterator;
    // 如果你是 const 反向迭代器, 那么Ref就是const T&, Ptr就是 const T*
	typedef reverse_list_iterator<const_iterator, const T&, const T*> const_reverse_iterator;

    reverse_iterator rbegin()
	{
		// 用哨兵位头节点构造的正向迭代器进而构造反向迭代器
		return iterator(_head);
	}

	const_reverse_iterator rbegin() const
	{
		// 用哨兵位头节点构造的正向迭代器进而构造反向迭代器
		return iterator(_head);
	}

	reverse_iterator rend()
	{
		// 用哨兵位头节点的下一个节点构造正向迭代器进而构造反向迭代器
		return iterator(_head->_next);
	}

	const_reverse_iterator rend() const
	{
		// 用哨兵位头节点的下一个节点构造正向迭代器进而构造反向迭代器
		return iterator(_head->_next);
	}
private:
    Node* _head
}

13. 迭代器的分类

从功能角度上讲,我们可以将迭代器分为下面的三类:

  • forward_iterator:单向迭代器,支持++;
  • bidirectional_iterator:双向迭代器,支持++、--;
  • random_iterator:随机迭代器,支持++、--、+、-。
    双向迭代器是一种特殊的单向迭代器;

随机迭代器是一种特殊的双向/单向迭代器。
STL 中的 std::sort,如下:

cpp 复制代码
// default (1)	
template <class RandomAccessIterator>
  void sort (RandomAccessIterator first, RandomAccessIterator last);
// custom (2)	
template <class RandomAccessIterator, class Compare>
  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

这是STL标准库的sort(),我们看到它的参数类型是RandomAccessIterator,即随机迭代器。

它这么做的意义是什么呢?

其实就是暗示了调用这个函数的迭代器只能是随机迭代器(例如vector、deque的迭代器可以调用该函数),而 list是双向迭代器,是不可以调用这个函数的。

相关推荐
阿洵Rain4 小时前
【C++】哈希
数据结构·c++·算法·list·哈希算法
黎明晓月8 小时前
Java之字符串分割转换List
java·windows·list
slp_8 小时前
java list使用基本操作
java·开发语言·list
大黄瓜de冬天15 小时前
list集合常见去重方式以及效率对比
java·spring boot·list
南城花随雪。1 天前
哈希表(Hash Table)、跳表(Skip List) 和 有序字典(Ordered Dictionary) 的详细介绍
list·哈希算法·散列表
算法与编程之美2 天前
list与iterator的之间的区别,如何用斐波那契数列探索yield
数据结构·list
天狼12223 天前
java8 list map 聚合求和
list·map·q求和
初次见面我叫泰隆3 天前
C++STL——list
开发语言·c++·list
杀神lwz4 天前
Java List根据属性排序
java·python·list
fs哆哆5 天前
C#编程:VSTO在Excel工作表中输出List数据
服务器·windows·c#·list·excel