文章目录

1 list介绍
2 list的模拟实现
- 2.1 类的定义
- 2.2 默认成员函数
- - 2.2.1 构造函数
  - 2.2.2 析构函数
  - 2.2.3 拷贝构造
  - 2.2.4 赋值重载
- 2.3 迭代器
- - 2.3.1 正向迭代器
  - 2.3.2 反向迭代器
- 2.4 修改接口
- - 2.4.1 任意位置插入
  - 2.4.2 任意位置删除
- 2.5 其他接口
- - 2.5.1 尾插
  - 2.5.2 头插
  - 2.5.3 尾删
  - 2.5.3 头删
3 list和vector的比较

1 list介绍

1 list是可以在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
2 list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。

2 list的模拟实现

2.1 类的定义

template<class T>
	struct list_node//链表结点的类
	{
		T _data;//数据域
		list_node<T>* _prev;//指向前一个结点
		list_node<T>* _next;//指向后一个结点
		list_node(const T& x = T())
			:_data (x)
		    ,_prev (nullptr)
			,_next(nullptr)
		{

		}
	};
template<class T>
	class list//链表类
	{
		typedef list_node<T> Node;
	public:
	void empty_init()
		{
			//创建哨兵位并初始化
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head;
		}
		  list()
		{
			empty_init();
		}
		private:
		Node* _head;
};

①可以看出，list的实现也是模板，这样结点里面的数据可以是任意类型
②其中list_node是链表节点类，用来构造结点
③list是链表类，用来实现链表的各种操作，其中初始化的时候只用创建一个哨兵位
④一般定义用来被别的类使用的类都用struct定义，因为struct定义的类成员默认都是公有的。

在这里插入图片描述

2.2 默认成员函数

2.2.1 构造函数

void empty_init()
		{
			//创建哨兵位并初始化
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head;
		}
		  list()
		{
			empty_init();
		}

在这里插入图片描述
构造出带哨兵位的空链表
也可以利用迭代器区间进行构造

template<class Inputiterator>
			list(Inputiterator first, Inputiterator last)//利用迭代器区间进行构造
		{
			empty_init();//先要进行初始化，构造出头结点，然后一个个尾插
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}

2.2.2 析构函数

~list()
		{
			clear();
			delete _head;
			_head = nullptr;

		}
		void clear()
		{//删除除哨兵位以外的所有结点
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

2.2.3 拷贝构造

void swap(list<T>& tmp)
		{
			//交换两个链表，即交换两个链表的头结点
			std::swap(_head, tmp._head);
		}
		//lt2(lt1)
		list(const list<T>& lt)//拷贝构造
		{
			empty_init();
			list<T> tmp(lt.begin(), lt.end());//迭代器区间构造出tmp
			swap(tmp);
			//对swap传递参数的理解：这里是调用的lt2的拷贝构造函数，所以在类里面访问lt2的成员变量是用this指针，不用实际传递
		}

注意：在交换前一定要先对lt2初始化，使lt2里面的成员变量_head不是随机值。

2.2.4 赋值重载

//lt2=lt3
		list<T>& operator=(list<T> tmp)//赋值重载
		{
			swap(tmp);
			return *this;
		}

2.3 迭代器

2.3.1 正向迭代器

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

迭代器就是进行遍历容器数据的操作，之前我们所学习的string，vector等顺序容器，其底层都是连续的物理空间，所以就是用指针去实现迭代器的功能如解引用，++等。但是list的底层并不是连续的物理空间，通过存储前后节点的地址将每个结点连接起来，所以直接++就不是下一个结点的位置，也就不能访问到正确的数据。
但是从上层使用的角度，我们还是想和vector,list一样，直接++就可以访问到下一个结点的数据，底层该如何实现呢？这时就要用到C++类的封装和运算符的重载 自己实现一个迭代器类，并重载那些运算符

template <class T,class Ref,class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T,Ref,Ptr> iterator;//iterator是一个结构体，成员变量的类型是Node*
		Node* _node;
		__list_iterator(Node* node)//构造函数
			:_node(node)
		{

		}
		//it!=lt.end()
		bool operator!=(const iterator& it)const
		{
			return _node != it._node;
		}
		bool operator==(const iterator& it)const
		{
			return _node == it._node;
		}
		Ref operator*()//解引用，只返回数据
		{
			return _node->_data;
		}
		Ptr operator->()//返回数据的地址，处理data类型为自定义类型的情况
		{
			return  &(operator*());
		}
		iterator& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		iterator& operator++(int)
		{
			iterator tmp(*this);//拷贝构造，用默认生成的就行，这里就是要指向同一个结点，而不是拷贝出相同的。
			_node = _node->_next;
			return tmp;
		}
		iterator& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		iterator& operator--(int)
		{
			iterator tmp(*this);
			_node = _node->_next;
			return tmp;
		}
	};

迭代器的使用

iterator begin()//用头结点的下一个构造出begin()
		{
			return iterator(_head->_next);//返回的是一个匿名对象
		}
		iterator end()
		{
			return iterator(_head);//用头结点构造出end()
		}

void test1()
	{
		list<int>lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		//尾插1,2,3,4
		list<int>::iterator  it= lt.begin();
		while (it != lt.end())//调用迭代器类里面的!=的运算符重载函数
		{
			cout << *it<<" ";//解引用取到数据
			++it;//指向下一个结点
			
		}
		cout << endl;
		}

void fun(const list<int>& lt)
	{
		list<int>::const_iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << *it<<" ";
			++it;
		}
	}

当const修饰的对象调用迭代器时，就要将迭代器的类模板初始化为常量迭代器，所以给迭代器类增加了Ref和Ptr两个模板参数，对应返回值的引用类型和指针类型

template <class T,class Ref,class Ptr>
typedef __list_iterator<T,T&,T*> iterator;//普通迭代器
typedef __list_iterator < T, const T&, const T*> const_iterator;//const迭代器

->重载的使用场景

struct pos
	{
		int _x;
		int _y;
		pos(int x=0 ,int y=0)
			:_x(x)
			, _y(y)
		{

		}
	};
	void test2()
	{
		list<pos>lt;
		lt.push_back(pos(1, 2));
		lt.push_back(pos(3,4));
		list<pos>::iterator  it = lt.begin();
		while (it != lt.end())
		{
			cout << it ->_x <<"," << it ->_y;
			cout << endl;
			++it;

		}
	}

list里面的数据类型是自定义类型，要访问自定义类型里面的成员变量，可以使用->访问

2.3.2 反向迭代器

反向迭代器的++就是正向迭代器的–，反向迭代器的–就是正向迭代器的++，因此反向迭代器的实现可以借助正向迭代器，即：反向迭代器内部可以包含一个正向迭代器，对正向迭代器的接口进行包装即可。这是一种适配器模式，所以反向迭代器适配所有容器，只用实现一份就好。

template<class Iterator, class Ref, class Ptr>
	struct __reverse_iterator
	{
		typedef __reverse_iterator<Iterator, Ref, Ptr> RIterator;
		Iterator _cur;//成员变量是一个正向迭代器
		__reverse_iterator(Iterator it)//用正向迭代器去构造反向迭代器
			:_cur(it)
		{

		}
		RIterator operator++()
		{
			--_cur;//调用正向迭代器的operator--()
			return *this;
		}
		RIterator operator--()
		{
			++_cur;//调用正向迭代器的operator()++
			return *this;
		}
			bool operator!=(const  RIterator& it)
		{
			return _cur != it._cur;
		}
	};

基本的操作符重载以及构造函数都是用正向迭代器去实现的。

Ref operator*()
		{
			auto tmp = _cur;
			--tmp;
			return *tmp;//返回的是前一个位置的数据
		}
		Ptr operator->()
		{
			return &(operator*());
		}

但是反向迭代器在实现解引用和箭头(->)的操作却是返回前一个位置的数据，这是为何呢？
STL中所有容器的正反向迭代器的实现正好是对应相反，以达到对应的效果。所以我们在实现的时候也是这样。

在这里插入图片描述
所以反向迭代器在实现解引用的时候返回的是上一个结点的数据，箭头(->)返回的是上一个结点数据的地址

在实现解引用操作的时候应注意，当前迭代器的位置不能改变，即当前迭代器指向哪个位置，在返回数据后还是指向那个位置，所以实现返回上一个结点的数据应该用当前迭代器拷贝出一个tmp迭代器，然后用tmp迭代器返回上一个结点的数据。

反向迭代器的使用

typedef __reverse_iterator<iterator,T&,T*> reverse_iterator;
reverse_iterator rbegin()
		{
			return reverse_iterator(end());//正向迭代器去构造反向迭代器
		}
reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}
		list<int>::reverse_iterator  rit = lt.rbegin();
		while (rit != lt.rend())
		{
			cout << *rit << " ";
			++rit;

		}

即在使用反向迭代器的时候，先实现rbegin(),rend()两个接口(用对应容器的end(),begin()去构造),然后就可以实现遍历，打印数据的操作。

2.4 修改接口

2.4.1 任意位置插入

iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* newnode = new Node(x);
			newnode->_next = cur;
			cur->_prev = newnode;
			prev->_next = newnode;
			newnode->_prev = prev;
			return iterator(newnode);
			//pos是iterator类型的结构体，里面的成员变量是Node*类型

		}

2.4.2 任意位置删除

iterator erase(iterator pos)
		{
			assert(pos != end());//不能删除哨兵位
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;
			prev->_next = next;
			next->_prev = prev;
			delete(cur);
			return iterator(next);
		}

2.5 其他接口

2.5.1 尾插

	void push_back(const T& x)
		{
			/*Node* tail = _head->_prev;
			Node* newnode = new Node(x);
			newnode->_prev = tail;
			newnode->_next = _head;
			_head->_prev = newnode;
			tail->_next = newnode;*/
			insert(end(), x);

		}

2.5.2 头插

void push_front(const T& x)
	{
			insert(begin(), x);
	}

2.5.3 尾删

void pop_back()
		{
			erase(--end());
		}

2.5.3 头删

void pop_front()
		{
			erase(begin());
		}

3 list和vector的比较

	vector	list
底层结构	一段连续的空间	带头结点的双向循环链表
随机访问	支持随机访问,访问某个元素效率O(1)	不支持随机访问，访问某个元素效率O(N)
插入和删除	任意位置插入和删除效率低，需要搬移元素	任意位置插入和删除效率高，不需要搬移元素
空间利用率	底层为连续空间，不容易造成内存碎片，空间利用率高	底层节点动态开辟，小节点容易造成内存碎片，空间利用率低
迭代器	原生态指针	对原生态指针(节点指针)进行封装
使用场景	需要高效存储，支持随机访问	大量插入和删除操作，不关心随机访问