【STL详解】list的模拟实现

目录

list的模拟实现总览：

1.节点类的模拟实现

构造函数

2.迭代器类的模拟实现

迭代器类的模板参数说明

构造函数

++运算符的重载

--运算符的重载

==运算符的重载

!=运算符的重载

*运算符的重载

 ->运算符的重载

list的模拟实现

默认成员函数

构造函数

 拷贝构造函数（迭代器版本）

拷贝构造函数(现代写法)

赋值运算符重载函数（现代写法）

 其他构造函数

析构函数

迭代器相关函数

 访问容器相关函数

插入、删除函数

insert（前插）

erase

push_back和pop_back

push_front和pop_front

---

list的模拟实现总览：

#include<iostream>
using namespace std;

namespace lxy
{
	//模拟实现list当中的结点类
	template<class T>
	struct ListNode
	{
		//构造函数
		ListNode(const T& data = T());
		//成员变量
		T _data;			//数据域
		ListNode<T>* _next;	//后继指针
		ListNode<T>* _prev;	//前驱指针
	};

	//模拟实现list迭代器
	template<class T,class Ref,class Ptr>
	struct __list_iterator
	{
		typedef ListNode<T> Node;
		typedef __list_iterator<T, Ref, Ptr> self;

		//构造函数
		__list_iterator(Node* x);

		//各种运算符重载函数
		self& operator++();
		self& operator--();
		self operator++(int);
		self operator--(int);
		bool operator==(const self& it) const;
		bool operator!=(const self& it) const;
		Ref operator*();
		Ptr operator->();

		//成员变量
		Node* _node;
	};


	//模拟实现list
	template<class T>
	class list
	{
	public:
		typedef ListNode<T> Node;
		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const  T*> const_iterator;
		
		//默认成员函数
		list();
		list(const list<T>& lt);
		list<T>& operator=(const list<T>& lt);
		~list();

		//迭代器相关函数
		iterator begin();
		iterator end();
		const_iterator begin() const;
		const_iterator end() const;

		//访问容器相关函数
		T& front();
		T& back();
		const T& front() const;
		const T& back() const;

		//插入、删除函数
		iterator insert(iterator pos, const T& x);
		iterator erase(iterator pos);
		void push_back(const T& x);
		void pop_back();
		void push_front(const T& x);
		void pop_front();

		//其他函数
		size_t size() const;
		void resize(size_t n, const T& val = T());
		void clear();
		bool empty() const;
		void swap(list<T>& lt);

	private:
		//指向链表头结点的指针
		Node* _head;
	};
}

1.节点类的模拟实现

	template<class T>
	struct ListNode
	{
		//构造函数
		ListNode(const T& data = T());
		//成员变量
		T _data;			//数据域
		ListNode<T>* _next;	//后继指针
		ListNode<T>* _prev;	//前驱指针
	};

list是一个带头双向循环链表，故先实现一个结点类。

构造函数

		ListNode(const T& data = T())
			:_next(nullptr)
			, _prev(nullptr)
			, _data(data)
		{ }

 注意： 若构造结点时未传入数据，则默认以list容器所存储类型的默认构造函数所构造出来的值为传入数据。

2.迭代器类的模拟实现

	//模拟实现list迭代器
	template<class T,class Ref,class Ptr>
	struct __list_iterator
	{
		typedef ListNode<T> Node;
		typedef __list_iterator<T, Ref, Ptr> self;

		//构造函数
		__list_iterator(Node* x);

		//各种运算符重载函数
		self& operator++();
		self& operator--();
		self operator++(int);
		self operator--(int);
		bool operator==(const self& it) const;
		bool operator!=(const self& it) const;
		Ref operator*();
		Ptr operator->();

		//成员变量
		Node* _node;
	};

对于list来说，其各个结点在内存当中的位置是随机的，并不是连续的，我们不能仅通过结点指针的自增、自减以及解引用等操作对相应结点的数据进行操作。迭代器让使用者可以不必关心容器的底层实现，可以用简单统一的方式对容器内的数据进行访问。

 list迭代器类，实际上就是对结点指针进行了封装，对其各种运算符进行了重载，使得结点指针的各种行为看起来和普通指针一样。

迭代器类的模板参数说明

<