深入理解C++ 中的list容器

目录

一、引言

二、list的基本介绍

[2.1 底层结构](#2.1 底层结构)

[2.2 特性](#2.2 特性)

三、list的使用

[3.1 构造函数](#3.1 构造函数)

[3.2 迭代器的使用](#3.2 迭代器的使用)

[3.3 容量相关操作](#3.3 容量相关操作)

[3.4 元素访问相关操作](#3.4 元素访问相关操作)

[3.5 修改器操作](#3.5 修改器操作)

[3.6 迭代器失效问题](#3.6 迭代器失效问题)

四、list的模拟实现

[4.1 节点定义](#4.1 节点定义)

[4.2 迭代器实现](#4.2 迭代器实现)

[4.3 list类实现](#4.3 list类实现)

五、list与vector的对比

表格

六、总结

---

一、引言

在C++ 的标准模板库（STL）中， list 是一种非常重要的序列式容器。它以其独特的底层结构和高效的操作接口，在许多场景下发挥着重要作用。今天，我们就来深入探讨一下 list 容器的方方面面。

二、list的基本介绍

2.1 底层结构

list 的底层是双向链表结构。 每个元素存储在独立的节点中，节点通过指针指向前一个元素和后一个元素 ，并且是带头结点的双向循环链表。这意味着在链表中，头结点可以作为一个哨兵节点，方便进行插入和删除操作，同时循环的特性使得从链表的尾部可以无缝连接到头部。

2.2 特性

**- 插入和删除高效：**由于其链表结构，在任意位置进行插入和删除操作的时间复杂度为 O(1) ，不需要像 vector 那样移动大量元素。

- 双向迭代：支持前后双向迭代，提供了正向迭代器和反向迭代器，方便从不同方向遍历容器。

**- 不支持随机访问：**与 vector 不同， list 不支持任意位置的随机访问。如果要访问第 n 个元素，必须从已知位置（如头部或尾部）开始迭代，时间复杂度为 O(n) 。

三、list的使用

3.1 构造函数

list 提供了多种构造方式：

cpp

#include <list>

#include <iostream>



int main() {

    // 构造包含n个值为val的元素的list

    std::list<int> list1(5, 10); // 包含5个值为10的元素



    // 构造空的list

    std::list<int> list2; 



    // 拷贝构造

    std::list<int> list3(list1); 



    // 用[first, last)区间中的元素构造list

    std::list<int> list4(list1.begin(), list1.end()); 



    for (const auto& num : list1) {

        std::cout << num << " ";

    }

    std::cout << std::endl;



    return 0;

}

3.2 迭代器的使用

迭代器是访问 list 元素的关键工具。 list 提供正向迭代器 begin() 和 end() ，以及反向迭代器 rbegin() 和 rend() 。

cpp

#include <list>

#include <iostream>



int main() {

    std::list<int> myList = {1, 2, 3, 4, 5};



    // 正向遍历

    for (auto it = myList.begin(); it != myList.end(); ++it) {

        std::cout << *it << " ";

    }

    std::cout << std::endl;



    // 反向遍历

    for (auto rit = myList.rbegin(); rit != myList.rend(); ++rit) {

        std::cout << *rit << " ";

    }

    std::cout << std::endl;



    return 0;

}

需要注意的是，begin() 和 end() 是正向迭代器，对其执行 ++ 操作，迭代器向后移动； rbegin() 和 rend() 是反向迭代器，对其执行 ++ 操作，迭代器向前移动。

3.3 容量相关操作

• empty() ：检测 list 是否为空，返回 true 或 false 。

• size() ：返回 list 中有效节点的个数。

cpp

#include <list>

#include <iostream>



int main() {

    std::list<int> myList;

    std::cout << "Is myList empty? " << (myList.empty()? "Yes" : "No") << std::endl;



    myList.push_back(1);

    std::cout << "Size of myList: " << myList.size() << std::endl;



    return 0;

}

3.4 元素访问相关操作

• front() ：返回 list 的第一个节点中值的引用。

• back() ：返回 list 的最后一个节点中值的引用。

cpp

#include <list>

#include <iostream>



int main() {

    std::list<int> myList = {10, 20, 30};

    std::cout << "First element: " << myList.front() << std::endl;

    std::cout << "Last element: " << myList.back() << std::endl;



    return 0;

}

3.5 修改器操作

• push_front(val) ：在 list 首元素前插入值为 val 的元素。

• pop_front() ：删除 list 中第一个元素。

• push_back(val) ：在 list 尾部插入值为 val 的元素。

• pop_back() ：删除 list 中最后一个元素。

• insert(position, val) ：在 list 的 position 位置中插入值为 val 的元素。

• erase(position) ：删除 list 中 position 位置的元素。

• swap(other_list) ：交换两个 list 中的元素。

• clear() ：清空 list 中的有效元素。

cpp

#include <list>

#include <iostream>



int main() {

    std::list<int> myList;

    myList.push_back(1);

    myList.push_back(2);

    myList.push_front(0);



    myList.pop_back();

    myList.pop_front();



    auto it = myList.begin();

    myList.insert(it, 10);



    myList.erase(it);



    std::list<int> anotherList = {3, 4};

    myList.swap(anotherList);



    myList.clear();



    return 0;

}

3.6 迭代器失效问题

由于 list 的底层是双向链表，在插入元素时，不会导致迭代器失效。但在删除元素时，指向被删除节点的迭代器会失效，其他迭代器不受影响。例如：

cpp

#include <list>

#include <iostream>



void TestListIterator() {

    int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

    std::list<int> l(array, array + sizeof(array) / sizeof(array[0]));



    auto it = l.begin();

    while (it != l.end()) {

        l.erase(it++); // 正确做法，erase后it已经指向下一个有效元素

    }

}

如果写成 l.erase(it); ++it; ，在 erase 操作后 it 已经失效，再对其进行 ++ 操作就会出错。

四、list的模拟实现

4.1 节点定义

cpp

template <typename T>

struct ListNode {

    T data;
    ListNode* prev;
    ListNode* next;

    ListNode(const T& val) 
        : data(val)
        , prev(nullptr)
        , next(nullptr)
    {}

};

4.2 迭代器实现

cpp

template <typename T, typename Ref, typename Ptr>

struct ListIterator {

    using iterator_category = std::bidirectional_iterator_tag;

    using value_type = T;

    using reference = Ref;

    using pointer = Ptr;

    using node = ListNode<T>;



    node* ptr;



    ListIterator(node* p) : ptr(p) {}



    reference operator*() { return ptr->data; }

    pointer operator->() { return &(ptr->data); }



    ListIterator& operator++() {

        ptr = ptr->next;

        return *this;

    }

    ListIterator operator++(int) {

        ListIterator temp = *this;

        ptr = ptr->next;

        return temp;

    }



    ListIterator& operator--() {

        ptr = ptr->prev;

        return *this;

    }

    ListIterator operator--(int) {

        ListIterator temp = *this;

        ptr = ptr->prev;

        return temp;

    }



    bool operator!=(const ListIterator& other) const { return ptr != other.ptr; }

    bool operator==(const ListIterator& other) const { return ptr == other.ptr; }

};

4.3 list类实现

cpp

template <typename T>

class List {

private:

    ListNode<T>* head;



public:

    using iterator = ListIterator<T, T&, T*>;

    using const_iterator = ListIterator<T, const T&, const T*>;



    List() {

        head = new ListNode<T>(T());

        head->prev = head;

        head->next = head;

    }



    ~List() {

        clear();

        delete head;

    }



    iterator begin() { return iterator(head->next); }

    iterator end() { return iterator(head); }

    const_iterator begin() const { return const_iterator(head->next); }

    const_iterator end() const { return const_iterator(head); }



    void push_back(const T& val) {

        insert(end(), val);

    }



    void push_front(const T& val) {

        insert(begin(), val);

    }



    iterator insert(iterator pos, const T& val) {

        ListNode<T>* newNode = new ListNode<T>(val);

        ListNode<T>* cur = pos.ptr;

        newNode->prev = cur->prev;

        newNode->next = cur;

        cur->prev->next = newNode;

        cur->prev = newNode;

        return iterator(newNode);

    }



    iterator erase(iterator pos) {

        ListNode<T>* cur = pos.ptr;

        ListNode<T>* nextNode = cur->next;

        cur->prev->next = cur->next;

        cur->next->prev = cur->prev;

        delete cur;

        return iterator(nextNode);

    }



    void clear() {

        iterator it = begin();

        while (it != end()) {

            it = erase(it);

        }

    }

};

五、list与vector的对比

表格

|-------|----------------------------------------------|-------------------------------------------|
| 特性 | vector | list |
| 底层结构 | 动态顺序表，一段连续空间 | 带头结点的双向循环链表 |
| 随机访问 | 支持随机访问，访问某个元素效率 O(1) | 不支持随机访问，访问某个元素效率 O(n) |
| 插入和删除 | 任意位置插入和删除效率低，需要搬移元素，时间复杂度为 O(n) ，插入时可能需要增容 | 任意位置插入和删除效率高，不需要搬移元素，时间复杂度为 O(1) |
| 空间利用率 | 底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高 | 底层节点动态开辟，小节点容易造成内存碎片，空间利用率低，缓存利用率低 |
| 迭代器 | 原生态指针 | 对原生态指针（节点指针）进行封装 |
| 迭代器失效 | 插入元素时，可能导致重新扩容，使原来迭代器失效；删除时，当前迭代器需要重新赋值否则会失效 | 插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响 |
| 使用场景 | 需要高效存储，支持随机访问，不关心插入删除效率 | 大量插入和删除操作，不关心随机访问 |

完整代码

#define _CRT_SECURE_NO_WARNINGS
#pragma once 
#include <iostream> 
using namespace std;
#include <assert.h> 
namespace ldg
{
	// List的节点类 
	template<class T>
	struct ListNode
	{
		ListNode(const T& val = T())
			: _prev(nullptr)
			, _next(nullptr)
			, _val(val)
		{}
		ListNode<T>* _prev;
		ListNode<T>* _next;
		T _val;
	};

	/*

	List 的迭代器

	迭代器有两种实现方式，具体应根据容器底层数据结构实现：

	 1. 原生态指针，比如：vector

	 2. 将原生态指针进行封装，因迭代器使用形式与指针完全相同，因此在自定义的类中必须实现以下方法：

		 1. 指针可以解引用，迭代器的类中必须重载operator*()

		 2. 指针可以通过->访问其所指空间成员，迭代器类中必须重载oprator->()

		 3. 指针可以++向后移动，迭代器类中必须重载operator++()与operator++(int)

			至于operator--()/operator--(int)释放需要重载，根据具体的结构来抉择，双向链表可以向前 移动，所以需要重载，如果是forward_list就不需要重载--

		 4. 迭代器需要进行是否相等的比较，因此还需要重载operator==()与operator!=()

	*/
	template<class T, class Ref, class Ptr>
	class ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;
		// Ref 和 Ptr 类型需要重定义下，实现反向迭代器时需要用到 
	public:
		typedef Ref Ref;
		typedef Ptr Ptr;
	public:
		// 
		// 构造 
		ListIterator(Node* node = nullptr)
			: _node(node)
		{}
		// 
		// 具有指针类似行为 
		Ref operator*()
		{
			return _node->_val;
		}

		Ptr operator->()
		{
			return &(operator*());
		}
		// 
		// 迭代器支持移动 
		Self& operator++()
		{
			_node = _node->_next;
			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& l)const
		{
			return _node != l._node;
		}
		bool operator==(const Self& l)const
		{
			return _node != l._node;
		}
		Node* _node;
	};
	template<class Iterator>
	class ReverseListIterator
	{
		// 注意：此处typename的作用是明确告诉编译器，Ref是Iterator类中的一个类型，而不是静态成员变量 
		// 否则编译器编译时就不知道Ref是Iterator中的类型还是静态成员变量 
		// 因为静态成员变量也是按照 类名::静态成员变量名 的方式访问的 
	public:
		typedef typename Iterator::Ref Ref;
		typedef typename Iterator::Ptr Ptr;
		typedef ReverseListIterator<Iterator> Self;
	public:
		// 
		// 构造 
		ReverseListIterator(Iterator it)
			: _it(it)
		{}
		// 
		// 具有指针类似行为 
		Ref operator*()
		{
			Iterator temp(_it);
			--temp;
			return *temp;
		}
		Ptr operator->()
		{
			return &(operator*());
		}
		// 
		// 迭代器支持移动 
		Self& operator++()
		{
			--_it;
			return *this;
		}

		Self operator++(int)
		{
			Self temp(*this);
			--_it;
			return temp;
		}

		Self& operator--()
		{
			++_it;
			return *this;
		}
		Self operator--(int)
		{
			Self temp(*this);
			++_it;
			return temp;
		}
		// 
		// 迭代器支持比较 
		bool operator!=(const Self& l)const
		{
			return _it != l._it;
		}
		bool operator==(const Self& l)const
		{
			return _it != l._it;
		}
		Iterator _it;
	};

	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		// 正向迭代器 
		typedef ListIterator<T, T&, T*> iterator;
		typedef ListIterator<T, const T&, const T&> const_iterator;
		// 反向迭代器 
		typedef ReverseListIterator<iterator> reverse_iterator;
		typedef ReverseListIterator<const_iterator> const_reverse_iterator;
	public:
		/// 
		// List的构造 
		list()
		{
			CreateHead();
		}

		list(int n, const T& value = T())
		{
			CreateHead();
			for (int i = 0; i < n; ++i)
				push_back(value);
		}
		template <class Iterator>
		list(Iterator first, Iterator last)
		{
			CreateHead();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		list(const list<T>& l)
		{
			CreateHead();

			// 用l中的元素构造临时的temp,然后与当前对象交换 
			list<T> temp(l.begin(), l.end());
			this->swap(temp);
		}

		list<T>& operator=(list<T> l)
		{
			this->swap(l);
			return *this;
		}

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		/// 
		// List的迭代器 
		iterator begin()
		{
			return iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}

		const_iterator begin()const
		{
			return const_iterator(_head->_next);
		}

		const_iterator end()const
		{
			return const_iterator(_head);
		}

		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}

		const_reverse_iterator rbegin()const
		{
			return const_reverse_iterator(end());
		}

		const_reverse_iterator rend()const
		{
			return const_reverse_iterator(begin());
		}
		/// 
		// List的容量相关 
		size_t size()const
		{
			Node* cur = _head->_next;
			size_t count = 0;
			while (cur != _head)
			{
				count++;
				cur = cur->_next;
			}
			return count;
		}

		bool empty()const
		{
			return _head->_next == _head;
		}
		void resize(size_t newsize, const T& data = T())
		{
			size_t oldsize = size();
			if (newsize <= oldsize)
			{
				// 有效元素个数减少到newsize 
				while (newsize < oldsize)
				{

					pop_back();
					oldsize--;
				}
			}
			else
			{
				while (oldsize < newsize)
				{
					push_back(data);
					oldsize++;
				}
			}
		}
		 
		// List的元素访问操作 
		// 注意：List不支持operator[] 
		T& front()
		{
			return _head->_next->_val;
		}
		const T& front()const
		{
			return _head->_next->_val;
		}
		T& back()
		{
			return _head->_prev->_val;
		}
		const T& back()const
		{
			return _head->_prev->_val;
		}
		 
		// List的插入和删除 
		void push_back(const T& val)
		{
			insert(end(), val);
		}
		void pop_back()
		{
			erase(--end());
		}
		void push_front(const T& val)
		{
			insert(begin(), val);
		}
		void pop_front()
		{
			erase(begin());
		}

		// 在pos位置前插入值为val的节点 
		iterator insert(iterator pos, const T& val)
		{
			Node* pNewNode = new Node(val);
			Node* pCur = pos._node;
			// 先将新节点插入 
			pNewNode->_prev = pCur->_prev;
			pNewNode->_next = pCur;
			pNewNode->_prev->_next = pNewNode;
			pCur->_prev = pNewNode;
			return iterator(pNewNode);
		}
		// 删除pos位置的节点，返回该节点的下一个位置 
		iterator erase(iterator pos)
		{
			// 找到待删除的节点 
			Node* pDel = pos._node;
			Node* pRet = pDel->_next;
			// 将该节点从链表中拆下来并删除 
			pDel->_prev->_next = pDel->_next;
			pDel->_next->_prev = pDel->_prev;
			delete pDel;
			return iterator(pRet);
		}

		void clear()
		{
			Node* cur = _head->_next;
			// 采用头删除删除 
			while (cur != _head)
			{
            	_head->_next = cur->_next;
				delete cur;
				cur = _head->_next;
			}
			_head->_next = _head->_prev = _head;
		}

		void swap(ldg::list<T>& l)
		{
			std::swap(_head, l._head);
		}
	private:
		void CreateHead()
		{
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head;
		}
	private:
		Node* _head;
	};
}
/// 
// 对模拟实现的list进行测试 
// 正向打印链表 
template<class T>
void PrintList(const ldg::list<T>& l)
{
	auto it = l.begin();
	while (it != l.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}
// 测试List的构造 
void TestBiteList1()
{
	ldg::list<int> l1;
	ldg::list<int> l2(10, 5);
	PrintList(l2);
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	ldg::list<int> l3(array, array + sizeof(array) / sizeof(array[0]));
	PrintList(l3);
	ldg::list<int> l4(l3);
	PrintList(l4);
	l1 = l4;
	PrintList(l1);
}
// PushBack()/PopBack()/PushFront()/PopFront() 
void TestBiteList2()
{
	// 测试PushBack与PopBack 
	ldg::list<int> l;
	l.push_back(1);
	l.push_back(2);
	l.push_back(3);
	PrintList(l);
	l.pop_back();
	l.pop_back();
	PrintList(l);
	l.pop_back();
	cout << l.size() << endl;
	// 测试PushFront与PopFront 
	l.push_front(1);
	l.push_front(2);
	l.push_front(3);
	PrintList(l);
	l.pop_front();
	l.pop_front();
	PrintList(l);
	l.pop_front();
	cout << l.size() << endl;
}

// 测试insert和erase 
void TestBiteList3()
{

	int array[] = { 1, 2, 3, 4, 5 };
	ldg::list<int> l(array, array + sizeof(array) / sizeof(array[0]));
	auto pos = l.begin();
	l.insert(l.begin(), 0);
	PrintList(l);
	++pos;
	l.insert(pos, 2);
	PrintList(l);
	l.erase(l.begin());
	l.erase(pos);
	PrintList(l);
	// pos指向的节点已经被删除，pos迭代器失效 
	cout << *pos << endl;
	auto it = l.begin();
	while (it != l.end())
	{
		it = l.erase(it);
	}
	cout << l.size() << endl;
}

// 测试反向迭代器 

void TestBiteList4()
{
	int array[] = { 1, 2, 3, 4, 5 };
	ldg::list<int> l(array, array + sizeof(array) / sizeof(array[0]));
	auto rit = l.rbegin();

	while (rit != l.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
	const ldg::list<int> cl(l);
	auto crit = l.rbegin();

	while (crit != l.rend())
	{
		cout << *crit << " ";
		++crit;
	}
	cout << endl;
}

六、总结

list 容器凭借其独特的双向链表结构，在插入和删除操作上具有高效性，适用于需要频繁进行这些操作的场景。通过深入理解其接口和实现原理，我们可以在实际编程中更好地运用它，同时与 vector 等其他容器对比，能更清晰地知道在不同需求下如何选择合适的容器。希望这篇博客能帮助大家对 list 容器有更全面、深入的认识。