掌握STL容器基本技巧：从入门到精通的C++指南-原创手记-慕课网

从零开始的STL容器之旅

快速上手C++的现代化工具

在这个高速发展的编程领域，C++不仅保留了其强大的特性，更是在标准库（STL）的加持下，提供了高效、现代的工具供开发者使用。作为C++程序员，理解并熟练运用STL容器是实现高效、可维护代码的关键一步。

强大容器，灵活应变

vector：动态数组的灵活应用，让你在数组大小变化时轻松应对。
list：双链表的高效数据结构，特别适合需要频繁进行插入和删除操作的场景。
deque：双端队列，为两端提供高效的数据增删操作，是处理多方向数据流的理想选择。
stack与queue：基于容器的栈和队列实现，简化了数据处理和任务调度过程。
array：固定大小数组的优化版本，适合预知大小且无需动态调整的数据集。

掌握基础操作，驾驭复杂任务

容器初始化与元素操作：定义容器，插入、删除元素，理解和运用容器提供的高效API。
容器遍历与分析：使用迭代器遍历容器，查找元素，执行复杂操作。
元素排序与查找：高效地对数据进行排序，快速定位特定元素。

选择与优化：最适合的容器

性能考量：理解不同容器的性能特点，根据具体场景选择最合适的容器。
容器间比较：分析容器的优缺点，权衡适用情况。
动态与静态选择：何时使用动态数组，何时选择链表，理解容器的使用场景。

高级特性与实践应用

容器管理技巧：掌握reserve、capacity、resize、clear等方法的正确使用，优化内存分配与管理。
迭代器的魔法：深入理解begin与end迭代器，灵活运用它们进行复杂的遍历与修改操作。

实战演练：从理论到实际

通过具体的编程案例，我们将深入实践，学习如何在实际项目中灵活运用STL容器，解决日常编程中的各种挑战，从理论走向实际应用，成为C++领域的专家。

掌握基本技巧：STL容器轻松入门指南

概述与STL容器简介

在现代C++编程中，STL（Standard Template Library）是一个关键的组成部分，它提供了一组高效的泛型算法和容器。STL容器不仅封装了数据结构，还提供了丰富的功能以实现高效的数据管理。这些容器是执行复杂操作的基础，如排序、搜索、迭代和操作集合，它们在提高代码可读性、减少错误和提升性能方面发挥了重要作用。

核心STL容器详解

`vector`：动态数组的使用与操作

vector是STL中最常用的容器之一，它提供了一个类似数组的接口，但能够动态改变大小。vector支持随机访问，并且在插入或删除元素时，如果容器大小不匹配，会自动进行内存的申请和释放。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);

    for (int i = 0; i < v.size(); ++i) {
        std::cout << v[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}

`list`：双链表的基本概念与应用

list是一个双向链表容器，它支持高效的迭代和在链表任何位置的插入与删除操作。由于链表的结构，list在这些操作上通常比动态数组快，但随机访问速度较慢。

#include <list>
#include <iostream>

int main() {
    std::list<int> l;
    l.push_back(10);
    l.push_back(20);
    l.push_back(30);

    for (std::list<int>::iterator it = l.begin(); it != l.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    return 0;
}

`deque`：双端队列的特性与优势

deque（双端队列）允许在两端进行快速插入和删除操作，它的内部实现通常基于数组或动态数组，使得两端操作的效率较高，而中间位置的操作效率低于vector。

#include <deque>
#include <iostream>

int main() {
    std::deque<int> d;
    d.push_front(10);
    d.push_back(20);
    d.push_front(30);

    for (std::deque<int>::iterator it = d.begin(); it != d.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    return 0;
}

`stack`：基于容器的栈实现

虽然stack没有直接提供给用户，但可以通过vector或deque实现栈的功能，通过push和pop操作来模拟栈的行为。stack在调用push后会检查栈是否已满，而pop则检查栈是否为空。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> s;
    s.push_back(10);
    s.push_back(20);
    s.push_back(30);

    while (!s.empty()) {
        std::cout << s.back() << " ";
        s.pop_back();
    }
    std::cout << std::endl;
    return 0;
}

`queue`：基于容器的队列实现

同样，queue也没有直接提供给用户实现，可以通过vector、list或deque来实现队列功能。使用enqueue和dequeue操作分别为队列的两端进行元素的添加和删除。

#include <queue>
#include <iostream>

int main() {
    std::queue<int> q;
    q.push(10);
    q.push(20);
    q.push(30);

    while (!q.empty()) {
        std::cout << q.front() << " ";
        q.pop();
    }
    std::cout << std::endl;
    return 0;
}

`array`：固定大小数组的使用

array类似于C语言中的数组，它提供了一种更安全、更高效的方式来处理固定大小的数据集，但不会自动扩展或收缩。

#include <array>
#include <iostream>

int main() {
    std::array<int, 3> a = {{10, 20, 30}};
    for (int i : a) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

容器的基本操作

初始化容器

容器的初始化可以通过构造函数或emplace函数完成。emplace函数可以更直接地插入已构建的值，相比于先构造一个对象再插入，通常更高效。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {10, 20, 30};
    std::vector<int> v2 = {40, 50, 60};
    std::vector<int> v3 = {70, 80, 90};

    std::vector<std::vector<int>> vv = {v, v2, v3};

    for (const auto &vec : vv) {
        for (int i : vec) {
            std::cout << i << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

读取与写入元素

容器支持迭代器进行元素的读取与写入。begin返回指向容器第一个元素的迭代器，end则返回一个指向容器最后一个元素之后位置的迭代器。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {10, 20, 30};
    for (auto it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    v.push_back(40);
    for (auto it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    return 0;
}

容器遍历

通过迭代器，可以遍历容器中的所有元素。这不仅限于打印元素，还可以进行更复杂的操作。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {10, 20, 30};
    for (int i : v) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    for (auto it = v.begin(); it != v.end(); ++it) {
        *it = 2 * *it;
    }
    for (int i : v) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

容器元素排序与查找

sort函数可以对容器进行排序，而std::find函数可以搜索特定元素是否存在。

#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> v = {30, 20, 10};
    std::sort(v.begin(), v.end());
    for (int i : v) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    if (std::find(v.begin(), v.end(), 20) != v.end()) {
        std::cout << "Found 20" << std::endl;
    } else {
        std::cout << "Not found" << std::endl;
    }
    return 0;
}

容器的特性与比较

在选择容器时，需要考虑操作的常见情况、数据访问模式、容器的性能和内存使用情况。例如，对于频繁的插入和删除操作，list或deque可能是更优选择；对于随机访问和排序操作，vector通常更为合适。

STL容器的高级特性

`reserve`与`capacity`

reserve用于预先分配容器的内存，确保在后续的插入操作中不会频繁触发内存重分配。capacity则返回当前容器可以容纳的最大元素数。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v;
    v.reserve(100); // Reserve memory for 100 elements
    for (int i = 0; i < 100; ++i) {
        v.push_back(i);
    }
    std::cout << "Capacity: " << v.capacity() << std::endl;
    return 0;
}

`resize`与`clear`方法的应用场景

resize可以调整容器的大小，如果需要的大小大于当前大小，它将自动填充新元素；如果小于当前大小，它将删除多余的元素。clear则用于移除容器中的所有元素。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {10, 20, 30};
    v.resize(5, 0); // Resize to 5 elements, fill with 0s
    v.clear(); // Remove all elements
    return 0;
}

实践案例：使用STL容器解决实际问题

假设我们需要实现一个简单的日志系统，记录系统操作并能快速搜索特定事件。

#include <iostream>
#include <vector>
#include <string>
#include <limits>
#include <cassert>

struct LogEntry {
    std::string description;
    int timestamp;
};

class LogSystem {
public:
    LogSystem() {}
    ~LogSystem() {}

    void log(const std::string& desc, int ts) {
        entries.push_back({desc, ts});
    }

    bool search(const std::string& keyword) {
        for (const auto& entry : entries) {
            if (entry.description.find(keyword) != std::string::npos) {
                return true;
            }
        }
        return false;
    }

private:
    std::vector<LogEntry> entries;
};

int main() {
    LogSystem ls;
    ls.log("Starting the system", 1627380000);
    ls.log("Error in module A", 1627380050);
    ls.log("Saving user data", 1627380100);
    ls.log("Error in module B", 1627380150);

    assert(ls.search("Error") == true);
    assert(ls.search("unknown") == false);
    return 0;
}

通过这些案例，我们不仅学习了如何使用STL容器，还理解了它们在实际编程场景中的应用。掌握STL容器的基本技巧和高级特性，将使你的C++程序更加高效和灵活。