STL的六大组件

一.总体概念

STL（Standard Template Library，标准模板库）是C++标准库的一部分，提供了丰富且高效的数据结构和算法。STL主要由六大组件组成，它们是：

容器（Containers）：STL提供了多种不同类型的容器，如vector、list、deque、set、map等，用于存储和管理数据。这些容器提供了不同的特性和性能，可以根据具体需求选择合适的容器。
算法（Algorithms）：STL包含了大量的算法，如排序、查找、遍历等，可以在不同的容器上进行操作。这些算法具有高度的重用性和通用性，帮助开发者快速实现各种常见的操作。
迭代器（Iterators）：迭代器是STL中用于遍历容器元素的工具，提供了统一的访问接口，使得算法可以以通用的方式操作各种容器。迭代器分为输入迭代器、输出迭代器、正向迭代器、双向迭代器和随机访问迭代器等不同类型。
仿函数（Functors）：仿函数是STL中的一个重要概念，它允许将函数对象作为参数传递给算法，从而实现更加灵活和通用的操作。STL提供了一些内置的仿函数，同时也支持用户自定义的仿函数。
适配器（Adapters）：适配器可以在已有的容器或算法之间提供一个接口层，以实现不同组件之间的互操作。常见的适配器有stack、queue和priority_queue等，它们提供了不同的数据结构和访问方式。
分配器（Allocators）：分配器是STL中用于内存管理的组件，负责为容器分配和释放内存。STL中的容器在实现时通常使用分配器进行内存分配，不同的分配器可以满足不同的内存分配策略和需求。

这些组件共同构成了STL的核心部分，为C++程序提供了强大、高效且通用的数据结构和算法支持。使用STL可以提高代码的可读性、可维护性和性能，并加速开发过程。

在这里插入图片描述

二.详细分析

1.容器

multimap和multiset介绍

Multimap和Multiset都是关联容器，允许存储多个相同键值的元素，但它们之间存在一些区别。

Multimap（多映射）：

Multimap是一个有序容器，它使用红黑树（Red-Black Tree）作为底层实现，元素按键值自动排序。
允许存储多个相同键值的元素，可以通过键值快速查找对应的元素。
插入新元素时，并不会覆盖掉已存在的相同键值元素，而是将新元素插入到相同键值元素的后面。
提供了插入、删除、查找等操作，时间复杂度为O(log n)。
示例：

#include <iostream>
#include <map>int main() {std::multimap<int, std::string> myMultimap;myMultimap.insert(std::make_pair(1, "apple"));myMultimap.insert(std::make_pair(2, "banana"));myMultimap.insert(std::make_pair(1, "avocado"));for (const auto& pair : myMultimap) {std::cout << pair.first << ": " << pair.second << std::endl;}return 0;
}

输出：

1: apple
1: avocado
2: banana

Multiset（多集合）：

Multiset是一种有序容器，允许存储多个相同的元素，并且会保持元素插入的顺序。在Multiset中，相同的元素会被当作不同的元素存储，即允许存在多个相同的元素。

因此，Multiset允许存储多个相同的元素，并且会按照插入的顺序保持这些元素，但不会有重复的元素。

Multiset也是一个有序容器，底层同样使用红黑树进行实现，但存储的是无重复的元素集合。
允许存储多个相同的元素，插入时会保持元素的顺序，但不会有重复的元素。
提供了插入、删除、查找等操作，时间复杂度为O(log n)。
示例：

#include <iostream>
#include <set>int main() {std::multiset<int> myMultiset;myMultiset.insert(1);myMultiset.insert(2);myMultiset.insert(1);for (const auto& value : myMultiset) {std::cout << value << std::endl;}return 0;
}

输出：

1
1
2

总结：Multimap和Multiset在STL中提供了方便的操作多个相同键值的元素和无重复元素集合的功能，适用于需要按照特定顺序存储、查找和操作元素的情况。通过了解它们的区别和特性，可以更好地选择适合的容器来满足编程需求。

2. 算法

merge函数介绍

merge是STL中的一个算法，用于将两个已排好序的序列合并成一个有序序列。该算法会合并两个序列，并将结果存储在目标序列中。以下是merge算法的详细介绍：

函数签名：

template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator merge(InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, InputIterator2 last2,OutputIterator result);

参数：
first1, last1: 第一个有序序列的起始和结束迭代器。
first2, last2: 第二个有序序列的起始和结束迭代器。
result: 目标序列的起始迭代器，用于存储合并后的有序序列。
返回值：
返回一个迭代器，指向合并后的有序序列最后一个元素之后的位置。
功能：
merge算法将两个已排好序的序列进行合并，并将结果存储在目标序列中。
合并后的序列仍然是有序的。

使用示例：

#include <iostream>
#include <algorithm>
#include <vector>int main() {std::vector<int> v1 = {1, 3, 5, 7};std::vector<int> v2 = {2, 4, 6, 8};std::vector<int> result(v1.size() + v2.size());std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), result.begin());for (const auto& num : result) {std::cout << num << " ";}return 0;
}

输出：

1 2 3 4 5 6 7 8

在上面的示例中，我们使用merge算法将两个已排好序的向量v1和v2合并到result中，并输出合并后的有序序列。这样我们可以方便地将两个有序序列合并成一个有序序列。

3.迭代器

迭代器（Iterator）是C++中用来访问容器元素的一种抽象概念。它允许我们以统一的方式遍历各种不同类型的容器，如数组、向量、链表和映射等。下面是一个简单的示例，用于说明迭代器的基本用法：

#include <iostream>
#include <vector>int main() {std::vector<int> v = {1, 2, 3, 4, 5};// 使用迭代器遍历向量并打印元素std::cout << "Using iterator to traverse the vector: ";for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it) {std::cout << *it << " ";}std::cout << std::endl;return 0;
}

在上面的例子中，我们创建了一个整数向量v并使用迭代器it来遍历它。现在让我解释一下代码中迭代器的用法和相关概念：

v.begin()返回指向向量起始元素的迭代器。
v.end()返回指向向量末尾下一个位置的迭代器。
it是一个迭代器，它初始化为v.begin()，逐步向前遍历直到v.end()，在每一步中，使用*it来获取迭代器当前所在位置的元素值。

上述代码中，我们使用了模板类std::vector的迭代器std::vector::iterator来遍历整数向量v。需要注意的是，C++ 11引入了auto关键字，可以用它来自动推断迭代器的类型，让代码更加简洁：


#include <iostream>
#include <vector>int main() {std::vector<int> v = {1, 2, 3, 4, 5};// 使用 auto 关键字简化迭代器类型std::cout << "Using iterator to traverse the vector: ";for (auto it = v.begin(); it != v.end(); ++it) {std::cout << *it << " ";}std::cout << std::endl;return 0;
}

在这个简化的示例中，我们使用auto关键字自动推断迭代器的类型，并且不需要显式指定std::vector::iterator。

4. 适配器

在C++中，适配器（Adapter）是一种设计模式，用于将一个类的接口转换成另一个类的接口，以满足客户端的需求而不改变原有类的代码。在STL中，有一些适配器容器，可以对其他容器进行适配，提供不同的接口和功能。

下面是几种常见的适配器容器及其功能：

栈（stack）：

栈是一种后进先出（LIFO）的容器，只能在顶部进行插入和删除操作。
使用适配器std::stack可以创建一个栈，基于其他容器（默认是std::deque）实现。

#include <iostream>
#include <stack>int main() {std::stack<int> s;s.push(10);s.push(20);s.push(30);while (!s.empty()) {std::cout << s.top() << " ";s.pop();}std::cout << std::endl;return 0;
}

输出：30 20 10

队列（queue）：

队列是一种先进先出（FIFO）的容器，支持在队尾插入，在队头删除元素。
使用适配器std::queue可以创建一个队列，基于其他容器（默认是std::deque）实现。

#include <iostream>
#include <queue>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;
}

输出：10 20 30

优先队列（priority_queue）：

优先队列是一种具有优先级顺序的队列，每次取出的元素都是优先级最高的。
使用适配器std::priority_queue可以创建一个优先队列，默认情况下基于std::vector实现。

#include <iostream>
#include <queue>int main() {std::priority_queue<int> pq;pq.push(30);pq.push(10);pq.push(20);while (!pq.empty()) {std::cout << pq.top() << " ";pq.pop();}std::cout << std::endl;return 0;
}

输出：30 20 10

以上是几种常见的STL适配器容器以及它们的基本用法。适配器容器可以简化具体容器的操作，并提供了更高层次的功能和接口，方便在实际开发中使用。

5. 仿函数

在C++中，仿函数（function object）是一种类或结构体，可以像函数一样被调用。仿函数可以以类似函数调用的方式使用，将其对象当作函数来调用，这种方式在STL中被广泛应用。

仿函数的特点：

仿函数是一个类或结构体，重载了operator()函数。
仿函数可以带有状态，可以在构造函数中初始化，因此可以用于实现更复杂的逻辑。
仿函数可以作为参数传递给算法或者容器，以自定义比较、排序、筛选等操作。

下面是一个简单的示例，演示如何定义一个仿函数并使用它：

#include <iostream>
#include <algorithm>
#include <vector>// 定义一个仿函数 LessThan，用于比较两个整数的大小
class LessThan {
public:bool operator()(int a, int b) const {return a < b;}
};int main() {std::vector<int> nums = {5, 2, 8, 1, 6, 3};// 使用仿函数 LessThan 对 nums 中的元素进行排序std::sort(nums.begin(), nums.end(), LessThan());// 输出排序后的结果for (int num : nums) {std::cout << num << " ";}std::cout << std::endl;return 0;
}