【C++指南】STL list容器完全解读（一）：从入门到掌握基础操作

.

📝Gitee主页：倔强的石头的gitee主页

⏩ 文章专栏：《C++指南》

期待您的关注

文章目录

• • 一、初识list容器
  • • 1.1 什么是list？
    • 1.2 核心特性
    • 1.3 典型应用场景
    • 二、核心成员函数
    • • 2.1 默认成员函数
      • 三、迭代器操作
      • • 3.1 基础迭代器
        • 3.2 常量迭代器（C++11）
        • 四、容量与访问操作
        • • 4.1 容量查询
          • 4.2 元素访问
          • 五、修改操作详解
          • • 5.1 基础修改函数
            • 5.2 高级修改操作
            • 5.3 插入与删除
            • • insert重载版本
              • erase操作
              • 六、特殊成员函数
              • • 6.1 条件操作
                • 6.2 链表特有操作
                • 七、总结与进阶

                  一、初识list容器

                  1.1 什么是list？

                  在C++标准模板库（STL）中，list是一个基于双向链表实现的序列容器。它允许在任意位置进行高效插入和删除操作，时间复杂度为O(1)。与vector不同，list不保证元素在内存中的连续存储，因此不支持随机访问。

                  

                  1.2 核心特性

                  • 双向链表结构：每个元素包含指向前后节点的指针
                  • 动态内存分配：元素按需分配内存
                  • 高效插入删除：无需移动其他元素
                  • 迭代器稳定性：插入删除操作不会使已有迭代器失效（除被删除元素）

                    1.3 典型应用场景

                    • 需要频繁在首尾之外的位置插入/删除元素
                    • 元素体积较大，避免vector扩容时的拷贝开销
                    • 需要维护元素的插入顺序
                    • 需要合并、拆分链表等特殊操作

                      二、核心成员函数

                      2.1 默认成员函数

                      

                      构造函数的重载版本

                      

                      函数	功能描述	示例
                      默认构造函数	创建空list	list lst1;
                      填充构造函数	创建包含n个元素的list	list lst2(5);
                      拷贝构造函数	复制另一个list的内容	list lst3(lst2);
                      移动构造函数(C++11)	转移另一个list的资源	list lst4(move(lst3));
                      析构函数	自动释放内存（通常无需手动调用）	lst1.~list();
                      拷贝赋值运算符	深拷贝赋值操作	lst2 = lst1;
                      移动赋值运算符(C++11)	高效转移资源赋值操作	lst3 = move(lst2);

                      // 初始化列表构造（C++11）
                      list fruits {"apple", "banana", "cherry"};
                      

                      ---

                      三、迭代器操作

                      

                      3.1 基础迭代器

                      函数	功能	示例
                      begin()	返回指向第一个元素的迭代器	auto it = lst.begin();
                      end()	返回末尾哨兵迭代器	while(it != lst.end())
                      rbegin()	返回反向起始迭代器	auto rit = lst.rbegin();
                      rend()	返回反向结束迭代器	for(; rit != lst.rend();)

                      3.2 常量迭代器（C++11）

                      函数	功能	示例
                      cbegin()	返回不可修改的正向起始迭代器	auto cit = lst.cbegin();
                      cend()	返回不可修改的正向结束迭代器	if(cit == lst.cend())
                      crbegin()	返回不可修改的反向起始迭代器	auto crit = lst.crbegin();
                      crend()	返回不可修改的反向结束迭代器	while(crit != lst.crend())

                      list nums {1,2,3};
                      // 正向遍历
                      for(auto it = nums.begin(); it != nums.end(); ++it) {
                          cout 36.5, 37.1, 38.0};
                      temps.front() = 35.9;  // 修改首元素
                      cout 
                      public:
                          Student(int id, string name) : id(id), name(name) {}
                      private:
                          int id;
                          string name;
                      };
                      list1,2,3});       // 内容变为[1,2,3]
                      nums.resize(5);             // 变为[1,2,3,0,0]
                      nums.resize(3);             // 截断为[1,2,3]
                      10,20,30};
                      auto it = data.begin();
                      advance(it, 1);
                      data.insert(it, 15);        // [10,15,20,30]
                      data.insert(it, 2, 18);     // [10,15,18,18,20,30]
                      vector25,35};
                      data.insert(data.end(), tmp.begin(), tmp.end()); // 末尾追加
                      data.erase(it);             // 删除第二个18
                      1,2,3,2,5};
                      nums.remove(2);  // 删除所有2 → [1,3,5]
                      nums.remove_if([](int x){ return x3; }); // → [1,3]
                      1,3,5}, b {2,4,6};
                      a.merge(b);       // a变为[1,2,3,4,5,6], b为空
                      a.sort();         // 排序（若未有序）
                      list10,20}, y {30,40};
                      auto pos = x.begin();
                      x.splice(pos, y); // x变为[30,40,10,20], y为空