C/C++总述：Study C/C++-****博客 

目录

定义和初始化list对象

list中元素的访问

list的大小与容量

list的增

list的删 

list的改

list的模拟实现

C++ 标准库中的 list 是一种双向链表容器，它支持快速的插入和删除操作。

​

list 容器中各个元素的前后顺序是靠指针来维系的，每个元素都配备了 2 个指针，分别指向它的前一个元素和后一个元素。其中第一个元素的前向指针总为 null，因为它前面没有元素；同样，尾部元素的后向指针也总为 null。

#include <list>
using std::list;

定义和初始化list对象

1. 创建一个没有任何元素的空 list 容器：

   list<int> lt;

2. 创建一个包含 n 个元素的 list 容器：

   list<int> lt(10);//创建lt容器，其中包含10个元素，每个元素的值都为相应类型的默认值（int类型的默认值为0）

3. 创建一个包含 n 个元素的 list 容器，并为每个元素指定初始值:

   list<int> lt(10, 5);//创建了一个包含10个元素并且值都为5个lt容器。

4. 在已有 list 容器的情况下，通过拷贝该容器可以创建新的 list 容器:

   list<int> lt1(10);
   list<int> lt2(lt1);//注意：采用此方式，必须保证新旧容器存储的元素类型一致。

5. 通过拷贝其他类型容器（或者普通数组）中指定区域内的元素，可以创建新的 list 容器:

   //拷贝普通数组，创建list容器
   int a[] = { 1,2,3,4,5 };
   list<int> lt1(a, a+5);
   //拷贝其它类型的容器，创建 list 容器
   vector<int, 5>ve{ 11,12,13,14,15 };
   list<int>lt(ve.begin()+2, ve.end());//拷贝ve容器中的{13,14,15}

list中元素的访问

list的大小与容量

list的增

list的删 

list的改

list的模拟实现

#include<string>
#include<vector>
#include<iostream>
 
using namespace std;
namespace mylist 
{
	template<class T>
    //链表的每个结点的结构
	struct list_node 
	{
		T _data;            //存放数据
		list_node<T>* _prev;//指向前一个结点的指针
		list_node<T>* _next;//指向后一个结点的指针
 
		list_node(const T& val = T())  //构造一个结点对象
			:_data(val)
			, _prev(nullptr)
			, _next(nullptr)
		{ }
	};
 
	// T T& T*
	// T cosnt T& const T*
	template<class T,class Ref,class Ptr>
	struct __list_iterator                   //list的迭代器结构
	{
		typedef list_node<T> Node;             //结点
		typedef __list_iterator<T,Ref,Ptr> _self; //_self就是一个实例化的迭代器
		Node* _node;                          //结点的指针
 
		__list_iterator(Node* node)
			:_node(node)
		{
 
		}
 
		Ref operator*()                //重载运算符* 通过*能够访问结点里面的数据
		{
			return _node->_data;
		}
        
		Ptr operator->()         //重载-> ， 结构体指针访问成员可以用结构体对象->结构体成员
		{
			return &_node->_data;
		}
 
		_self& operator++()   //重载运算符前置++,返回下一个结点的迭代器
		{
			_node = _node->_next;
			return (*this);
		}
 
		_self& operator--()  //重载运算符前置--,返回前一个结点的迭代器
		{
			_node = _node->_prev;
			return (*this);
		}
 
		_self operator++(int)  //重载运算符后置++,返回当前结点的迭代器的拷贝再++
		{
			Node* tmp(_node);
			_node = _node->_next;
 
			return tmp;
		}
 
		_self operator--(int) //重载运算符前置--,返回当前一个结点迭代器的拷贝再--
		{
			Node* tmp(_node);
			_node = _node->_prev;
 
			return tmp;
		}
 
		bool operator!=(const _self& n)  //重载迭代器的比较运算符!=
		{
			return this->_node != n._node;
		}
 
		bool operator==(const _self& n)  //重载迭代器的比较运算符==
		{
			return this->_node == n._node;
		}
 
	};
 
	template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;
 
		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}
			
		const_iterator end() const
		{
			return const_iterator(_head);
		}
 
		iterator begin()
		{
			return (_head->_next);
		}
 
		iterator end()
		{
			return _head;
		}
 
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
 
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
 
		}
 
		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}
 
		list()
		{
			empty_init();
		}
 
		//lt1(lt2)
		list(const list<T>& lt)
		{
 
			empty_init();
			for (auto e : lt)
			{
				push_back(e);
			}
		}
 
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
 
		list<int>& operator=(list<int>lt)
		{
			swap(lt);
			return *this;
		}
 
		void push_back(const T& x)
		{
			insert(end(), x);
		}
 
		void push_front(const T& x)
		{
			insert(begin(), x);
		}
 
		void pop_back(const T& x)
		{
			erase(--end());
		}
 
		void pop_front(const T& x)
		{
			erase(begin());
		}
 
		iterator insert(iterator pos, const T& x)
		{
			Node* newnode = new Node(x);
			Node* cur = pos._node;
			Node* prev = cur->_prev;
 
			prev->_next = newnode;
			newnode->_prev = prev;
 
			newnode->_next = cur;
			cur->_prev = newnode;
 
			++_size;
			return iterator(newnode);
 
		}
 
		iterator erase(iterator pos)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;
 
			delete cur;
			prev->_next = next;
			next->_prev = prev;
			--_size;
			return iterator(next);
		}
 
		size_t size()
		{
			return _size;
		}
 
	private:
		Node* _head; //list的头结点
		size_t _size;//list的大小
 
	};
}