【 c++ 常用容器分析】

1. 序列容器

1.1 vector

特性：动态数组，支持随机访问。
优点：
动态大小，自动管理内存。
支持快速随机访问（O(1)）。
尾部插入和删除操作效率高（O(1)）。
缺点：
中间插入和删除操作效率低（O(n)）。
需要额外的内存管理，可能会导致内存碎片。

额外的内存管理，可能会导致内存碎片的原因：

1. 动态扩展
自动扩容：当 vector 的容量不足以容纳新元素时，它会自动扩展容量。这通常涉及分配一个更大的内存块，并将现有元素复制到新内存中。
重新分配：每次扩展都可能导致内存重新分配，从而产生短期的内存使用高峰，增加了内存碎片的风险。
2. 容量与大小的差异
容量大于大小：vector 通常会分配比当前元素数量更多的内存，以允许未来的插入而无需频繁重新分配。这种策略可能会导致内存未被有效利用，形成碎片。
浪费内存：如果 vector 的容量远大于实际使用的元素数量，未使用的内存可能与其他分配的内存块不连续，从而增加碎片的机会。
3. 插入和删除操作
频繁插入和删除：在 vector 中进行插入或删除操作（尤其是在中间位置）时，可能需要移动大量元素，影响内存的连续性。
内存重分配：如果插入元素时触发扩容，也会导致内存重分配，增加碎片的风险
4. 短生命周期的 vector
临时对象：如果 vector 被频繁创建和销毁，尤其是在函数中作为临时对象，可能导致频繁的内存分配和释放，增加碎片。
5. 不均匀的分配
小块和大块的混合使用：由于 vector 在不同情况下可能会进行不同大小的内存分配，最终会导致内存中小块和大块的混合，增加了碎片的产生。
6. 内存对齐问题
对齐要求：有些系统对内存的对齐有要求，vector 的分配可能未能完全遵循这些要求，从而导致额外的内存使用和碎片。

解决方案：

	1. 内存池
内存池是一种预先分配固定大小内存块的方法。程序启动时，分配一块较大的内存区域（池），然后在这个池中分配小块内存。优点是：
减少碎片：由于所有小块都是固定大小，内存的使用更有规律，避免了小块随机分布引起的碎片。
提高性能：分配和释放内存时，只需调整指针，而不需要频繁地进行系统调用，效率更高。
2. 自定义分配器
自定义内存分配器允许开发者根据应用的需求来优化内存管理。常见策略包括：

分级分配：根据对象大小将内存分为多个区域。例如，小对象在一个区，大对象在另一个区，这样可以减少小对象间的碎片。
统计信息：记录每种大小的内存块的使用情况，调整分配策略以适应实际使用。
3. 避免频繁分配和释放
频繁的动态内存分配和释放会导致碎片。可以通过以下方式减少这种情况：
重用内存：在不再需要对象时，尽量将其保留在池中以备后用，而不是释放内存。
使用数据结构：使用像 std::vector 这样的动态数组，能够自动管理内存并优化空间使用。
4. 合并空闲块
在释放内存时，合并相邻的空闲块可以减少碎片。具体步骤：
检查相邻块：释放内存后，查看前后相邻的内存块是否为空闲状态。
合并：如果是，合并它们成一个更大的空闲块，从而提高内存的使用效率。
5. 使用智能指针
智能指针是 C++11 引入的内存管理工具。使用智能指针的优点包括：
自动管理：智能指针会在对象超出作用域时自动释放内存，减少内存泄漏的可能性。
减少手动管理：开发者无需手动调用 delete，从而减少错误导致的内存碎片。
6. 分配策略
选择合适的内存分配策略可以影响碎片的产生：
首次适应（First Fit）：从开头开始查找第一个合适的空闲块，效率高但可能导致碎片。
最佳适应（Best Fit）：寻找最小的合适块，理论上可以减少剩余空闲块的大小，但查找时间较长。
最差适应（Worst Fit）：选择最大的空闲块，目的是留下大块的空闲内存，适合大对象分配，但不一定有效。
7. 内存压缩技术
一些库提供内存压缩功能，能够在内存使用后对已分配内存进行整理，压缩空闲块。这种方法可以降低碎片并提高内存的使用效率。
8. 使用现代内存分配器
现代的内存分配器（如 jemalloc、tcmalloc）提供更好的内存管理性能：
优化算法：这些分配器通常实现了更高级的分配算法，以减少碎片。
多线程友好：针对多线程环境进行优化，避免锁竞争，提高并发性能。

示例代码：

#include <iostream>
#include <vector>

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

1.2 list

特性：
双向链表，元素通过指针连接，每个元素包含前后指针。
优点：
高效的插入/删除：在已知位置插入或删除元素的时间复杂度为 O(1)，只需调整指针。
迭代高效：由于其结构，迭代访问性能良好。
缺点：
不支持随机访问：无法通过下标直接访问元素，查找复杂度为 O(n)。
内存占用：每个元素需要额外存储指针，内存开销较大。
适用场景：适合需要频繁插入或删除操作的场景，特别是在中间位置。

示例代码：

#include <iostream>
#include <list>

int main() {
    std::list<int> lst = {1, 2, 3};
    lst.push_back(4); // 添加元素
    lst.remove(2);    // 删除元素
    for (int num : lst) {
        std::cout << num << " "; // 输出: 1 3 4
    }
    return 0;
}

1.3 deque

特性：
双端队列，允许在两端进行快速插入和删除。
优点：
快速两端操作：在两端插入和删除的时间复杂度为 O(1)。
支持随机访问：访问任意元素的时间复杂度为 O(1)。
缺点：
内存复杂性：由于需要管理多个内存块，可能导致内存开销高于 vector。
适用场景：适合需要频繁在两端进行插入和删除的场景，如任务调度器。

示例代码：

#include <iostream>
#include <deque>

int main() {
    // 创建一个 deque
    std::deque<int> myDeque;

    // 添加元素
    myDeque.push_back(1); // 在末尾添加元素
    myDeque.push_back(2);
    myDeque.push_front(0); // 在前面添加元素

    // 输出当前 deque 内容
    std::cout << "Deque contents: ";
    for (int num : myDeque) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 访问元素
    std::cout << "First element: " << myDeque.front() << std::endl;
    std::cout << "Last element: " << myDeque.back() << std::endl;

    // 删除元素
    myDeque.pop_front(); // 删除第一个元素
    myDeque.pop_back();  // 删除最后一个元素

    // 输出修改后的 deque 内容
    std::cout << "After popping: ";
    for (int num : myDeque) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

//此程序输出
Deque contents: 0 1 2 
First element: 0
Last element: 2
After popping: 1

2. 关联容器

关联容器通过键来存储数据，提供快速的查找、插入和删除功能。

2.1 set

特性：
存储唯一元素的集合，自动按顺序排列。
优点：
自动去重：不允许重复元素，自动管理。
高效查找：查找、插入和删除的时间复杂度为 O(log n)。
缺点：
不能随机访问：无法通过索引直接访问元素。
适用场景：适合需要保持元素唯一并自动排序的情况，如存储不重复的值。

示例代码：

#include <iostream>
#include <set>

int main() {
    std::set<int> s = {1, 2, 3};
    s.insert(2); // 不会重复插入
    s.insert(4);
    for (int num : s) {
        std::cout << num << " "; // 输出: 1 2 3 4
    }
    return 0;
}

2.2 map

特性：
键值对的集合，键唯一，自动按键排序。
优点：
快速查找：查找、插入和删除的时间复杂度为 O(log n)。
有序存储：可以通过范围查询获取一组键值对。
缺点：
不能随机访问：访问特定元素的效率不如数组。
适用场景：适合需要根据键进行快速查找的情况，如字典或配置项。

示例代码：

#include <iostream>
#include <map>

int main() {
    std::map<std::string, int> ages;
    ages["Alice"] = 30;
    ages["Bob"] = 25;
    for (const auto& pair : ages) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    // 输出: Alice: 30
    //        Bob: 25
    return 0;
}

2.4 unordered_map

特性：
键值对的无序集合，键唯一。
优点：
平均 O(1) 查找：快速查找、插入和删除的平均时间复杂度为 O(1)。
灵活性：适合存储大量键值对的数据。
缺点：
哈希冲突：最坏情况下性能降至 O(n)。
无序性：无法通过顺序访问元素。
适用场景：适合需要频繁基于键进行查找的情况，如频率计数器。

示例代码：

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    // 创建一个 unordered_map
    std::unordered_map<std::string, int> myMap;

    // 添加元素
    myMap["apple"] = 3;
    myMap["banana"] = 5;
    myMap["orange"] = 2;

    // 输出当前 unordered_map 内容
    std::cout << "Fruit counts:" << std::endl;
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 访问元素
    std::cout << "Count of bananas: " << myMap["banana"] << std::endl;

    // 删除元素
    myMap.erase("orange");

    // 输出修改后的 unordered_map 内容
    std::cout << "After removing oranges:" << std::endl;
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

3. 容器适配器

容器适配器提供特定接口，封装底层容器的实现。

3.1 stack

特性：
后进先出（LIFO）结构，基于其他容器实现（如 deque）。
优点：
简单易用：只提供 push、pop、top 操作。
易于管理：适合管理临时数据。
缺点：
无法随机访问：只能访问栈顶元素。
适用场景：适合需要临时存储数据的情况，如函数调用栈或表达式求值。

3.2 queue

特性：
先进先出（FIFO）结构，基于其他容器实现（如 deque）。
优点：
简单操作：只提供 push、pop、front 操作。
任务调度：适合处理排队任务。
缺点：
无法随机访问：只能访问队头元素。
适用场景：适合任务排队或消息处理的场景。

3.3 priority_queue

特性：
根据优先级排序的队列，通常基于堆实现。
优点：
高效获取最高优先级元素：在 O(1) 时间内获取最大元素。
自动排序：元素根据优先级自动管理。
缺点：
随机访问受限：不能直接访问任意元素。
适用场景：适合调度任务或管理需要优先级处理的元素。