list——迭代器问题

目录

一. 迭代器实现

二. 迭代器失效问题

---

一. 迭代器实现

C语言已经实现过list，我们知道需要先创建一个结点的模板类，通过查看stl库的源码发现实现的链表的是双向带头循环链表，因此结点需包含两个指针加一个数据：

//模板结点，公有的使用struct
	template<class T>
	struct _list_node
	{
		_list_node<T>* next;//指向下一个结点
		_list_node<T>* prev;//指向上一个结点
		T _data;//存储数据

		//默认构造函数，创建一个匿名对象用来给缺省值
		_list_node(const T& val = T())
			:next(nullptr)
			, prev(nullptr)
			, _data(val)
		{}
	};

我们知道无论是vecro还是list都有迭代器，vector的迭代器是原生指针，但是由于list不是连续存储的，可以猜测list的迭代器不是原生指针，那么list的迭代器只能自己实现的一个类，通过vector的迭代器我们不难发现，迭代器无非是模仿指针的行为，也就是说，指针该有的操作，迭代器也不能少，那么实现list的迭代器问题就不大了。

但是，这里需要考虑一个问题：对于const迭代器如何实现？由于我们传的是模板参数，再按照普通迭代器的做饭写一份const迭代器未免太复杂，那么就干脆多设置两个模板参数来应对返回const引用和const指针，也就是说，使用三个模板参数来处理传参的问题，其他指针行为实现的函数问题也就不大了，如下：

//迭代器(本质上是模拟指针的行为)，公有的使用struct
	//使用三个模板参数，一个是数据的类型，另外两个是针对const迭代器和普通迭代器设置的
	template<class T, class Ref, class Ptr>
	struct _list_iterator
	{
		//声明结点
		typedef _list_node<T> Node;
		//重命名自己后续更方便
		typedef _list_iterator<T, Ref, Ptr> self;
		Node* _node;
		
		//构造函数
		_list_iterator(Node* node)
			:_node(node)
		{}
		//析构使用默认的，因为结点不是迭代器申请的，不由迭代器释放
		//拷贝构造不用写，我们需要的就是浅拷贝，因为迭代器就是要和结点指向一块空间

		//重载*
		Ref operator*()
		{
			//取数据
			return _node->_data;
		}

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

		//重载前置++，对象还在
		self& operator++()
		{
			_node = _node->next;
			//*this是迭代器对象
			return *this;
		}

		//重载后置++，对象不在，需要拷贝，设置一个默认参数和前置++做区分，构成函数重载
		self operator++(int)
		{
			//拷贝一份对象再++
			self temp(*this);
			_node = _node->next;
			//返回拷贝的对象
			return temp;
		}

		//重载前置--
		self& operator--()
		{
			_node = _node->prev;
			return *this;
		}

		//重载后置--，设置一个默认参数和前置--做区分，构成函数重载
		self operator--(int)
		{
			self temp(*this);
			_node = _node->prev;
			return temp;
		}

		//重载!=
		bool operator!=(const self& it)
		{
			//比较两个迭代器里的_node是否是一个
			return _node != it._node;
		}

		//重载等于
		bool operator==(const self& it)
		{
			return _node == it._node;
		}
	};

那么，vector迭代器有失效问题吗？事实上，list的insert插入并不会存在迭代器失效问题

运行如下代码：

mylist::list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	lt.push_back(6);

	//偶数前插入，不存在迭代器失效问题
	auto it = lt.begin();
	while (it != lt.end())
	{
		if (*it % 2 == 0)
		{
			lt.insert(it, *it * 2);
		}
		++it;
	}
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

这里需要注意一下迭代器的->访问，我们平时访问是obje->data，但是通过了运算符重载后我们会发现：本来应该是这样object.operator->()调用，但是在迭代器中这是调用了重载函数，而重载函数返回的是一个指针，按照正常道理应该还要一个->来访问data，这里其实是编译器的优化问题，所以就可以只需要一个->。

二. 迭代器失效问题

我们发现迭代器并没有像vector那样出现迭代器失效问题。

但是erase却是会失效的，是访问了野指针的迭代器失效并且从此后的迭代器全部失效，毕竟我们释放结点了，再访问是会失效的，运行如下代码，可以发现：

//删除偶数
    mylist::list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	lt.push_back(6);
	auto it2 = lt.begin();
	while (it2 != lt.end())
	{
		if (*it2 % 2 == 0)
		{
			lt.erase(it2);//需要注意迭代器失效问题
		}
		++it2;
	}
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

直接崩溃，这里说明了list在erase后迭代器是会失效的，和vector做一样的赋值处理后便可以解决问题：

//删除偶数
	auto it2 = lt.begin();
	while (it2 != lt.end())
	{
		if (*it2 % 2 == 0)
		{
			it2 = lt.erase(it2);//需要注意迭代器失效问题
		}
		else
		{
			++it2;
		}
	}
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
}

综上所述，list主要需要注意还是迭代器的问题。

由于已经实现过vector，对于list本类的实现也就问题不大，最主要的问题是要处理迭代器的问题，由于不是原生指针所以需要我们自己去实现一个迭代器，进而引出使用三个模板参数来解决const迭代器问题，list本类的实现如下：

（传给迭代器的三个模板参数，后面两个就是应对普通迭代器和const迭代器问题）

//链表
	template<class T>
	class list
	{
	public:
		//缩短结点名字
		typedef _list_node<T> node;
		//重命名迭代器
		typedef _list_iterator<T, T&, T*> iterator;//普通迭代器
		typedef _list_iterator<T, const T&, const T*> const_iterator;//const迭代器
		//无参构造函数
		list()
		{
			_head = new node();
			_head->next = _head;
			_head->prev = _head;
		}

		//带参的迭代器区间构造函数
		template <class InputIterator>  
		list(InputIterator first, InputIterator last)
		{
			empty_init();//先初始化，给头结点，不然没法继续
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		//析构函数，调用clear函数帮忙清理
		~list()
		{
			clear();
			delete _head;//释放哨兵位的头结点
			_head = nullptr;
		}

		//空初始化函数
		void empty_init()
		{
			_head = new node();
			_head->next = _head;
			_head->prev = _head;
		}

		//交换函数，只需要交换哨兵位的头结点即可
		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
		}

		//拷贝构造
		//传统写法
		//list(const list<T>& lt)
		//{
		//	//先初始化待被拷贝对象
		//	_head = new node();
		//	_head->next = _head;
		//	_head->prev = _head;

		//	//遍历拷贝对象将拷贝对象的结点插入待被拷贝对象
		//	for (auto e : lt)
		//	{
		//		push_back(e);
		//	}
		//}
		//现代方法
		list(const list<T>& lt)
		{
			empty_init();//先将自己初始化
			list<T> tmp(lt.begin(), lt.end());//用lt构造tmp
			swap(tmp);//把tmp里的和本对象的交换，让tmp释放初始化的头结点
		}

		//现代方法重载=
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		//迭代器
		iterator begin()
		{
			//iterator匿名对象创建第一个结点的迭代器
			return iterator(_head->next);
		}
		iterator end()
		{
			//iterator匿名对象创建最后一个结点的下一个的迭代器
			return iterator(_head);
		}

		//const迭代器
		const_iterator begin() const
		{
			//conts_iterator匿名对象创建第一个结点的迭代器
			return const_iterator(_head->next);
		}
		const_iterator end() const
		{
			//const_iterator匿名对象创建最后一个结点的下一个的迭代器
			return const_iterator(_head);
		}

		//插入，不存在迭代器失效但是仍然设置返回值
		iterator insert(iterator pos, const T& x)
		{
			//创建结点
			node* newnode = new node(x);
			node* cur = pos._node;//存储当前位置
			node* prev = cur->prev;//存储前一个位置

			//将newnode的next指向pos，prev指向pos的前一个，再把pos前一个指向newnode，pos的prev指向newnode
			newnode->next = cur;
			newnode->prev = prev;
			prev->next = newnode;
			cur->prev = newnode;

			return iterator(newnode);//返回一个迭代器的匿名对象
		}

		//尾插
		void push_back(const T& val)
		{
			尾指针
			//node* tail = _head->prev;
			//node* newnode = new node(val);
			最后一个结点的next指向newnode，newnode的prev指向最后一个结点
			newnode的next指向哨兵位的头结点，哨兵位头结点的orev指向newnode
			//tail->next = newnode;
			//newnode->prev = tail;
			//newnode->next = _head;
			//_head->prev = newnode;
			insert(end(), val);
		}

		//头插
		void push_front(const T& val)
		{
			insert(begin(), val);
		}

		//删除，需要注意会出现野指针访问的迭代器失效问题，因为释放了cur，用返回下一个位置来避免
		iterator erase(iterator pos)
		{
			//不能删除哨兵位的头结点
			assert(pos != end());

			node* cur = pos._node;//存储当前位置
			node* next = cur->next;//存储前一个位置
			node* prev = cur->prev;//存储后一个位置

			//将prev的next指向next，next的prev指向prev，释放cur
			prev->next = next;
			next->prev = prev;
			delete cur;

			return iterator(next);//用迭代器对象创建一个匿名对象返回下一个位置，避免迭代器失效
		}

		//尾删
		void pop_back()
		{
			erase(--end());
		}

		//头删
		void pop_front()
		{
			erase(begin());
		}

		//清空结点
		void clear()
		{
			iterator it = begin();
			//哨兵位的头结点需要留着
			while (it != end())
			{
				it = erase(it);//需要赋值，防止迭代器失效
			}
		}

	private:
		node* _head;
	};