• ＜C++＞ list模拟实现

    目录

    前言

    一、list的使用

    1. list的构造函数

    2. list iterator的使用

    3. list capacity

    4. list modifiers 

    5. list的算法

    1. unique​

    2. sort

    3. merge

    4. remove

    5. splice 

    二、list模拟实现

    1. 设置节点类 && list类

    2. push_back 

    3. 迭代器 

    重载 *

    重载前置 ++

    重载后置++

    重载前置--

    重载后置-- 

    重载 != 

    重载 ==  

    begin() && end() 

    拷贝构造 && 析构函数

    const迭代器

    4. insert 

    5. erase

    6. size

    7. push_back && push_front && pop_back && pop_front 

    8. clear 

    9. list的析构函数 

    10. list的拷贝构造函数 

    11. empty_init 

    12. list的赋值运算符重载

    总结

    前言

            前面学习了string、vector的模拟实现，其两者相似，但今天要学习的list就又有新的不同

    列表是序列容器，允许在序列中的任意位置进行恒定时间插入和擦除操作，以及双向迭代。

    列表容器实现为双向链表;双向链表可以将它们包含的每个元素存储在不同且不相关的存储位置。排序通过与每个元素的关联在内部保持，该链接指向它前面的元素，并链接到它后面的元素。

    它们与forward_list非常相似：主要区别在于forward_list对象是单链表，因此它们只能向前迭代，以换取更小、更高效。

    与其他基本标准序列容器（数组、vector和 deque）相比，列表在已经获得迭代器的容器内任何位置插入、提取和移动元素方面通常表现更好，因此在大量使用这些元素的算法（如排序算法）中也是如此。

    与其他序列容器相比，    lists 和 forward_lists 的主要缺点是它们无法通过其位置直接访问元素;例如，要访问列表中的第六个元素，必须从已知位置（如开始或结束）迭代到该位置，这需要它们之间的距离的线性时间。它们还会消耗一些额外的内存，以保持与每个元素关联的链接信息（这可能是大型小元素列表的重要因素）。

    一、list的使用

    1. list的构造函数

    构造函数（constructor）接口说明
    list（）构造空的list
    list (size_type n, const value_type& val = value_type() )构造的list中包含n个值为val的元素
    list (const list& x)拷贝构造函数
    list (lnputlterator first, inputlterator last)用 [first, last)区间中的元素构造list

    2. list iterator的使用

    函数声明接口声明
    begin + end返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器
    rbegin + rend返回第一个元素的reserve_iterator，即end位置，返回最后一个元素下一个位置的reserve_iterator，即begin位置

    3. list capacity

    函数声明接口说明
    empty检查list是否为空，是返回true，否则返回false
    size返回list中有效结点的个数

    4. list modifiers 

    函数声明接口说明
    push_front
    在list首元素前插入值为val的元素
    pop_front
    删除list中第一个元素
    push_back
    在list尾部插入值为val的元素
    pop_back
    删除list中最后一个元素
    insert
    在list position 位置中插入值为val的元素
    erase
    删除list position位置的元素
    swap
    交换两个list中的元素
    clear
    清空list中的有效元素

            insert、erase 与string的 insert 不同，string的insert形参是下标，而vector、list的形参都是迭代器，但是list和vector还是有不同的，因为vector在第i个位置插入是begin() + i，而list就不能使用迭代器加数字，因为链表物理空间不连续，要实现加的代价有点大。

            要实现迭代器的改变，只能循环自加（重载的++）

    1. 	std::list<int> lt;
    2. 	lt.push_back(1);
    3. 	lt.push_back(2);
    4. 	lt.push_back(3);
    5. 	lt.push_back(4);
    6. 	auto it = lt.begin();
    7. 	for (size_t i = 0; i < 4; i++)
    8. 	{
    9. 		++it;
    10. 	}
    11. 	lt.insert(it, 100);
    12. 	for (auto e : lt)
    13. 	{
    14. 		cout << e << " ";
    15. 	}
    16. 	cout << endl;

            如果我们想在元素3之前插入一个数据，我们应该使用find函数来查找，但是我们可以发现vector、list都没有find函数，这是因为STL将容器和算法分开了，提出了容器公共的算法。

            因为容器数据一般都是私有的，外部不能访问，但是各容器都是通过迭代器访问的，C++通过迭代器提取出了容器公共的算法，迭代器没有暴露原容器的细节，不管是树还是数组...，都是通过同样的方式访问

    1. 	it = c.begin();
    2. 	while (it != c.end())
    3. 	{
    4. 		cout << *it << " ";
    5. 	}

            循环条件也是关键，并不是 it < c.end( )  而是 it != c.end( )，这是因为容器的存储方式不一定连续存储

            

            【first，last)

            所以公共算法是通过迭代器实现的，例如find函数

    1. template<class InputIterator, class T>
    2.   InputIterator find (InputIterator first, InputIterator last, const T& val)
    3. {
    4.   while (first!=last) {
    5.     if (*first==val) return first;
    6.     ++first;
    7.   }
    8.   return last;
    9. }

            例如：

    1. auto it = find(lt.begin(), lt.end(), 3);
    2. if (it != lt.end())
    3. {
    4. 	lt.insert(it, 100);
    5. }
    6.  
    7. for (auto e : lt)
    8. {
    9. 	cout << e << " ";
    10. }
    11.  
    12. cout << endl;

            因为list不需要扩容，节点的地址不改变，所以list的insert就不存在失效的问题

            同理分析erase，迭代器指向的节点被释放，那么迭代器一定是失效的

    5. list的算法

            迭代器从功能上来说，分为：单向、双向、随机 三类迭代器，它是由容器的底层结构决定的

    单向：只能++            forward_list / 哈希

    双向：可以++ / --      list / map / set

    随机：++ / -- / + / -    vector / string / deque

            单向迭代器访问自由度小于双向小于随机。所以，单向迭代器可以使用的情况，双向、随机迭代器都可以访问。

            对于不同的容器，迭代器种类不同，是否使用alrorithm的算法情况也不同，例如sort函数，实现原理是快排，sort的形参只能使用随机迭代器

    1. 	std::list<int> lt;
    2. 	lt.push_back(1);
    3. 	lt.push_back(2);
    4. 	lt.push_back(3);
    5. 	lt.push_back(4);
    6. 	lt.push_back(5);
    7.  
    8. 	//错误，随机sort需要随即迭代器，而list是双向迭代器
    9. 	//sort(lt.begin(), lt.end());
    10. 	for (auto e : lt)
    11. 		cout << e << " ";
    12. 	cout << endl;
    13.  
    14. 	lt.reverse();
    15. 	lt.sort();
    16.  
    17. 	for (auto e : lt)
    18. 		cout << e << " ";
    19. 	cout << endl;

            list的sort实现原理是归并排序，但是一旦数据量增大，list的sort就不合适了，效率还不如转到vector，vector排序后再转回list。

    所以，容器所提供的接口都是有讲究的，vector不提供专门的头插头删（只是复用insert），是因为如果它频繁的头插头删那么就不应该使用vector，而是list。

    再比如，list的sort，因为迭代器的原因，list需要自己实现sort，但是list它不是一个适合多次排序的容器，vector等随机迭代器才适合sort的快排算法，所以list的sort只适合少量数据的排序，数据量如果很大，那么就考虑更改容器来提高效率。

     1. unique

    • 去重函数，注意要先排序 ，不排序去重效率很低
    • 使用双指针进行去重操作

     2. sort

    • 双向迭代器

    3. merge

    • 两个有序链表的合并 
    • 第二个参数是仿函数

    4. remove

    •  等效于find + erase
    • 如果没找到，什么也不做，不会报错

    5. splice 

    • 转接链表，把 list1 的节点取下来，接到 list2 上 ’
    • 可以转接到自身，但是不能重叠，重叠会陷入死循环

    三个重载函数功能：

            1. 将链表x全部转移到position之前位置

            2. 将链表x的 i 迭代器处节点转移到position之前位置，即只转移一个节点

            3. 将链表x从first到last范围的节点全部转移到position之前位置

    例：

    1. int main()
    2. {
    3. 	std::list<int> mylist1, mylist2;
    4. 	std::list<int>::iterator it;
    5.  
    6. 	// set some initial values:
    7. 	for (int i = 1; i <= 4; ++i)
    8. 		mylist1.push_back(i);      // mylist1: 1 2 3 4
    9.  
    10. 	for (int i = 1; i <= 3; ++i)
    11. 		mylist2.push_back(i * 10);   // mylist2: 10 20 30
    12.  
    13. 	it = mylist1.begin();
    14. 	++it;                         // points to 2
    15.  
    16.  
    17. 	//将list2全部接在list1的2之前
    18. 	mylist1.splice(it, mylist2);
    19. 	//部分转移
    20. 	mylist1.splice(it, mylist2, ++mylist2.begin());
    21. 	mylist1.splice(it, mylist2, ++mylist2.begin(), mylist2.end());
    22.  
    23.     //转移到自身
    24. 	mylist1.splice(mylist1.begin(), mylist1, ++mylist1.begin(), mylist2.end());
    25.  
    26. 	return 0;
    27. }

    二、list模拟实现

    1. 设置节点类 && list类

    • list_node采用struct类，因为struct默认是公有，用class也行，但是要加上public，如果不加公有条件，后续使用十分麻烦，还要搞友元

    1. template<class T>
    2. struct list_node
    3. {
    4.     list_node* _next;
    5.     list_node* _prev;
    6.     T _val;
    7. };
    • C++的struct已经成为类，并且还有模板，所以list_node不是类型，list_node才是类型，为了避免书写时忘记，我们重命名
    • list成员变量即为头节点
    1. 	private:
    2. 		Node* _head;

    1. namespace my_list
    2. {
    3. 	template<class T>
    4. 	struct list_node
    5. 	{
    6. 		list_node* _next;
    7. 		list_node* _prev;
    8. 		T _val;
    9. 	};
    10.  
    11. 	template<class T>
    12. 	class list
    13. 	{
    14. 		typedef list_node Node;
    15. 	private:
    16. 		Node* _head;
    17. 	};

    2. push_back 

    • 开辟新节点，新节点类型是一个类，new的时候会调用默认构造，我们再struct类中定义构造函数来构造新节点
    1. namespace my_list
    2. {
    3. 	template<class T>
    4. 	struct list_node
    5. 	{
    6. 		list_node* _next;
    7. 		list_node* _prev;
    8. 		T _val;
    9.  
    10. 		//默认构造
    11. 		list_node(const T& val = T())
    12. 			:_next(nullptr)
    13. 			,_prev(nullptr)
    14. 			,_val(val)
    15. 		{}
    16.  
    17. 	};
    18.  
    19. 	template<class T>
    20. 	class list
    21. 	{
    22. 		typedef list_node Node;
    23. 	public:
    24. 		list()
    25. 		{
    26. 			_head = new Node;
    27. 			_head->_prev = _head;
    28. 			_head->_next = _head;
    29. 		}
    30.  
    31. 		void push_back(const T& x)
    32. 		{
    33. 			Node* tail = _head->_prev;
    34. 			Node* newnode = new Node(x);
    35. 			
    36. 			tail->_next = newnode;
    37. 			newnode->_prev = tail;
    38.  
    39. 			newnode->_next = _head;
    40. 			_head->_prev = newnode;
    41. 		}
    42. 	private:
    43. 		Node* _head;
    44. 	};
    45. }

    3. 迭代器 

    思考：直接将 Node* 作为 iterator 可以吗？

    答案：不能！

    原因：

            1. 首先，Node*作为迭代器解引用得到的是结构体，不是数据

            2. 其次，节点地址不连续，迭代器++不能移动到下一个节点

    之前的vector、string的元素指针天生就有两点优势，所以它们的迭代器就用指针实现

    解决：

            使用运算符重载！将iterator封装为一个类，重载运算符 ++ 和 * 。iterator是自定义类型，它的成员是一个节点的指针

    list<int>::iterator it = lt.begin();

            属于类域的是在类内部定义的，一种为typedef的内嵌类型，另一种是内部类

    1. 	template<class T>
    2. 	struct __list_iterator
    3. 	{
    4. 		typedef list_node Node;
    5. 		//成员
    6. 		Node* _node;
    7.  
    8. 		//默认构造
    9. 		__list_iterator(Node* _node)
    10. 			:_node(node)
    11. 		{}
    12.  
    13. 	};
    • 在 list 内部，我们将__list_iterator 重定义为 iterator，切记用public修饰，因为我们需要在类外部使用迭代器
    • 之所以将迭代器命名为__list_iterator是为了避免重名，因为后面的容器都是需要iterator的

    重载 *

    • 迭代器解引用应为元素值
    1. 		//引用返回，因为节点生命周期不在该函数内
    2. 		//可读可写版本
    3. 		T& operator*()
    4. 		{
    5. 			return _node->_val;
    6. 		}

    重载前置 ++

    • 返回this解引用
    1. 		__list_iterator& operator++()
    2. 		{
    3. 			_node = _node->_next;
    4. 			return *this;
    5. 		}

    重载后置++

    1. 		//后置++
    2. 		__list_iterator operator++(int)
    3. 		{
    4. 			__list_iterator tmp(*this);
    5.  
    6. 			_node = _node->_next;
    7. 			return tmp;
    8. 		}

    重载前置--

    1. 		//前置--
    2. 		self& operator--()
    3. 		{
    4. 			_node = _node->_prev;
    5. 			return *this;
    6. 		}

    重载后置-- 

    1. 		//后置--
    2. 		self operator--(int)
    3. 		{
    4. 			self tmp(*this);
    5.  
    6. 			_node = _node->_prev;
    7. 			return tmp;
    8. 		}

    重载 != 

    • 这里注意const，因为比较!=时，右边时end(), 该函数返回的是临时对象，临时对象具有常性，所以需要const修饰
    1. 		//这里注意const，因为比较!=时，右边时end(),该函数返回的是临时对象，临时对象具有常性
    2. 		bool operator!=(const __list_iterator& it)
    3. 		{
    4. 			return _node != it._node;
    5. 		}

    重载 ==  

    • 复用即可
    1. 		bool operator==(const __list_iterator& it)
    2. 		{
    3. 			return _node == it._node;
    4. 		}

    begin() && end() 

    • 返回指针类型会隐式类型转换为iterator类，我们也可以直接返回匿名对象
    1. 	template<class T>
    2. 	struct __list_iterator
    3. 	{
    4. 		typedef list_node Node;
    5. 		//成员
    6. 		Node* _node;
    7.  
    8. 		//默认构造
    9. 		__list_iterator(Node* node)
    10. 			:_node(node)
    11. 		{}
    12.  
    13. 		//引用返回，因为节点生命周期不在该函数内
    14. 		//可读可写版本
    15. 		T& operator*()
    16. 		{
    17. 			return _node->_val;
    18. 		}
    19.  
    20. 		__list_iterator& operator++()
    21. 		{
    22. 			_node = _node->_next;
    23. 			return *this;
    24. 		}
    25.  
    26. 		//这里注意const，因为比较!=时，右边时end(),该函数返回的是临时对象，临时对象具有常性
    27. 		bool operator!=(const __list_iterator& it)
    28. 		{
    29. 			return _node != it._node;
    30. 		}
    31. 	};
    32.  
    33. 	template<class T>
    34. 	class list
    35. 	{
    36. 		typedef list_node Node;
    37. 	public:
    38. 		//迭代器要公有，让外面可以使用
    39. 		typedef __list_iterator iterator;
    40.  
    41. 		iterator begin()
    42. 		{
    43. 			//由指针类型隐式转换为iterator类
    44. 			//return _head->_next;
    45.  
    46. 			//也可以用匿名对象
    47. 			return iterator(_head->_next);
    48. 		}
    49.  
    50. 		iterator end()
    51. 		{
    52. 			return iterator(_head);
    53. 		}
    54.  
    55. 		list()
    56. 		{
    57. 			_head = new Node;
    58. 			_head->_prev = _head;
    59. 			_head->_next = _head;
    60. 		}
    61.  
    62. 	private:
    63. 		Node* _head;
    64. 	};
    65.  
    66. }

     拷贝构造 && 析构函数

    list<int>::iterator it = lt.begin();

    1. 这里就是拷贝构造 it ，但是成员是内置类型Node*，浅拷贝正确吗？

            我们要的就是那个节点的指针，就是需要浅拷贝来访问该节点，所以对于iterator的拷贝构造我们仅仅就是需要浅拷贝即可，不需要深拷贝，所以编译器默认生成的就足够使用。

    2. 但是，我们要思考，多个迭代器对象指向同一个节点，会导致程序崩溃吗？

            浅拷贝导致程序崩溃的原因就是多次析构，但是每次使用完迭代器，就需要析构该节点吗？

            不可以！节点不属于迭代器，迭代器无权释放节点，迭代器仅仅是访问修改功能，有权限释放节点的是 list 的析构函数

    .

    所以，在实际的工作中，对于内置类型指针，需要浅拷贝or深拷贝是根据目标来决定的

     const迭代器

    如何设计const迭代器？

            

    typedef const __list_iterator const_iterator;

            这样设计可以吗？

            不可以！如果这样设计，迭代器本身就不能修改了。

            我们想实现的是迭代器指向的内容不能被修改，而迭代器本身可以++修改指向，如果使用上面的迭代器，那么我们就不能修改迭代器了，因为const迭代器对象就不能调用++函数，因为++函数没有const修饰，也不能加上const修饰，因为函数内要进行修改

            正确设计应将解引用重载函数的返回值设为const T&，

    但是又来了一个问题，我们需要再写一个除了解引用重载函数外一模一样的const_iterator类吗？

            代码冗余！

    我们来看stl的解决方案：

    • 因为只有解引用的返回值不同，所以在这里我们可以使用模板参数控制返回值类型
    • 对 __list_iterator 重命名为self，方便日后再次修改模板时，不用再去修改各成员函数的返回值
    1. 	//typedef __list_iterator iterator;
    2. 	//typedef __list_iterator const_iterator;
    3. 	//对于const迭代器和普通迭代器，这属于两个类，根据模板生成相应的类
    4. 	template<class T, class Ref>
    5. 	struct __list_iterator
    6. 	{
    7. 		typedef list_node Node;
    8. 		typedef __list_iterator self;
    9.  
    10. 		//成员变量
    11. 		Node* _node;
    12.  
    13. 		__list_iterator(Node* node)
    14. 			:_node(node)
    15. 		{}
    16.  
    17. 		//引用返回，因为节点生命周期不在该函数内
    18. 		//可读可写版本
    19. 		//Ref根据不同的参数，返回相应权限的引用
    20. 		Ref operator*()
    21. 		{
    22. 			return _node->_val;
    23. 		}
    24.  
    25. 		//前置++
    26. 		self& operator++()
    27. 		{
    28. 			_node = _node->_next;
    29. 			return *this;
    30. 		}
    31.  
    32. 		//后置++
    33. 		self operator++(int)
    34. 		{
    35. 			self tmp(*this);
    36.  
    37. 			_node = _node->_next;
    38. 			return tmp;
    39. 		}
    40.  
    41. 		//这里注意const，因为比较!=时，右边时end(),该函数返回的是临时对象，临时对象具有常性
    42. 		bool operator!=(const self& it)
    43. 		{
    44. 			return _node != it._node;
    45. 		}
    46.  
    47. 		bool operator==(const self& it)
    48. 		{
    49. 			return _node == it._node;
    50. 		}
    51. 	};

            我们再来升级：

            可以看到STL的list模板有三个类型，并且list的重载函数重载了->。

    问：为什么要重载 ->呢？*解引用得不到数据吗？

    答：是的，对于其他的自定义类型，operator*确实得不到其中数据，例如

    1. struct A
    2. {
    3. 	A(int a1 = 0, int a2 = 0)
    4. 		:_a1(a1)
    5. 		,_a2(a2)
    6. 	{}
    7.  
    8. 	int _a1;
    9. 	int _a2;
    10. };
    11.  
    12. void test()
    13. {
    14. 	list lt;
    15. 	lt.push_back(A(1, 1));
    16. 	lt.push_back(A(2, 2));
    17. 	lt.push_back(A(3, 3));
    18. 	lt.push_back(A(4, 4));
    19.  
    20. 	list::iterator it = lt.begin();
    21. 	while (it != lt.end())
    22. 	{
    23. 		cout << *it << " ";
    24. 		++it;
    25. 	}
    26. 	cout << endl;
    27. }

            编译错误，对于*it，解引用的结果是结构体，如果想要输出，要自己重载流插入和流提取，对于私有的变量，是需要自己重载，但是对于公有的变量，我们可以用 ->或(*it)._a1来访问数据。用 -> 是因为迭代器模拟的就是指针 

            但是，it -> _a1本质其实是it -> -> _a1，因为第一个->是运算符重载，返回的是一个指针，后面没有运算符了，所以是访问不了数据的，能访问是因为 迭代器特殊处理，省略了一个->

            由于operator->返回值有两种类型，所以我们又加了一个模板参数Ptr

    template<class T, class Ref, class Ptr>

            所以对于复杂的代码，很难一步看懂，先省略细节，往后看

    4. insert 

    • 在pos之前插入，由于双向链表特性，pos在哪里都可以，即使是头节点，那就是尾插
    • 返回插入后的迭代器
    1. 		//在pos之前插入，由于双向链表特性，pos哪里都可以，即使是头节点
    2. 		iterator insert(iterator pos)
    3. 		{
    4. 			//这里就体现了struct比class优点，class是需要封装为私有的，后面还要搞友元
    5. 			Node* cur = pos._node;
    6. 			Node* prev = cur->_prev;
    7. 			Node* newnode = new Node(x);
    8.  
    9. 			prev->_next = newnode;
    10. 			newnode->_next = cur;
    11.  
    12. 			cur->_prev = newnode;
    13. 			newnode->_prev = prev;
    14.  
    15. 			++_size;
    16.  
    17. 			return newnode;
    18. 		}

    5. erase

    • erase就需要判断pos是否合法
    • 返回删除后的下一个迭代器
    1. 		iterator erase(iterator pos)
    2. 		{
    3. 			assert(pos != end());
    4.  
    5. 			Node* cur = pos._node;
    6. 			Node* prev = cur->_prev;
    7. 			Node* next = cur->_next;
    8.  
    9. 			prev->_next = next;
    10. 			next->_prev = prev;
    11. 			delete cur;
    12.  
    13. 			--_size;
    14.  
    15. 			return next;
    16. 		}

    6. size

    • 可以遍历一遍，时间复杂度是O(N)
    • 也可以加一个_size成员变量，记录size
    1. 		size_t size()
    2. 		{
    3. 			/*size_t sz = 0;
    4. 			iterator it = begin();
    5. 			while (it != end())
    6. 			{
    7. 				++sz;
    8. 				++it;
    9. 			}
    11. 			return sz;*/
    12.  
    13. 			//也可增加一个_size的成员变量
    14. 			return _size;
    15. 		}

    7. push_back && push_front && pop_back && pop_front 

    • 全部复用insert、erase即可
    1. 		void push_back(const T& x)
    2. 		{
    3. 			/*Node* tail = _head->_prev;
    4. 			Node* newnode = new Node(x);
    5. 			
    6. 			tail->_next = newnode;
    7. 			newnode->_prev = tail;
    9. 			newnode->_next = _head;
    10. 			_head->_prev = newnode;*/
    11. 			insert(end(), x);
    12. 		}
    13.  
    14. 		void push_front(const T& x)
    15. 		{
    16. 			insert(beign(), x);
    17. 		}
    18.  
    19. 		void pop_back()
    20. 		{
    21. 			erase(--end());
    22. 		}
    23.  
    24. 		void pop_front()
    25. 		{
    26. 			erase(begin());
    27. 		}

    8. clear 

    • 清除数据，除了头节点
    1. 		//清数据，不需要清除头节点
    2. 		void clear()
    3. 		{
    4. 			iterator it = beign();
    5. 			while (it != end())
    6. 			{
    7. 				//不要++it，迭代器失效
    8. 				it = erase(it);
    9. 			}
    10. 			_size = 0;
    11. 		}

    9. list的析构函数 

    • 复用clear函数
    1. 		~list()
    2. 		{
    3. 			//复用clear
    4. 			clear();
    5. 			delete _head;
    6. 			_head = nullptr;
    7. 		}

    10. list的拷贝构造函数 

    • 逐个push_back即可
    1. 		//拷贝构造
    2. 		list(const list& lt)
    3. 		{
    4. 			_head = new Node;
    5. 			_head->_prev = _head;
    6. 			_head->_next = _head;
    7. 			_size = 0;
    8.  
    9. 			for (auto& e : lt)	//引用是为了防止数组类型很大
    10. 			{
    11. 				push_back(e);
    12. 			}
    13. 		}

    11. empty_init 

    • 因为构造和拷贝构造都需要四行初始化，所以我们封装为empty_init函数
    1. 		void empty_init()
    2. 		{
    3. 			_head = new Node;
    4. 			_head->_prev = _head;
    5. 			_head->_next = _head;
    6.  
    7. 			_size = 0;
    8. 		}

    12. list的赋值运算符重载

    • 现代写法
    1. 		void swap(list& lt)
    2. 		{
    3. 			std::swap(_head, lt._head);
    4. 			std::swap(_size, lt._size);
    5. 		}
    6. 		
    7. 		list& operator=(list lt)	//赋值运算符重载的现代写法
    8. 		{
    9. 			swap(lt);
    10. 			return *this;
    11. 		}

            注意：对于拷贝构造和赋值运算符重载，STL的list中这两个函数声明时，返回值是list&，而我们写的是list&，list是类型，list是类名，写类型是必然正确的，但是这里写类名也对，编译器也可以识别。 

            类模板在类里既可以写类名又可以写类型，但是不推荐缩写类型名

    整体代码

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5.  
    6. namespace my_list
    7. {
    8. 	template<class T>
    9. 	struct list_node
    10. 	{
    11. 		//成员
    12. 		list_node* _next;
    13. 		list_node* _prev;
    14. 		T _val;
    15.  
    16. 		//默认构造
    17. 		list_node(const T& val = T())
    18. 			:_next(nullptr)
    19. 			,_prev(nullptr)
    20. 			,_val(val)
    21. 		{}
    22.  
    23. 	};
    24.  
    25.  
    26. 	//typedef __list_iterator iterator;
    27. 	//typedef __list_iterator const_iterator;
    28. 	//对于const迭代器和普通迭代器，这属于两个类，根据模板生成相应的类
    29. 	template<class T, class Ref, class Ptr>
    30. 	struct __list_iterator
    31. 	{
    32. 		typedef list_node Node;
    33. 		typedef __list_iterator self;
    34.  
    35. 		//成员变量
    36. 		Node* _node;
    37.  
    38. 		__list_iterator(Node* node)
    39. 			:_node(node)
    40. 		{}
    41.  
    42. 		//引用返回，因为节点生命周期不在该函数内
    43. 		//可读可写版本
    44. 		//Ref根据不同的参数，返回相应权限的引用
    45. 		Ref operator*()
    46. 		{
    47. 			return _node->_val;
    48. 		}
    49.  
    50. 		//第三个模板参数，T* 和 const T*
    51. 		Ptr operator->()
    52. 		{
    53. 			return &(_node->_val);
    54. 		}
    55.  
    56. 		//前置++
    57. 		self& operator++()
    58. 		{
    59. 			_node = _node->_next;
    60. 			return *this;
    61. 		}
    62.  
    63. 		//后置++
    64. 		self operator++(int)
    65. 		{
    66. 			self tmp(*this);
    67.  
    68. 			_node = _node->_next;
    69. 			return tmp;
    70. 		}
    71.  
    72. 		//前置--
    73. 		self& operator--()
    74. 		{
    75. 			_node = _node->_prev;
    76. 			return *this;
    77. 		} 
    78.  
    79. 		//后置--
    80. 		self operator--(int)
    81. 		{
    82. 			self tmp(*this);
    83.  
    84. 			_node = _node->_prev;
    85. 			return tmp;
    86. 		}
    87.  
    88. 		//这里注意const，因为比较!=时，右边时end(),该函数返回的是临时对象，临时对象具有常性
    89. 		bool operator!=(const self& it)
    90. 		{
    91. 			return _node != it._node;
    92. 		}
    93.  
    94. 		bool operator==(const self& it)
    95. 		{
    96. 			return _node == it._node;
    97. 		}
    98. 	};
    99.  
    100. 	template<class T>
    101. 	class list
    102. 	{
    103. 		typedef list_node Node;
    104. 	public:
    105. 		typedef __list_iterator iterator;	//迭代器要公有，让外面可以使用
    106. 		typedef __list_iteratorconst T&, const T*> const_iterator;
    107.  
    108. 		iterator begin()
    109. 		{
    110. 			//由指针类型隐式转换为iterator类
    111. 			//return _head->_next;
    112.  
    113. 			//也可以用匿名对象
    114. 			return iterator(_head->_next);
    115. 		}
    116.  
    117. 		iterator end()
    118. 		{
    119. 			return iterator(_head);
    120. 		}
    121.  
    122. 		const_iterator beign() const
    123. 		{
    124. 			return const_iterator(_head->next);
    125. 		}
    126.  
    127. 		const_iterator end() const
    128. 		{
    129. 			return const_iterator(_head);
    130. 		}
    131.  
    132. 		void empty_init()
    133. 		{
    134. 			_head = new Node;
    135. 			_head->_prev = _head;
    136. 			_head->_next = _head;
    137.  
    138. 			_size = 0;
    139. 		}
    140.  
    141. 		list()
    142. 		{
    143. 			/*_head = new Node;
    144. 			_head->_prev = _head;
    145. 			_head->_next = _head;
    147. 			_size = 0;*/
    148. 			//因为构造和拷贝构造都需要这四行初始化，所以我们封装为empty_init
    149. 			empty_init();
    150. 		}
    151.  
    152. 		//拷贝构造
    153. 		list(const list& lt)
    154. 		{
    155. 			/*_head = new Node;
    156. 			_head->_prev = _head;
    157. 			_head->_next = _head;
    158. 			_size = 0;*/
    159. 			empty_init();
    160.  
    161. 			for (auto& e : lt)	//引用是为了防止数组类型很大
    162. 			{
    163. 				push_back(e);
    164. 			}
    165. 		}
    166.  
    167. 		void swap(list& lt)
    168. 		{
    169. 			std::swap(_head, lt._head);
    170. 			std::swap(_size, lt._size);
    171. 		}
    172. 		
    173. 		//list是类型
    174. 		list& operator=(list lt)	//赋值运算符重载的现代写法
    175. 		{
    176. 			swap(lt);
    177. 			return *this;
    178. 		}
    179.  
    180. 		~list()
    181. 		{
    182. 			//复用clear
    183. 			clear();
    184. 			delete _head;
    185. 			_head = nullptr;
    186. 		}
    187.  
    188. 		//清数据，不需要清除头节点
    189. 		void clear()
    190. 		{
    191. 			iterator it = beign();
    192. 			while (it != end())
    193. 			{
    194. 				//不要++it，迭代器失效
    195. 				it = erase(it);
    196. 			}
    197. 			_size = 0;
    198. 		}
    199.  
    200. 		void push_back(const T& x)
    201. 		{
    202. 			/*Node* tail = _head->_prev;
    203. 			Node* newnode = new Node(x);
    204. 			
    205. 			tail->_next = newnode;
    206. 			newnode->_prev = tail;
    208. 			newnode->_next = _head;
    209. 			_head->_prev = newnode;*/
    210. 			insert(end(), x);
    211. 		}
    212.  
    213. 		void push_front(const T& x)
    214. 		{
    215. 			insert(beign(), x);
    216. 		}
    217.  
    218. 		void pop_back()
    219. 		{
    220. 			erase(--end());
    221. 		}
    222.  
    223. 		void pop_front()
    224. 		{
    225. 			erase(begin());
    226. 		}
    227.  
    228. 		//在pos之前插入，由于双向链表特性，pos哪里都可以，即使是头节点
    229. 		iterator insert(iterator pos)
    230. 		{
    231. 			//这里就体现了struct比class优点，class是需要封装为私有的，后面还要搞友元
    232. 			Node* cur = pos._node;
    233. 			Node* prev = cur->_prev;
    234. 			Node* newnode = new Node(x);
    235.  
    236. 			prev->_next = newnode;
    237. 			newnode->_next = cur;
    238.  
    239. 			cur->_prev = newnode;
    240. 			newnode->_prev = prev;
    241.  
    242. 			++_size;
    243.  
    244. 			return newnode;
    245. 		}
    246.  
    247. 		iterator erase(iterator pos)
    248. 		{
    249. 			assert(pos != end());
    250.  
    251. 			Node* cur = pos._node;
    252. 			Node* prev = cur->_prev;
    253. 			Node* next = cur->_next;
    254.  
    255. 			prev->_next = next;
    256. 			next->_prev = prev;
    257. 			delete cur;
    258.  
    259. 			--_size;
    260.  
    261. 			return next;
    262. 		}
    263.  
    264. 		size_t size()
    265. 		{
    266. 			/*size_t sz = 0;
    267. 			iterator it = begin();
    268. 			while (it != end())
    269. 			{
    270. 				++sz;
    271. 				++it;
    272. 			}
    274. 			return sz;*/
    275.  
    276. 			//也可增加一个_size的成员变量
    277. 			return _size;
    278. 		}
    279.  
    280. 	private:
    281. 		Node* _head;
    282. 		size_t _size;
    283. 	};
    284.  
    285. }

    总结

            list相较于vector、string最重要的是迭代器的设计，list因为数据类型、储存方式而需要独特的迭代器——类来实现，除此之外，list无更多新的内容，对于反向迭代器，会在之后的适配器同意讲解。下节，我们来学习stack、queue。

            最后，如果小帅的本文哪里有错误，还请大家指出，请在评论区留言（ps：抱大佬的腿），新手创作，实属不易，如果满意，还请给个免费的赞，三连也不是不可以（流口水幻想）嘿！那我们下期再见喽，拜拜！

  • 相关阅读:
    javascript中数组和对象的解构
    VirtualBox安装CentOS 7教程
    2023昆明理工大学计算机考研信息汇总
    process.env环境变量配置方式（配置环境变量区分开发环境和生产环境）
    照片图片 动漫化 卡通化
    面向对象之抽象类的认识 - （java语法）
    最新版SpringBoot整合Mybatis，实现增删改查（CRUD）
    AWS SAA C003 Test --EBS snapshot
    黑马程序员2023新版JavaWeb企业开发全流程学习笔记（涵盖Spring+MyBatis+SpringMVC+SpringBoot等）
    P2824 [HEOI2016/TJOI2016] 排序
  • 原文地址：https://blog.csdn.net/prodigy623/article/details/134107108