C++ STL入门：解锁现代C++编程的强大工具箱

2024-03-15 17:38:07
开发
17

引言

STL基础

容器

引言

在现代C++编程中，标准模板库（Standard Template Library，STL）是不可或缺的一部分，它提供了一系列广泛使用的数据结构和算法。对于有其他编程背景但未接触过STL的程序员来说，掌握STL将大大提升编写高效、简洁和强大的C++代码的能力。本文将通过实例和简明的解释，引领读者步入STL的世界。

STL基础

STL是C++的一个强大功能库，它支持泛型编程。STL中的每个组件都是模板化的，这意味着它们可以与任何数据类型一起工作，提供极高的灵活性和代码复用性。STL主要由以下几部分构成：

容器：存储数据的通用数据结构，如向量（vector）、列表（list）、映射（map）等。
迭代器：提供访问容器中元素的方法，类似于指针。
算法：对数据执行操作的函数模板，例如排序和搜索。
函数对象：行为类似函数的对象，可以作为算法的某些操作。
配接器：修改容器或函数对象接口的工具。

STL的设计目标是高效和可重用，使得程序员可以集中精力解决具体问题，而不是重新发明数据结构和算法。

容器

STL提供了一系列的容器，分为序列容器、关联容器和容器适配器三种，每种容器都支持不同的数据组织和存取方式。

序列容器

vector：向量是一个动态数组，支持随机访问。它可以在尾部快速插入或删除元素，但在中间或开始插入元素可能较慢。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4};
    vec.push_back(5); // 在末尾添加元素
    for(int i : vec) {
        std::cout << i << " ";
    }
    // 输出: 1 2 3 4 5
    return 0;
}

list：列表是一个双向链表，支持在任何位置快速插入和删除元素，但不支持随机访问。

#include <list>
#include <iostream>

int main() {
    std::list<int> lst = {1, 2, 3, 4};
    lst.push_front(0); // 在开头添加元素
    for(int i : lst) {
        std::cout << i << " ";
    }
    // 输出: 0 1 2 3 4
    return 0;
}

deque：双端队列，结合了向量和列表的优点，可以在两端快速插入和删除元素，同时提供随机访问。

#include <deque>
#include <iostream>

int main() {
    std::deque<int> deq = {2, 3, 4};
    deq.push_front(1); // 在前端添加元素
    deq.push_back(5);  // 在后端添加元素
    for(int i : deq) {
        std::cout << i << " ";
    }
    // 输出: 1 2 3 4 5
    return 0;
}

关联容器

set：集合是一个存储唯一元素的容器，内部自动根据元素的值进行排序。

#include <set>
#include <iostream>

int main() {
    std::set<int> s = {3, 1, 4, 1, 2};
    s.insert(5); // 尝试添加元素
    for(int i : s) {
        std::cout << i << " ";
    }
    // 输出: 1 2 3 4 5
    return 0;
}

map：映射是一种关联数组，存储键值对，其中每个键都是唯一的，内部根据键自动排序。

#include <map>
#include <iostream>

int main() {
    std::map<char, int> m;
    m['a'] = 1;
    m['b'] = 2;
    m['c'] = 3;
    for(auto& pair : m) {
        std::cout << pair.first << ": " << pair.second << "\n";
    }
    // 输出: a: 1 b: 2 c: 3
    return 0;
}

容器适配器

stack：栈提供了限制在一端插入和删除元素的LIFO（后进先出）数据结构。

#include <stack>
#include <iostream>

int main() {
    std::stack<int> stack;
    stack.push(1);
    stack.push(2);
    stack.push(3);
    while (!stack.empty()) {
        std::cout << stack.top() << " ";
        stack.pop();
    }
    // 输出: 3 2 1
    return 0;
}

queue：队列提供了限制在一端插入而在另一端删除元素的FIFO（先进先出）数据结构。

#include <queue>
#include <iostream>

int main() {
    std::queue<int> queue;
    queue.push(1);
    queue.push(2);
    queue.push(3);
    while (!queue.empty()) {
        std::cout << queue.front() << " ";
        queue.pop();
    }
    // 输出: 1 2 3
    return 0;
}

容器是STL中最基本的组成部分，为数据的存储和访问提供了强大支持。

算法

STL的算法库提供了一系列广泛使用的算法，如排序、搜索、变换和计算操作。这些算法通常作用于容器，通过迭代器与容器解耦，使得相同的算法可以应用于不同类型的容器。

排序和搜索

sort：std::sort函数可以对容器中的元素进行排序。它需要两个迭代器作为参数，指定要排序的元素的范围。

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

int main() {
    std::vector<int> v = {4, 2, 5, 1, 3};
    std::sort(v.begin(), v.end());
    for (int i : v) {
        std::cout << i << " ";
    }
    // 输出: 1 2 3 4 5
    return 0;
}

find：std::find函数用于搜索容器中的元素，返回一个指向找到的元素的迭代器，如果未找到，则返回指向容器末尾的迭代器。

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

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    auto it = std::find(v.begin(), v.end(), 3);
    if (it != v.end()) {
        std::cout << "Found " << *it << std::endl;
    } else {
        std::cout << "Not found" << std::endl;
    }
    // 输出: Found 3
    return 0;
}

变换和操作

transform：std::transform函数可以将指定操作应用于容器中的每个元素，并将结果存储在另一个容器中。

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

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::vector<int> v2(v.size());
    std::transform(v.begin(), v.end(), v2.begin(), [](int val) { return val * val; });
    for (int i : v2) {
        std::cout << i << " ";
    }
    // 输出: 1 4 9 16 25
    return 0;
}

accumulate：std::accumulate函数用于计算容器中元素的总和，位于<numeric>头文件中。

#include <numeric>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    int sum = std::accumulate(v.begin(), v.end(), 0);
    std::cout << "Sum: " << sum << std::endl;
    // 输出: Sum: 15
    return 0;
}

STL算法的优势在于它们的通用性和效率。通过将操作抽象化，算法可以应用于几乎所有容器类型，而无需关心容器的具体实现细节。下一节将介绍迭代器，它是容器和算法之间沟通的桥梁。

迭代器

迭代器是访问容器中元素的对象，它提供了一种方法来顺序访问容器中的元素，而不需要了解容器的内部结构。迭代器是STL中的核心概念之一，连接了容器与算法。

迭代器的分类

输入迭代器：只能读取序列中的元素一次，不能写入。
输出迭代器：只能写入序列中的元素一次，不能读取。
前向迭代器：可以多次读写同一个元素，并且能向前移动到下一个元素。
双向迭代器：除了具有前向迭代器的所有功能外，还可以向后移动。
随机访问迭代器：可以直接访问任何元素，支持迭代器之间的算术运算。

示例：使用迭代器遍历vector

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    // 输出: 1 2 3 4 5
    return 0;
}

通过使用迭代器，算法可以在不知道容器具体实现细节的情况下，操作容器中的数据。这种解耦使得STL具有极高的灵活性和复用性。

实战示例

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

int main() {
    // 创建一个vector容器存储整数
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用算法transform将每个数字平方
    std::transform(numbers.begin(), numbers.end(), numbers.begin(), [](int x) { return x * x; });

    // 使用算法accumulate计算平方后的总和
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0);

    // 打印结果
    std::cout << "Sum of squares: " << sum << std::endl;
    // 输出: Sum of squares: 55

    return 0;
}

结语

学习使用STL可以更加轻松地处理复杂的数据结构和算法问题。本文旨在针对有编程基础但未接触过STL的程序员快速入门，开启在C++领域的探索之旅。

原文地址:https://blog.csdn.net/m0_63629756/article/details/136723063 本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：https://www.suanlizi.com/kf/1768572374317404160.html 如若内容造成侵权/违法违规/事实不符，请联系《酸梨子》网邮箱：1419361763@qq.com进行投诉反馈，一经查实，立即删除！

阅读全部