C++ Linux编程中如何使用STL容器

在C++ Linux编程中，STL（Standard Template Library）容器是一种非常强大的工具，它提供了许多预定义的数据结构和算法，可以帮助我们更高效地处理数据。以下是一些常用的STL容器及其使用方法：

1. 向量（std::vector）

向量是一个动态数组，可以自动调整大小。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 访问元素
    std::cout << vec[0] << std::endl; // 输出 1

    // 添加元素
    vec.push_back(6);

    // 遍历元素
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

2. 列表（std::list）

列表是一个双向链表，支持高效的插入和删除操作。

#include <iostream>
#include <list>

int main() {
    std::list<int> lst = {1, 2, 3, 4, 5};

    // 添加元素到头部
    lst.push_front(0);

    // 遍历元素
    for (int num : lst) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 删除元素
    lst.remove(3);

    return 0;
}

3. 集合（std::set）

集合是一个有序的容器，不允许重复元素。

#include <iostream>
#include <set>

int main() {
    std::set<int> st = {3, 1, 4, 1, 5, 9};

    // 插入元素
    st.insert(2);

    // 遍历元素
    for (int num : st) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 查找元素
    if (st.find(4) != st.end()) {
        std::cout << "Element found" << std::endl;
    }

    return 0;
}

4. 映射（std::map）

映射是一个键值对的容器，键是唯一的。

#include <iostream>
#include <map>

int main() {
    std::map<std::string, int> mp = {{"apple", 5}, {"banana", 3}, {"cherry", 7}};

    // 插入元素
    mp["orange"] = 2;

    // 遍历元素
    for (const auto& pair : mp) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 查找元素
    if (mp.find("banana") != mp.end()) {
        std::cout << "Element found" << std::endl;
    }

    return 0;
}

5. 队列（std::queue）

队列是一个先进先出（FIFO）的数据结构。

#include <iostream>
#include <queue>

int main() {
    std::queue<int> q;

    // 添加元素
    q.push(1);
    q.push(2);
    q.push(3);

    // 访问队首元素
    std::cout << "Front element: " << q.front() << std::endl; // 输出 1

    // 删除队首元素
    q.pop();

    // 遍历元素
    while (!q.empty()) {
        std::cout << q.front() << " ";
        q.pop();
    }
    std::cout << std::endl;

    return 0;
}

6. 栈（std::stack）

栈是一个后进先出（LIFO）的数据结构。

#include <iostream>
#include <stack>

int main() {
    std::stack<int> s;

    // 添加元素
    s.push(1);
    s.push(2);
    s.push(3);

    // 访问栈顶元素
    std::cout << "Top element: " << s.top() << std::endl; // 输出 3

    // 删除栈顶元素
    s.pop();

    // 遍历元素
    while (!s.empty()) {
        std::cout << s.top() << " ";
        s.pop();
    }
    std::cout << std::endl;

    return 0;
}

7. 双端队列（std::deque）

双端队列是一个双端队列，支持在两端高效地插入和删除元素。

#include <iostream>
#include <deque>

int main() {
    std::deque<int> dq = {1, 2, 3, 4, 5};

    // 在头部添加元素
    dq.push_front(0);

    // 在尾部添加元素
    dq.push_back(6);

    // 遍历元素
    for (int num : dq) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 删除头部元素
    dq.pop_front();

    // 删除尾部元素
    dq.pop_back();

    return 0;
}

总结

STL容器提供了丰富的数据结构和算法，可以大大简化编程任务。在使用这些容器时，需要注意它们的性能特性和适用场景。例如，std::vector适用于需要快速随机访问的场景，而std::list适用于频繁插入和删除的场景。通过合理选择和使用STL容器，可以提高代码的效率和可读性。