C++ STL

• STL
• 容器
  • 支持泛型

STL

STL（Standard Template Library）是C++标准库的一部分，提供了许多常用的数据结构和算法。STL主要包括以下几个部分：

容器（Containers）：

序列容器：vector, list, deque

关联容器：set, map, multiset, multimap

无序关联容器：unordered_set, unordered_map, unordered_multiset, unordered_multimap

容器适配器：stack, queue, priority_queue

迭代器（Iterators）：

输入迭代器、输出迭代器、前向迭代器、双向迭代器、随机访问迭代器

算法（Algorithms）：

非修改性序列操作：find, for_each
修改性序列操作：copy, transform
排序和相关操作：sort, binary_search
数值操作：accumulate, inner_product

函数对象（Function Objects）：

算术运算：plus, minus
比较运算：equal_to, less
逻辑运算：logical_and, logical_or

分配器（Allocators）：

用于管理内存分配和释放

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 定义一个比较类，用于自定义排序规则
class Compare {
public:
    // 重载()运算符，定义比较规则
    bool operator()(int i, int j) {
        return i > j; // 返回i是否大于j
    }
};

// 定义一个比较类，用于自定义条件判断
class MyCompare {
public:
    // 重载()运算符，定义条件判断规则
    bool operator()(int & v) {
        return v > 5; // 返回v是否大于5
    }
};

int main() {
    // 定义一个数组
    int arr[] = {6, 0, 7, 1, 5};

    // 定义一个vector，使用默认的allocator
    vector<int, allocator<int>> vi;

    // 将数组的内容赋值给vector
    vi.assign(arr, arr + 5);

    // 定义一个迭代器
    vector<int, allocator<int>>::iterator itr;

    // 使用自定义的Compare类进行排序
    sort(vi.begin(), vi.end(), Compare());

    // 遍历并输出排序后的vector
    for (itr = vi.begin(); itr != vi.end(); ++itr) {
        cout << *itr << endl;
    }

    // 使用自定义的MyCompare类统计大于5的元素个数
    int count = count_if(vi.begin(), vi.end(), MyCompare());
    cout << "大于5的个数: " << count << endl;  // 输出2

    // 使用bind和greater函数对象统计大于5的元素个数
    int count2 = count_if(vi.begin(), vi.end(), bind(greater<int>(), std::placeholders::_1, 5));
    cout << "大于5的个数: " << count2 << endl;  // 输出2
}

高可重用性：

STL 中几乎所有的代码都采用了模板类和模版函数的方式实现，这相比于传统的由
函数和类组成的库来说提供了更好的代码重用机会。

高性能：

如 map 可以高效地从十万条记录里面查找出指定的记录，因为 map 是采用红黑树的变体实现的。 (红黑树是平横二叉树的一种)

高移植性：

如在项目 A 上用 STL 编写的模块，可以直接移植到项目 B 上。

跨平台：

如用 windows 的 Visual Studio 编写的代码可以在 Mac OS 的 XCode 上直接编译

容器

支持泛型

    vector<int> vi;
    vector<double> vd;
    vector<string> vs;
    list<int> li;
    list<double> ld;
    list<string> ls;
    map<int,string> mis;
    map<string,int> msi;

STL容器优劣对比：
---------------------------------------------------------------------------------
| 容器类型          | 优点                                           | 缺点                                           | 适用场景                               |
|-------------------|------------------------------------------------|------------------------------------------------|----------------------------------------|
| `std::vector`     | 1. 随机访问速度快，O(1)                         | 1. 在中间插入/删除元素慢，O(n)                 | 1. 需要频繁随机访问元素的场景          |
|                   | 2. 在末尾插入/删除元素快，O(1)（平均情况）      | 2. 内存分配可能不连续，导致缓存不友好          | 2. 元素数量变化不大的场景              |
| `std::list`       | 1. 在任意位置插入/删除元素快，O(1)              | 1. 随机访问慢，O(n)                            | 1. 需要频繁在中间插入/删除元素的场景   |
|                   | 2. 内存分配连续，缓存友好                       | 2. 存储开销大，每个元素需要额外存储指针        |                                        |
| `std::deque`      | 1. 随机访问速度快，O(1)                         | 1. 在中间插入/删除元素慢，O(n)                 | 1. 需要频繁在两端插入/删除元素的场景   |
|                   | 2. 在两端插入/删除元素快，O(1)                  | 2. 内存分配可能不连续，导致缓存不友好          |                                        |
| `std::set`        | 1. 元素唯一，自动排序                           | 1. 插入/删除/查找元素慢，O(log n)              | 1. 需要元素唯一且有序的场景            |
|                   | 2. 红黑树实现，平衡性好                        | 2. 存储开销大，每个元素需要额外存储指针        |                                        |
| `std::map`        | 1. 键值对存储，键唯一，自动排序                 | 1. 插入/删除/查找元素慢，O(log n)              | 1. 需要键值对存储且键有序的场景        |
|                   | 2. 红黑树实现，平衡性好                        | 2. 存储开销大，每个元素需要额外存储指针        |                                        |
| `std::unordered_set` | 1. 元素唯一，无序                              | 1. 插入/删除/查找元素慢，O(1)（平均情况）      | 1. 需要元素唯一且无序的场景            |
|                   | 2. 哈希表实现，插入/删除/查找快                | 2. 哈希冲突可能导致性能下降                    |                                        |
| `std::unordered_map` | 1. 键值对存储，键唯一，无序                    | 1. 插入/删除/查找元素慢，O(1)（平均情况）      | 1. 需要键值对存储且键无序的场景        |
|                   | 2. 哈希表实现，插入/删除/查找快                | 2. 哈希冲突可能导致性能下降                    |                                        |
---------------------------------------------------------------------------------