为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 STL容器入门：简单易懂的教程

STL容器入门：简单易懂的教程

标签：
C++
概述

本文介绍了STL容器入门知识，包括容器的基本概念、分类、优势以及常用容器的操作方法。通过详细讲解和示例代码，帮助读者理解和使用STL容器。STL容器提供了丰富的功能和高效的实现，适用于各种数据结构和算法需求。STL容器入门教程适合初学者快速上手和掌握。

STL容器入门：简单易懂的教程
STL容器简介

STL容器的基本概念

STL（Standard Template Library，标准模板库）是C++中一个强大的库，它提供了许多数据结构和算法的实现。STL中的容器是用来存储和组织数据的基本类型。容器提供了灵活的方式来处理大量的数据，涵盖从简单的数组到复杂的树形结构。容器支持各种操作，如元素的添加、删除、访问和修改等。

STL容器的分类

STL容器可以分为序列容器（Sequence Containers）、关联容器（Associative Containers）和容器适配器（Container Adapters）三大类。

序列容器（Sequence Containers）

  • 向量（vector）：动态数组。
  • 链表（list）：双向链表。
  • 队列（queue）：双端队列。
  • 堆栈（stack）：后进先出（LIFO）堆栈。
  • 双端队列（deque）：两端都可以进行插入和删除操作的动态数组。

关联容器（Associative Containers）

  • 集合（set）：元素唯一且有序的集合。
  • 多重集（multiset）：允许重复元素的集合。
  • 映射（map）：元素成对（键值对）且键唯一且有序的映射。
  • 多重映射（multimap）：允许重复键的映射。

容器适配器（Container Adapters）

  • 队列（queue）：基于双端队列的队列。
  • 堆栈（stack）：基于链表的堆栈。
  • 优先队列（priority_queue）：基于堆的优先队列。

使用STL容器的优势

  • 代码复用：STL容器已经实现了许多常见的操作，如插入、删除、遍历等，可以减少重复代码。
  • 提高效率：STL容器使用高效的数据结构和算法，能够提高程序性能。
  • 易于扩展：STL容器支持自定义数据类型，可以方便地扩展和修改。
  • 标准的接口：使用STL容器，可以确保代码具有统一和标准的接口，便于维护。
  • 提供丰富的功能：STL容器提供了丰富的功能，使开发变得更加灵活和高效。
常用容器介绍

向量(vector)

向量（vector）是动态数组的一种实现。它可以根据需要动态地调整大小，同时提供随机访问元素的能力。

容器的初始化与基本操作

#include <vector>
#include <iostream>

int main() {
    // 初始化一个vector
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::cout << "Initial vector elements: ";
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 添加元素
    vec.push_back(6);
    std::cout << "After adding element 6: ";
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 删除元素
    vec.pop_back();
    std::cout << "After removing the last element: ";
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 访问元素
    std::cout << "Element at index 2: " << vec[2] << "\n";

    // 修改元素
    vec[2] = 10;
    std::cout << "After modifying element at index 2: ";
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 遍历容器
    std::cout << "Iterating through the vector: ";
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    return 0;
}

链表(list)

链表（list）是一种双向链表，它允许在任意位置插入和删除元素，而不需要移动其他元素。

容器的初始化与基本操作

#include <list>
#include <iostream>

int main() {
    // 初始化一个list
    std::list<int> lst;
    lst.push_back(1);
    lst.push_back(2);
    lst.push_back(3);
    lst.push_back(4);

    std::cout << "Initial list elements: ";
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 添加元素
    lst.push_front(0);
    std::cout << "After adding element 0: ";
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 删除元素
    lst.pop_front();
    std::cout << "After removing the first element: ";
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 访问元素
    std::cout << "Element at index 3: " << lst.front() << "\n";

    // 修改元素
    lst.front() = 5;
    std::cout << "After modifying the first element: ";
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 遍历容器
    std::cout << "Iterating through the list: ";
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    return 0;
}

队列(queue)

队列（queue）是一种先进先出（FIFO）的数据结构，通常用于实现队列的功能，如任务队列。

容器的初始化与基本操作

#include <queue>
#include <iostream>

int main() {
    // 初始化一个queue
    std::queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);

    std::cout << "Initial queue elements: ";
    while (!q.empty()) {
        std::cout << q.front() << " ";
        q.pop();
    }
    std::cout << "\n";

    // 添加元素
    q.push(5);
    std::cout << "After adding element 5: ";
    while (!q.empty()) {
        std::cout << q.front() << " ";
        q.pop();
    }
    std::cout << "\n";

    // 删除元素
    q.push(6);
    q.pop();
    std::cout << "After removing the first element: ";
    while (!q.empty()) {
        std::cout << q.front() << " ";
        q.pop();
    }
    std::cout << "\n";

    return 0;
}

堆栈(stack)

堆栈（stack）是一种后进先出（LIFO）的数据结构，通常用于实现堆栈的功能，如函数调用栈。

容器的初始化与基本操作

#include <stack>
#include <iostream>

int main() {
    // 初始化一个stack
    std::stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);

    std::cout << "Initial stack elements: ";
    while (!s.empty()) {
        std::cout << s.top() << " ";
        s.pop();
    }
    std::cout << "\n";

    // 添加元素
    s.push(5);
    std::cout << "After adding element 5: ";
    while (!s.empty()) {
        std::cout << s.top() << " ";
        s.pop();
    }
    std::cout << "\n";

    // 删除元素
    s.push(6);
    s.pop();
    std::cout << "After removing the top element: ";
    while (!s.empty()) {
        std::cout << s.top() << " ";
        s.pop();
    }
    std::cout << "\n";

    return 0;
}

双端队列(deque)

双端队列（deque）可以在两端进行插入和删除操作，是一种动态数组的扩展形式。

容器的初始化与基本操作

#include <deque>
#include <iostream>

int main() {
    // 初始化一个deque
    std::deque<int> dq;
    dq.push_back(1);
    dq.push_back(2);
    dq.push_back(3);
    dq.push_back(4);

    std::cout << "Initial deque elements: ";
    for (int i : dq) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 在两端添加元素
    dq.push_front(0);
    dq.push_back(5);
    std::cout << "After adding elements at both ends: ";
    for (int i : dq) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 删除两端的元素
    dq.pop_front();
    dq.pop_back();
    std::cout << "After removing elements from both ends: ";
    for (int i : dq) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 访问元素
    std::cout << "Element at index 2: " << dq[2] << "\n";

    // 修改元素
    dq[2] = 10;
    std::cout << "After modifying element at index 2: ";
    for (int i : dq) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 遍历容器
    std::cout << "Iterating through the deque: ";
    for (int i : dq) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    return 0;
}

集合(set)和多重集(multiset)

集合（set）是一种元素唯一且有序的数据结构，多重集（multiset）允许重复元素。

容器的初始化与基本操作

#include <set>
#include <iostream>

int main() {
    // 初始化一个set
    std::set<int> set;
    set.insert(1);
    set.insert(2);
    set.insert(3);
    set.insert(1); // Duplicate, ignored

    std::cout << "Initial set elements: ";
    for (int i : set) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 添加元素
    set.insert(4);
    std::cout << "After adding element 4: ";
    for (int i : set) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 删除元素
    set.erase(set.find(2));
    std::cout << "After removing element 2: ";
    for (int i : set) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 查询元素
    if (set.find(3) != set.end()) {
        std::cout << "Element 3 is in the set\n";
    }

    // 初始化一个multiset
    std::multiset<int> multiset;
    multiset.insert(1);
    multiset.insert(2);
    multiset.insert(3);
    multiset.insert(1); // Duplicate is allowed

    std::cout << "Initial multiset elements: ";
    for (int i : multiset) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 添加元素
    multiset.insert(4);
    std::cout << "After adding element 4: ";
    for (int i : multiset) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 删除元素
    multiset.erase(multiset.find(2));
    std::cout << "After removing element 2: ";
    for (int i : multiset) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    return 0;
}
容器的基本操作

容器的初始化

容器的初始化可以通过构造函数、赋值操作符、初始化列表等多种方式进行。

#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <iostream>

int main() {
    // 向量初始化
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 链表初始化
    std::list<int> lst = {1, 2, 3, 4, 5};

    // 队列初始化
    std::queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);

    // 堆栈初始化
    std::stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);

    // 集合初始化
    std::set<int> set = {1, 2, 3, 4, 5};

    // 多重集初始化
    std::multiset<int> multiset = {1, 2, 3, 4, 5};

    // 输出初始化的结果
    std::cout << "Vector: ";
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    std::cout << "List: ";
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    std::cout << "Queue: ";
    while (!q.empty()) {
        std::cout << q.front() << " ";
        q.pop();
    }
    std::cout << "\n";

    std::cout << "Stack: ";
    while (!s.empty()) {
        std::cout << s.top() << " ";
        s.pop();
    }
    std::cout << "\n";

    std::cout << "Set: ";
    for (int i : set) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    std::cout << "Multiset: ";
    for (int i : multiset) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    return 0;
}

元素的添加与删除

元素的添加和删除操作在STL容器中非常简单，可以通过成员函数来完成。

#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <iostream>

int main() {
    // 向量添加和删除元素
    std::vector<int> vec = {1, 2, 3, 4, 5};
    vec.push_back(6);
    vec.pop_back();
    std::cout << "Vector: ";
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 链表添加和删除元素
    std::list<int> lst = {1, 2, 3, 4, 5};
    lst.push_back(6);
    lst.pop_back();
    std::cout << "List: ";
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 队列添加和删除元素
    std::queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);
    q.pop();
    std::cout << "Queue: ";
    while (!q.empty()) {
        std::cout << q.front() << " ";
        q.pop();
    }
    std::cout << "\n";

    // 堆栈添加和删除元素
    std::stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);
    s.pop();
    std::cout << "Stack: ";
    while (!s.empty()) {
        std::cout << s.top() << " ";
        s.pop();
    }
    std::cout << "\n";

    // 集合添加和删除元素
    std::set<int> set = {1, 2, 3, 4, 5};
    set.insert(6);
    set.erase(set.find(2));
    std::cout << "Set: ";
    for (int i : set) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 多重集添加和删除元素
    std::multiset<int> multiset = {1, 2, 3, 4, 5};
    multiset.insert(6);
    multiset.erase(multiset.find(2));
    std::cout << "Multiset: ";
    for (int i : multiset) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    return 0;
}

元素的访问与修改

元素的访问和修改操作可以通过索引或迭代器来进行。

#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <iostream>

int main() {
    // 向量访问和修改元素
    std::vector<int> vec = {1, 2, 3, 4, 5};
    vec[2] = 10;
    std::cout << "Vector: ";
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 链表访问和修改元素
    std::list<int> lst = {1, 2, 3, 4, 5};
    lst.front() = 10;
    std::cout << "List: ";
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 队列访问和修改元素
    std::queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);
    std::cout << "Queue: ";
    while (!q.empty()) {
        std::cout << q.front() << " ";
        q.pop();
    }
    std::cout << "\n";

    // 堆栈访问和修改元素
    std::stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);
    std::cout << "Stack: ";
    while (!s.empty()) {
        std::cout << s.top() << " ";
        s.pop();
    }
    std::cout << "\n";

    // 集合访问和修改元素
    std::set<int> set = {1, 2, 3, 4, 5};
    set.erase(set.find(2));
    std::cout << "Set: ";
    for (int i : set) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 多重集访问和修改元素
    std::multiset<int> multiset = {1, 2, 3, 4, 5};
    multiset.erase(multiset.find(2));
    std::cout << "Multiset: ";
    for (int i : multiset) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    return 0;
}

容器的遍历与迭代

容器的遍历可以通过迭代器来进行，迭代器是一种类似于指针的对象，可以用来遍历容器中的元素。

#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <iostream>

int main() {
    // 向量遍历
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::cout << "Vector: ";
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 链表遍历
    std::list<int> lst = {1, 2, 3, 4, 5};
    std::cout << "List: ";
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 队列遍历
    std::queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);
    std::cout << "Queue: ";
    while (!q.empty()) {
        std::cout << q.front() << " ";
        q.pop();
    }
    std::cout << "\n";

    // 堆栈遍历
    std::stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);
    std::cout << "Stack: ";
    while (!s.empty()) {
        std::cout << s.top() << " ";
        s.pop();
    }
    std::cout << "\n";

    // 集合遍历
    std::set<int> set = {1, 2, 3, 4, 5};
    std::cout << "Set: ";
    for (int i : set) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 多重集遍历
    std::multiset<int> multiset = {1, 2, 3, 4, 5};
    std::cout << "Multiset: ";
    for (int i : multiset) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    return 0;
}
容器的比较与转换

不同容器之间的比较

容器的比较可以通过成员函数或标准库函数来进行。例如，可以比较两个集合是否相等，或者比较两个向量的大小。

#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <iostream>

int main() {
    // 向量比较
    std::vector<int> vec1 = {1, 2, 3, 4, 5};
    std::vector<int> vec2 = {1, 2, 3, 4, 5};
    bool vecEqual = vec1 == vec2;
    std::cout << "Vector equal: " << vecEqual << "\n";

    // 链表比较
    std::list<int> lst1 = {1, 2, 3, 4, 5};
    std::list<int> lst2 = {1, 2, 3, 4, 5};
    bool lstEqual = lst1 == lst2;
    std::cout << "List equal: " << lstEqual << "\n";

    // 集合比较
    std::set<int> set1 = {1, 2, 3, 4, 5};
    std::set<int> set2 = {1, 2, 3, 4, 5};
    bool setEqual = set1 == set2;
    std::cout << "Set equal: " << setEqual << "\n";

    // 多重集比较
    std::multiset<int> multiset1 = {1, 2, 3, 4, 5};
    std::multiset<int> multiset2 = {1, 2, 3, 4, 5};
    bool multisetEqual = multiset1 == multiset2;
    std::cout << "Multiset equal: " << multisetEqual << "\n";

    return 0;
}

容器之间的转换

容器之间的转换可以通过构造函数、赋值操作符等方式进行。例如，可以将一个向量转换为一个链表，或将一个链表转换为一个向量。

#include <vector>
#include <list>
#include <iostream>

int main() {
    // 向量转换为链表
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::list<int> lst(vec.begin(), vec.end());
    std::cout << "List from vector: ";
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 链表转换为向量
    std::list<int> lst = {1, 2, 3, 4, 5};
    std::vector<int> vec(lst.begin(), lst.end());
    std::cout << "Vector from list: ";
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    return 0;
}

容器的排序与查找

容器的排序和查找可以通过标准库函数来进行。例如，可以使用sort函数对向量进行排序，或使用find函数在集合中查找元素。

#include <vector>
#include <list>
#include <set>
#include <algorithm>
#include <iostream>

int main() {
    // 向量排序
    std::vector<int> vec = {4, 3, 5, 1, 2};
    std::sort(vec.begin(), vec.end());
    std::cout << "Sorted vector: ";
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 集合查找
    std::set<int> set = {1, 2, 3, 4, 5};
    bool found = set.find(3) != set.end();
    std::cout << "Element 3 found in set: " << found << "\n";

    return 0;
}
容器的深入使用

容器的自定义数据类型

容器可以存储自定义的数据类型。自定义数据类型需要实现<运算符，以便在容器中使用比较功能。

#include <vector>
#include <iostream>

struct CustomType {
    int value;

    CustomType(int val) : value(val) {}

    bool operator<(const CustomType& other) const {
        return value < other.value;
    }
};

int main() {
    std::vector<CustomType> vec;
    vec.push_back(CustomType(1));
    vec.push_back(CustomType(3));
    vec.push_back(CustomType(2));

    std::sort(vec.begin(), vec.end());

    std::cout << "Sorted custom type vector: ";
    for (const auto& item : vec) {
        std::cout << item.value << " ";
    }
    std::cout << "\n";

    return 0;
}

容器的嵌套使用

容器可以嵌套使用，例如，一个向量中可以包含多个链表，或者一个链表中可以包含多个向量。

#include <vector>
#include <list>
#include <iostream>

int main() {
    // 向量嵌套链表
    std::vector<std::list<int>> vecOfLists;
    std::list<int> lst1 = {1, 2, 3};
    std::list<int> lst2 = {4, 5, 6};
    vecOfLists.push_back(lst1);
    vecOfLists.push_back(lst2);

    std::cout << "Vector of lists: ";
    for (const auto& lst : vecOfLists) {
        for (int i : lst) {
            std::cout << i << " ";
        }
        std::cout << "\n";
    }

    // 链表嵌套向量
    std::list<std::vector<int>> lstOfVectors;
    std::vector<int> vec1 = {1, 2, 3};
    std::vector<int> vec2 = {4, 5, 6};
    lstOfVectors.push_back(vec1);
    lstOfVectors.push_back(vec2);

    std::cout << "List of vectors: ";
    for (const auto& vec : lstOfVectors) {
        for (int i : vec) {
            std::cout << i << " ";
        }
        std::cout << "\n";
    }

    return 0;
}

容器的内存管理

容器的内存管理是自动进行的，通常不需要手动管理内存。容器会自动分配和释放内存，以适应数据的变化。然而，对于较大的数据集，可以考虑使用reserve函数来优化内存分配。

#include <vector>
#include <iostream>

int main() {
    // 预留内存
    std::vector<int> vec;
    vec.reserve(1000);
    for (int i = 0; i < 1000; ++i) {
        vec.push_back(i);
    }

    // 手动释放内存
    vec.clear(); // 清空容器
    vec.shrink_to_fit(); // 收缩内存分配

    return 0;
}
实战演练

通过实际案例学习STL容器的使用

假设我们需要实现一个简单的任务队列，可以添加任务、移除任务并执行任务。我们可以使用队列来实现这个功能。

#include <iostream>
#include <queue>
#include <string>

void executeTask(const std::string& task) {
    std::cout << "Executing task: " << task << "\n";
}

int main() {
    std::queue<std::string> taskQueue;

    // 添加任务
    taskQueue.push("Task 1");
    taskQueue.push("Task 2");
    taskQueue.push("Task 3");

    // 执行任务
    while (!taskQueue.empty()) {
        std::string task = taskQueue.front();
        taskQueue.pop();
        executeTask(task);
    }

    return 0;
}

常见错误和解决方法

在使用STL容器时，常见的错误包括：

  • 不正确地使用迭代器。
  • 未初始化容器。
  • 未检查容器是否为空。

例如，以下代码尝试访问一个空队列的front元素，会导致未定义行为。

#include <queue>
#include <iostream>

int main() {
    std::queue<int> q;
    if (!q.empty()) {
        std::cout << q.front();
    } else {
        std::cout << "Queue is empty\n";
    }
    return 0;
}

容器性能分析

不同类型的容器在不同的操作上有不同的性能表现。例如，向量的访问和插入是在随机位置，而在末尾插入和删除是O(1)，但在中间插入和删除是O(n)，而链表的插入和删除操作在任意位置都是O(1)，但访问操作是O(n)。

为了更好地理解和优化容器的性能，可以使用工具如Valgrind或gprof来分析代码的性能。


#include <vector>
#include <list>
#include <iostream>
#include <chrono>

void measureTime(std::vector<int>& vec, int n) {
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < n; ++i) {
        vec.push_back(i);
    }
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> duration = end - start;
    std::cout << "Vector time: " << duration.count() << "ms\n";
}

void measureTime(std::list<int>& lst, int n) {
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < n; ++i) {
        lst.push_back(i);
    }
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> duration = end - start;
    std::cout << "List time: " << duration.count() << "ms\n";
}

int main() {
    int n = 1000000;
    std::vector<int> vec;
    std::list<int> lst;

    measureTime(vec, n);
    measureTime(lst, n);

    return 0;
}
``

通过上述代码，我们可以分析向量和链表在大量元素插入时的性能差异。

## 总结
STL容器是C++中非常强大的工具，它们提供了丰富的功能和高效率的操作。通过详细学习STL容器的基本操作和高级用法，可以大大提高开发效率和代码质量。希望本文的介绍对您有所帮助，如果需要进一步了解STL容器，可以参考官方文档或慕课网的相关课程。
点击查看更多内容
发表于 2024.10.25 19:05， 共 106 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

慕少森

手记
篇
粉丝
42
获赞与收藏
216

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消