C++ STL list 容器详解与模拟实现

C++ STL list 容器是一种双向链表数据结构，支持在任意位置高效插入和删除元素，但不支持随机访问。 list 的基本特性、常用操作（如构造、迭代器、增删改查）及时间复杂度分析，并提供了基于模板的 list 手动模拟实现代码，涵盖节点结构、迭代器定义、核心函数逻辑及测试用例，帮助深入理解其底层原理。

ArchDesign发布于 2026/3/30更新于 2026/4/132 浏览

一、list 介绍

std::list是 C++ 标准模板库 (STL) 中的一个双向链表容器。与 vector和deque不同，list不支持随机访问，但它在任何位置插入和删除元素都非常高效。

1.基本特性

(1)双向链表结构：每个元素都包含指向前驱和后继的指针

(2)非连续存储：元素分散存储在内存中，通过指针连接

(3)时间复杂度：

任意位置插入/删除：O(1)
随机访问：O(n)
遍历：O(n)

二、list常用操作

以下展示 list 常用函数的基础用法及效果。

1.创建和构造

#include <iostream>
#include <list>
using namespace std;

int main() {
    list<int> l1;              // 空 list
    list<int> l2(5);           // 包含 5 个默认构造的元素 (0)
    list<int> l3(5, 10);       // 包含 5 个值为 10 的元素
    list<int> l4 = { 1, 2, 3 }; // 初始化列表
    list<int> l5(l4);          // 拷贝构造
    list<int> l6(l5.begin(), lend()); 
     ;
}

相关免费在线工具

加密/解密文本
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。在线工具，加密/解密文本在线工具，online
Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online
Markdown 转 HTML
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。在线工具，Markdown 转 HTML在线工具，online
HTML 转 Markdown
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。在线工具，HTML 转 Markdown在线工具，online
JSON 压缩
通过删除不必要的空白来缩小和压缩JSON。在线工具，JSON 压缩在线工具，online

list<int> l = { 1, 2, 3, 4, 5 };
cout << l.front() << endl; // 第一个元素 (1)
cout << l.back() << endl;  // 最后一个元素 (5)

// 遍历 list
for (auto it = l.begin(); it != l.end(); ++it) {
    cout << *it << " ";
}
cout << endl;

// C++11 起可用范围 for 循环
for (int val : l) {
    cout << val << " ";
}
return 0;

#define _CRT_SECURE_NO_WARNINGS 1
#include <assert.h>
#include <iostream>
#include <algorithm>

namespace lwf {
    template<class T>
    struct list_node {
        list_node<T>* _next;
        list_node<T>* _prev;
        T _val;
        list_node(const T& val = T()) :_next(nullptr), _prev(nullptr), _val(val) {}
    };

    template<class T, class Ref, class Ptr>
    struct _list_iterator {
        typedef list_node<T> Node;
        typedef _list_iterator<T, Ref, Ptr> self;
        Node* _node;
        _list_iterator(Node* node) :_node(node) {}
        Ref operator*() { return _node->_val; }
        Ptr operator->() { return &_node->_val; }
        self& operator++() { _node = _node->_next; return *this; }
        self operator++(int) { self tmp(*this); _node = _node->_next; return tmp; }
        self& operator--() { _node = _node->_prev; return *this; }
        self operator--(int) { self tmp(*this); _node = _node->_prev; return tmp; }
        bool operator!=(const self& it) { return _node != it._node; }
        bool operator==(const self& it) { return _node == it._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;

        void empty_init() {
            _head = new Node;
            _head->_prev = _head;
            _head->_next = _head;
            _size = 0;
        }

        list() { empty_init(); }

        list(const list<T>& It) {
            empty_init();
            for (auto& e : It) {
                push_back(e);
            }
        }

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

        void swap(list<T> It) {
            std::swap(_head, It._head);
            std::swap(_size, It._size);
        }
        list<T>& operator=(list<T> It) {
            swap(It);
            return *this;
        }

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

        void clear() {
            iterator it = begin();
            while (it != end()) {
                it = erase(it);
            }
            _size = 0;
        }

        size_t size() {
            return _size;
        }

        void push_back(const T& x) {
            insert(end(), x);
        }

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

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

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

        iterator insert(iterator pos, const T& x) {
            Node* cur = pos._node;
            Node* prev = cur->_prev;
            Node* newnode = new Node(x);
            prev->_next = newnode;
            newnode->_prev = prev;
            cur->_prev = newnode;
            newnode->_next = cur;
            ++_size;
            return newnode;
        }

        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;
            --_size;
            return next;
        }

    private:
        Node* _head;
        size_t _size;
    };

    void Test_1() {
        list<int> It;
        It.push_back(1);
        It.push_back(2);
        It.push_back(3);
        It.push_back(4);
        It.push_front(5);
        It.push_front(6);
        It.push_front(7);
        It.push_front(8);
        for (auto& e : It) {
            cout << e << " ";
        }
        cout << endl;
        It.pop_back();
        It.pop_front();
        for (auto& e : It) {
            cout << e << " ";
        }
        cout << endl;
    }

    void Test_2() {
        list<int> It;
        It.push_back(1);
        It.push_back(2);
        It.push_back(3);
        It.push_back(4);
        It.push_front(5);
        It.push_front(6);
        It.push_front(7);
        It.push_front(8);
        for (auto& e : It) {
            cout << e << " ";
        }
        cout << endl;
        It.pop_back();
        It.pop_front();
        for (auto& e : It) {
            cout << e << " ";
        }
        cout << endl;
        It.clear();
        It.push_front(50);
        It.push_front(60);
        It.push_front(70);
        It.push_front(80);
        for (auto& e : It) {
            cout << e << " ";
        }
        cout << endl;
        cout << It.size() << endl;
    }

    void Test_3() {
        list<int> lt;
        lt.push_back(1);
        lt.push_back(2);
        lt.push_back(3);
        lt.push_back(4);
        for (auto e : lt) {
            cout << e << " ";
        }
        cout << endl;
        list<int> lt1(lt);
        for (auto e : lt1) {
            cout << e << " ";
        }
        cout << endl;
        list<int> lt2;
        lt2.push_back(10);
        lt2.push_back(20);
        lt2.push_back(30);
        lt2.push_back(40);
        for (auto e : lt2) {
            cout << e << " ";
        }
        cout << endl;
        lt1 = lt2;
        for (auto e : lt1) {
            cout << e << " ";
        }
        cout << endl;
    }
}

C++ STL list 容器详解与模拟实现

一、list 介绍

1.基本特性

二、list常用操作

1.创建和构造

更多推荐文章

相关免费在线工具

2.迭代器

3.核心成员函数

三、list 模拟实现

1.节点与迭代器定义

C++ STL list 容器详解与模拟实现

一、list 介绍

1.基本特性

二、list常用操作

1.创建和构造

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

2.迭代器

3.核心成员函数

三、list 模拟实现

1.节点与迭代器定义