---

1. 顺序容器与关联容器的比较

存储方式

• 顺序容器：顺序容器通过连续的内存位置来存储元素，元素按照它们被添加到容器中的顺序来排列（除非明确进行排序）。顺序容器存储的是单个元素。
• 关联容器：关联容器以键值对的形式存储数据，每个元素包含一个键（key）和一个值（value）。关联容器中的元素可以根据键进行排序，并且可以快速通过键来访问元素。

有序性

• 顺序容器：默认情况下，顺序容器中的元素是无序的，除非显式地对它们进行排序。
• 关联容器：关联容器保持元素的有序性，通常是按照键的顺序进行排序。

查找效率

• 顺序容器：由于顺序容器中的元素是连续存储的，大多数顺序容器的查找操作需要遍历整个容器，因此其时间复杂度通常为O(n)。
• 关联容器：关联容器内部通常使用平衡二叉搜索树（如红黑树）或其他高效的数据结构来存储元素，因此查找、插入和删除操作的时间复杂度可以达到O(log n)。

迭代器

• 顺序容器：提供从第一个元素开始的迭代器，可以按顺序访问容器中的所有元素。
• 关联容器：提供基于键的迭代器，可以直接根据键来访问和比较元素。

典型容器

• 顺序容器：包括vector（动态数组）、list（双向链表）、deque（双端队列）、array（固定大小的数组）、forward_list（单向链表，C++11引入）等。
• 关联容器：包括map（存储唯一键及其关联值的映射）、multimap（允许键重复）、set（存储唯一元素的集合）、multiset（允许元素重复）、以及无序版本的unordered_map、unordered_multimap、unordered_set、unordered_multiset等。

顺序容器与关联容器的具体类型

顺序容器

• vector：动态数组，支持随机访问，能够高效地插入和删除尾部元素，但在中间或头部插入和删除元素时效率较低。
• list：双向链表，支持快速插入和删除操作，但随机访问效率较低。
• deque：双端队列，支持在两端快速插入和删除操作，内部实现为多个连续存储的块。
• array：固定大小的数组，支持随机访问，但大小在编译时确定，不支持动态扩容。
• forward_list：单向链表，仅支持向前遍历，适用于仅需要从一端插入和删除元素的场景。

关联容器

• map：存储键值对，键唯一，根据键的顺序进行排序，支持快速查找、插入和删除操作。
• multimap：类似于map，但允许键重复。
• set：存储唯一元素的集合，根据元素的顺序进行排序。
• multiset：类似于set，但允许元素重复。
• unordered_map、unordered_multimap、unordered_set、unordered_multiset：这些是无序版本的关联容器，内部使用哈希表实现，提供平均常数时间的查找、插入和删除操作。

综上所述，顺序容器和关联容器在C++中各有特点，选择哪种容器取决于具体的应用需求，如是否需要快速查找、元素是否必须有序、以及对性能等的要求。

2. vector 底层的实现

1. std::vector底层的实现

std::vector是C++标准模板库（STL）中的一个序列容器，它能够存储具有相同类型的元素，并允许随机访问容器中的任何元素。vector的底层实现通常是一个动态分配的连续数组。这个数组的大小可以根据需要动态增长或缩小，但通常会在需要更多空间时重新分配一个更大的连续内存块，并将旧数据复制到新位置，然后释放旧的空间。

2. 迭代器类型为随机迭代器

std::vector的迭代器类型为随机访问迭代器，这意味着它们支持使用下标操作符（[]）和指针算术进行访问，允许在常数时间内访问任何元素。随机访问迭代器还允许进行元素之间的迭代比较，以及使用迭代器与整数进行加减运算来访问容器中的元素。

3. insert 具体做了哪些事？

当在std::vector的某个位置插入一个新元素时，insert成员函数会执行以下操作：

1. 检查空间：首先，vector会检查当前已分配的存储空间是否足够容纳新元素和所有现有元素。如果空间不足，vector会分配一个新的、更大的数组。

2. 移动元素：如果vector需要扩容，或者插入位置不是容器的末尾，那么vector会将插入点之后的所有元素向后移动一个位置，为新元素腾出空间。这个操作是通过复制或移动构造函数（C++11及以后）完成的，具体取决于元素的类型和是否启用了移动语义。

3. 插入新元素：在腾出的空间位置，使用给定的值或元素（如果是迭代器或范围插入）构造新元素。

4. 更新迭代器：insert操作完成后，所有指向被移动元素的迭代器、引用和指针都会失效，因为它们的指向的内存位置可能已经被改变。返回的迭代器指向新插入的元素。

4. resize()调用的是什么？

resize()成员函数用于改变vector的大小。它接受一个参数，即新的大小n，以及一个可选的第二个参数，即如果新大小大于当前大小，则用于填充新元素的值。

• 如果新大小n小于当前大小，vector会删除超出n的元素，并释放可能不再需要的内存。
• 如果新大小n大于当前大小，vector会分配足够的空间（如果需要的话），并使用默认构造函数（如果未提供第二个参数）或给定的值来构造新元素。

在内部，resize()可能会调用内存分配函数（如operator new）来分配或重新分配内存，以及调用元素的构造函数或赋值运算符来初始化或赋值新元素。

总结来说，std::vector通过动态数组提供高效的随机访问和灵活的元素管理，但其性能可能受到重新分配和移动元素的影响。了解这些内部机制有助于更有效地使用vector并编写高效的C++代码。

3. vector 的 push_back 要注意什么

在C++中，std::vector是一个非常灵活且常用的容器，它支持动态数组的操作，如插入、删除和访问元素。然而，当在vector中大量使用push_back方法时，确实需要注意几个关键方面，特别是关于性能和资源管理的：

1. 拷贝构造与析构

拷贝构造（Copy Construction）与析构（Destruction）：每次调用push_back向vector中插入一个元素时，如果该vector的容量不足以存储新的元素，vector可能会重新分配更大的内存空间来存储所有现有的元素和新添加的元素。在这个过程中，如果元素类型不是轻量级的（比如包含大量数据或动态分配的内存），那么大量的拷贝构造和析构操作会导致性能下降。

解决方案：

• 使用移动语义：C++11引入了移动语义，允许使用std::move来传递对象，这可以避免不必要的拷贝。如果你的元素类型支持移动语义（即定义了移动构造函数和移动赋值运算符），则push_back将使用移动而不是拷贝来添加新元素，这可以显著提高性能。
• 预分配空间：使用reserve成员函数预先为vector分配足够的空间，可以避免在添加元素时重新分配内存。

2. 内存分配与释放

内存分配（Allocation）与释放（Deallocation）：如上所述，当vector的容量不足以存储更多元素时，它会分配一个新的、更大的内存块，并将旧数据拷贝（或移动）到新块中，然后释放旧块。这种内存分配和释放操作，特别是当频繁发生时，会对性能产生负面影响，并可能增加内存碎片。

解决方案：

• 预分配足够的空间：使用reserve成员函数可以预先分配足够的内存空间，从而避免不必要的内存分配和释放。
• 考虑使用其他容器：如果知道将要存储的元素数量，并且该数量在生命周期内不会改变太多，可以考虑使用std::array（固定大小数组）或std::deque（双端队列，支持在两端快速插入和删除）。

3. 迭代器失效

虽然这不是直接关于拷贝构造和析构或内存分配的问题，但值得注意的是，在vector中插入或删除元素可能会导致迭代器失效。特别是，在push_back之后，指向vector末尾的迭代器、引用和指针可能会失效，因为vector可能会重新分配内存。

解决方案：

• 尽量避免在vector的迭代过程中修改其大小，或者在修改后立即重新获取迭代器。
• 使用支持稳定迭代器的容器，如std::list或std::deque，但这可能会牺牲一些性能优势。

综上所述，当在C++中使用std::vector的push_back方法时，需要特别注意拷贝构造与析构的性能影响、内存分配与释放的效率，以及迭代器失效的问题。通过采用上述提到的解决方案，可以显著提高程序的性能和稳定性。

4. vector 的 resize() 与 reserve()

在C++中，std::vector是一个非常灵活且常用的容器，它允许存储可变数量的同类型元素。resize()和reserve()是std::vector中两个非常重要的成员函数，它们在容器的大小管理方面扮演着不同的角色。下面，我将首先解释这两个函数的作用，然后提供一个测试程序来演示它们的行为。

resize()

resize()函数用于改变容器的大小。如果新的大小大于当前大小，则会添加额外的元素（默认初始化为该类型的默认值），直到达到新的大小。如果新的大小小于当前大小，则多余的元素会被删除。

• 参数：size_type n（新的大小），可选的第二个参数const T& val（当增加大小时，用于初始化新元素的值）。
• 返回值：无返回值（但会改变容器大小）。

reserve()

reserve()函数用于请求改变容器的容量（即分配的内存大小）。这不会改变容器的大小（即已存储元素的数量），但会预留足够的空间以存储更多的元素，从而减少未来添加元素时重新分配内存的需要。

• 参数：size_type n（请求的新容量）。
• 返回值：无返回值（但会改变容器的容量）。

测试程序

以下是一个简单的C++程序，展示了resize()和reserve()的用法及其效果：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;

    // 初始状态
    std::cout << "初始容量: " << vec.capacity() << ", 大小: " << vec.size() << std::endl;

    // 使用reserve()增加容量
    vec.reserve(10);
    std::cout << "增加容量后: 容量: " << vec.capacity() << ", 大小: " << vec.size() << std::endl;

    // 使用resize()改变大小
    vec.resize(5, 100); // 将大小改为5，并用100初始化新增的元素
    std::cout << "改变大小后: 容量: " << vec.capacity() << ", 大小: " << vec.size() << std::endl;
    for (int val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    // 再次使用resize()减小大小
    vec.resize(3);
    std::cout << "再次改变大小后: 容量: " << vec.capacity() << ", 大小: " << vec.size() << std::endl;
    for (int val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出

程序的输出将取决于std::vector的具体实现（特别是其内存管理策略），但通常会类似于以下形式：

初始容量: 0, 大小: 0
增加容量后: 容量: 10, 大小: 0
改变大小后: 容量: 10, 大小: 5
100 100 100 100 100 
再次改变大小后: 容量: 10, 大小: 3
100 100 100 

注意，reserve()调用后，容量增加了，但大小（即元素数量）保持不变。resize()调用则改变了大小，并且如果需要，还会改变容量。在第二次resize()调用中，大小减小了，但容量保持不变（除非实现决定减小容量以节省内存）。

5. 如何释放 vector 的空间？

在C++中，std::vector是一个序列容器，它能够存储具有相同类型的元素。关于如何释放vector占用的空间，有几种不同的策略和方法，每种方法适用于不同的场景和需求。

1. 使用swap技巧释放vector空间

当你想重置vector的大小并尽可能释放其已分配的内存时，可以使用swap技巧。具体做法是，先将vector与一个空的临时vector进行swap操作，然后让临时vector离开作用域自动销毁，从而释放原vector占用的内存。

std::vector<int> vec;
// 假设vec已经被填充了数据，占用了大量内存

// 使用swap技巧释放vec的内存
std::vector<int>().swap(vec);

// 现在vec是空的，并且其容量被缩减到最小（或者实现定义的某个最小值）

2. 容器的元素类型为指针

如果vector的元素是指针，那么释放vector的内存本身并不会释放指针所指向的内存。这意呀着，你需要手动管理这些指针所指向的内存，以避免内存泄露。

• 直接管理：确保在删除vector元素之前，手动释放每个指针所指向的内存。
• 使用智能指针：为了避免手动管理内存的复杂性，可以使用智能指针（如std::unique_ptr或std::shared_ptr）来自动管理内存。这样，当智能指针离开作用域或被删除时，它们会自动释放所管理的内存。

3. 指针是trivial_destructor

如果指针的析构函数是trivial（即默认析构函数，不执行任何操作），那么当vector被销毁时，其元素（即指针）的析构函数也不会执行任何操作。这意呀着，即使vector被销毁，指针所指向的内存也不会被自动释放。因此，你需要确保在vector销毁之前，手动释放或转移这些指针所指向的内存的所有权。

4. 使用智能指针管理内存

为了避免内存泄露和简化内存管理，推荐使用智能指针来管理vector中的元素（如果元素是指针的话）。智能指针能够自动管理内存，减少手动释放内存的需要，从而降低出错的风险。

#include <vector>
#include <memory>

std::vector<std::unique_ptr<int>> vec;

// 添加元素
vec.emplace_back(std::make_unique<int>(10));
vec.emplace_back(std::make_unique<int>(20));

// 当vec被销毁时，所有unique_ptr也会自动销毁，进而释放它们所指向的内存

总结来说，释放vector占用的空间可以通过swap技巧实现，而管理vector中指针所指向的内存则需要额外的注意，包括手动管理或使用智能指针来自动管理。

6. vector 的 clear 与 deque 的 clear

在C++中，std::vector和std::deque是两种常用的序列容器，它们各自在处理元素时有着不同的内存管理策略。关于clear方法和erase方法在这两个容器中的行为，以及它们与内存管理的关系，我们可以从以下几个方面来详细解释。

std::vector 的 clear 和 erase

对于std::vector来说，clear和erase方法确实会析构容器中的元素，但是它们本身并不直接释放分配给容器的全部内存。std::vector内部维护一个连续的内存块来存储元素，这个内存块的大小（即容量，capacity）可能会比当前存储的元素数量（即大小，size）大。当你调用clear或erase移除所有元素时，这些操作会遍历并析构所有元素，将容器的大小设置为0，但并不会立即减小其容量。

• clear：将容器的大小设置为0，但容量保持不变。如果需要减少容量，需要显式调用shrink_to_fit（C++11及以后）来请求容器释放不需要的内存。但请注意，shrink_to_fit是一个请求，并非保证会释放内存。
• erase：从容器中移除一个或多个元素，但同样不改变容量。被移除的元素会被析构，剩余的元素会被向前移动以填补空白。

std::deque 的 clear 和 erase

与std::vector不同，std::deque是一个双端队列，它允许在容器的前端和后端快速插入和删除元素。std::deque的内部实现通常是由多个小的连续内存块（或称为缓冲区）组成的，这些内存块之间通过指针链接起来。这种设计使得std::deque在两端操作时可以避免整体数据的移动。

• clear：对于std::deque，clear方法会析构容器中的所有元素，并且根据实现的不同，它可能会释放内部使用的某些或全部缓冲区。然而，与std::vector类似，C++标准并没有强制要求std::deque在调用clear后必须释放所有内存。
• erase：与clear类似，erase方法会析构被移除的元素，并且根据删除操作的位置和范围，它可能会调整内部缓冲区的链接和大小。在某些情况下，这可能会导致释放一些不再需要的缓冲区。

总结

• std::vector的clear和erase只会析构元素，不会释放内存（除非显式调用shrink_to_fit）。
• std::deque的clear和erase同样会析构元素，并且可能会根据内部实现和删除操作的具体情况释放一些或全部缓冲区。然而，C++标准并不保证std::deque在调用clear后必须释放所有内存。

在面试中，解释这些概念时，可以强调标准库实现的具体行为可能因编译器和库的不同而有所差异，但总体上遵循上述原则。同时，也可以讨论在特定情况下，如内存使用非常紧张时，如何通过手动管理内存（如使用std::unique_ptr管理动态分配的std::vector）或使用其他容器（如std::list，虽然它在随机访问上不如vector和deque高效）来优化内存使用。

7. list 的底层实现

在C++标准库中，std::list 是一种双向链表（doubly linked list）的实现。这种数据结构允许高效的插入和删除操作，而不需要像数组或向量（std::vector）那样进行大量的元素移动。下面，我将详细解释 std::list 的底层实现，特别是它如何支持双向迭代器。

双向链表的结构

双向链表中的每个节点（node）都包含三个部分：

1. 数据域：存储元素的值。
2. 前驱指针（prev pointer）：指向链表中前一个节点的指针。对于链表的头节点，这个指针通常被设置为 nullptr 或指向一个特殊的哨兵节点（sentinel node，具体取决于实现）。
3. 后继指针（next pointer）：指向链表中后一个节点的指针。对于链表的尾节点，这个指针通常被设置为 nullptr。

std::list 的实现

std::list 的实现围绕上述双向链表结构进行。它提供了丰富的成员函数来管理链表，如插入、删除、遍历等。

双向迭代器

由于 std::list 是一个双向链表，它自然支持双向迭代器。双向迭代器允许你向前或向后遍历链表，但不能直接进行随机访问（如 std::vector 的迭代器那样）。

双向迭代器通常至少包含以下两个操作：

• operator++()：将迭代器向前移动到下一个元素。
• operator--()：将迭代器向后移动到前一个元素。

此外，为了支持双向遍历，双向迭代器还可能包含比较运算符（如 == 和 !=）来比较两个迭代器是否指向相同的元素。

std::list 的迭代器实现

在 std::list 的实现中，迭代器通常是一个轻量级的封装，它内部持有一个指向链表节点的指针（或引用）。这个指针允许迭代器访问节点的数据，以及通过前驱和后继指针在链表中移动。

示例

尽管我们不能直接看到标准库的内部实现，但我们可以想象一个简化的迭代器类可能看起来像这样：

template<typename T>
class ListNode {
public:
    T data;
    ListNode* prev;
    ListNode* next;

    ListNode(T val) : data(val), prev(nullptr), next(nullptr) {}
};

template<typename T>
class ListIterator {
private:
    ListNode<T>* node;

public:
    ListIterator(ListNode<T>* n = nullptr) : node(n) {}

    T& operator*() { return node->data; }
    T* operator->() { return &node->data; }

    ListIterator<T>& operator++() {
        node = node->next;
        return *this;
    }

    ListIterator<T>& operator--() {
        node = node->prev;
        return *this;
    }

    // 省略其他可能的成员函数，如比较运算符等
};

请注意，上面的代码是一个高度简化的示例，用于说明双向迭代器的概念，而不是 std::list 的实际实现细节。

总之，std::list 的底层实现是一个双向链表，它使用双向迭代器来支持向前和向后的遍历。这种设计提供了灵活的元素管理，特别是在需要频繁插入和删除元素时。

8. deque 的底层实现

在C++中，std::deque（双端队列）是一个序列容器，它允许在容器的开头和结尾快速插入和删除元素。与std::vector相比，std::deque提供了更灵活的元素插入和删除操作，尤其是在容器的两端。为了实现这些特性，std::deque的底层实现采用了与std::vector不同的策略。

deque 的底层实现

std::deque的底层实现通常包括一个中央控制器（或称为映射表、索引数组）和多个固定大小的连续内存块（通常称为缓冲区或段）。这种设计允许deque在容器的两端进行快速的插入和删除操作，而不需要像vector那样在每次插入或删除元素时重新分配整个内存块。

• 中央控制器：这是一个数组（或类似结构），用于存储指向每个连续内存块的指针（或迭代器）。这个数组的大小决定了deque能够直接管理的内存块数量，但它本身的大小可以动态调整以适应更多的内存块。

• 连续内存块：每个内存块都包含了一定数量的元素，这些元素在内存中是连续存储的。但是，不同内存块之间的元素在内存中并不一定是连续的。每个内存块的大小在deque被创建时确定，并且通常保持不变（尽管有些实现可能允许在必要时重新调整内存块的大小）。

迭代器类型为随机迭代器

std::deque的迭代器被设计为随机迭代器（Random Access Iterator），这意味着它们支持所有的迭代器操作，包括随机访问。具体来说，它们支持以下操作：

• 使用迭代器算术（如++、--、+=、-=）来在容器中前进或后退。
• 使用迭代器间的算术运算（如iter1 - iter2）来计算两个迭代器之间的距离。
• 使用下标操作符（如iter[n]）来直接访问迭代器之后的第n个元素（注意，这种用法可能会超出迭代器的有效范围）。
• 使用比较操作符（如==、!=、<、<=、>、>=）来比较迭代器。

由于deque的迭代器支持随机访问，因此可以使用标准库算法中的任何需要随机迭代器的算法，如std::sort、std::binary_search等。

总结

std::deque的底层实现通过中央控制器和多个连续内存块来支持在容器两端的高效插入和删除操作。其迭代器设计为随机迭代器，支持广泛的迭代器操作，包括随机访问，这使得deque在许多情况下都是一个非常灵活和强大的容器选择。

9. vector 与 deque 的区别

在C++中，std::vector和std::deque都是序列容器，但它们在设计、内部实现和性能特性上有着显著的差异。下面是对这两个容器区别的详细解释，特别是针对您提到的两点：

1. 内部实现

• std::vector：vector是一个动态数组，它在连续的内存位置上存储元素。这意味着vector中的所有元素都紧密地排列在一起，因此它可以高效地访问任何位置的元素（通过下标或迭代器），时间复杂度为O(1)。然而，由于它是连续存储的，所以在其开始或结束位置插入或删除元素时可能需要移动大量的元素，以保持连续性，这通常会导致较差的性能（时间复杂度为O(n)）。

• std::deque：deque（双端队列）是一个能够在两端高效插入和删除元素的序列容器。与vector不同，deque通常不是以连续的方式存储其元素的；相反，它通过多个较小的连续数组（或称为块）来存储元素，并管理一个指向这些块的索引。这种结构使得deque在两端插入或删除元素时非常高效（时间复杂度为O(1)），因为它只需要修改索引和可能地重新分配一小部分内存。但是，由于元素不是连续存储的，所以随机访问元素的性能（尽管仍然是O(1)，但可能包含额外的间接寻址开销）可能略逊于vector。

2. 容量管理

• std::vector：vector有一个capacity()成员函数，它返回容器在不重新分配其存储空间的情况下能够存储的元素的最大数量。当向vector中添加元素并且当前大小超过容量时，它可能会分配一个更大的内存块，并将所有元素复制到新位置（这称为重新分配），这是一个相对昂贵的操作。

• std::deque：deque没有直接提供capacity()的概念，因为它不是基于单一连续内存块的。然而，deque确实管理着多个块的内存分配，但它并不提供一个直接的方法来查询这些块的总容量或单个块的大小。deque通过动态地管理这些块来确保高效的插入和删除操作，而不必担心整个容器的重新分配。

总结

• 性能特点：如果你需要频繁地在序列的开头或结尾插入或删除元素，deque可能是更好的选择，因为它在这些操作上提供了更好的性能。如果你主要进行随机访问并且不关心在序列两端的操作，vector可能会更合适，因为它提供了更好的随机访问性能。

• 内存管理：vector使用单一连续的内存块，并提供了capacity()来查询其当前容量。而deque则通过多个较小的连续内存块来管理元素，并不直接提供capacity()的概念。

• 使用场景：选择哪个容器取决于你的具体需求。如果你需要一个能够高效地进行随机访问的序列，并且不需要频繁地在序列两端进行操作，那么vector是更好的选择。如果你需要在序列的两端进行高效的插入和删除操作，那么deque是更合适的选择。

10. map、set 的实现原理

- 红黑树
- 对于 set 来说 key 和 value 合一，value 就是 key
- map 的元素是一个 pair，包括 key 和 value
- set 不支持[]
- map(不包括 multimap)支持[]

在C++中，std::map 和 std::set 是两种基于键值对（对于map）或单一键（对于set）的有序容器。它们的实现原理主要依赖于平衡二叉搜索树，特别是红黑树（Red-Black Tree），以确保在对数时间内完成查找、插入和删除操作。下面我将详细解释这些概念以及您提到的各点。

红黑树

红黑树是一种自平衡的二叉搜索树，它通过一系列属性和旋转操作来保持树的平衡，从而确保在最坏情况下基本操作（如搜索、插入、删除）的时间复杂度为O(log n)，其中n是树中节点的数量。红黑树的每个节点都包含一个颜色属性（红色或黑色），并且满足以下性质：

• 每个节点要么是红色，要么是黑色。
• 根节点是黑色。
• 每个叶子节点（NIL节点，空节点）是黑色。
• 如果一个节点是红色的，则它的两个子节点都是黑色的（也就是说，在红黑树中，红色节点不能相邻）。
• 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

map 的实现原理

std::map 是一个关联容器，它存储的元素是键值对（pair），并且按键（key）的升序排列。map 内部使用红黑树来组织这些键值对，以便快速查找、插入和删除元素。当使用map的[]操作符时，如果键已存在，则返回该键对应的值的引用；如果键不存在，则插入一个具有该键的新键值对，并返回新插入值的引用（其值被初始化为该类型的默认值）。

set 的实现原理

std::set 是一个容器，它只包含键，并且这些键是唯一的，按照升序排列。在set中，键和值实际上是“合一”的，即每个元素既是键也是值。由于set只包含键，因此它不提供[]操作符来访问元素。相反，它提供了诸如find()、insert()、erase()等成员函数来操作元素。

对于 map 和 set 的比较

• 存储结构：map存储键值对，而set只存储键。
• 访问方式：map可以通过[]操作符访问元素（如果键存在则返回对应的值，否则插入新键值对），而set不支持[]操作符，因为它不包含值部分。
• 性能：由于map和set都基于红黑树实现，因此它们的查找、插入和删除操作的时间复杂度都是O(log n)。

总结

在C++中，std::map和std::set是通过红黑树实现的有序容器，它们提供了高效的查找、插入和删除操作。map存储键值对，并支持通过键来访问值，而set只存储键，并且不支持通过[]操作符访问元素。了解这些实现细节有助于在开发过程中做出更合适的数据结构选择。

11. set(map) 和 multiset(multimap)的区别

- set 不允许 key 重复,其 insert 操作调用 rb_tree 的 insert_unique 函数
- multiset 允许 key 重复,其 insert 操作调用 rb_tree 的 insert_equal 函数

在C++标准库中，set、map、multiset和multimap都是基于红黑树（RB-Tree，一种自平衡二叉搜索树）实现的关联容器，它们提供了对键（key）的快速查找、插入和删除操作。然而，这些容器在处理键的唯一性方面有所不同，这直接影响了它们的内部操作和行为。下面是set/map和multiset/multimap之间区别的详细解释：

set 和 multiset

• 唯一性：

  • set：不允许有重复的元素（或键）。当你尝试向set中插入一个已存在的元素时，插入操作将失败，并且容器的大小不会增加。
  • multiset：允许有重复的元素（或键）。你可以向multiset中插入多个相同的元素，并且每个元素都将被存储。

• 内部操作：

  • set 的 insert 操作在底层调用红黑树的 insert_unique 函数。这个函数首先检查要插入的键是否已经存在于树中，如果不存在，则将其插入树中；如果存在，则插入操作失败（在C++标准库中，这通常表现为返回一个指向已存在元素的迭代器，但不改变容器的大小）。
  • multiset 的 insert 操作在底层调用红黑树的 insert_equal 函数。这个函数不检查要插入的键是否已经存在于树中，而是直接将其插入树中，允许键的重复。

map 和 multimap

• 键值对：

  • map 和 multimap 与 set 和 multiset 类似，但存储的是键值对（key-value pairs）。这意味着每个元素都有一个键和一个与之关联的值。

• 唯一性：

  • map：不允许有重复的键。每个键都映射到一个唯一的值。
  • multimap：允许有重复的键，但每个键可以映射到多个值。

• 内部操作：

  • 与 set 和 multiset 类似，map 的 insert 操作调用 insert_unique，而 multimap 的 insert 操作调用 insert_equal。这些操作确保了各自的唯一性约束。

总结

• set/map 适用于需要唯一键的场景，如去重、快速查找等。
• multiset/multimap 适用于允许键重复的场景，如统计某个键出现的次数、存储具有相同键但值不同的数据等。

了解这些容器的内部实现（如红黑树的使用）和它们之间的区别，有助于在C++编程中做出正确的选择，从而优化程序的性能和资源使用。

12. set(multiset) 和 map(multimap)的迭代器

在C++中，set、multiset、map 和 multimap 都是基于红黑树（Red-Black Tree）实现的关联容器，它们各自具有特定的用途和行为特性。关于这些容器的迭代器及其允许的操作，下面将给出准确、全面且深入的答案。

1. set 和 multiset

• 基本概念：set 是一个包含唯一元素的集合，而 multiset 则允许存储重复的元素。在这两个容器中，每个元素的值（即“key”）和元素本身是一体的，也就是说，不存在一个单独的“key”和一个与之关联的“value”。

• 迭代器行为：由于 set 和 multiset 中的元素（或称为“节点”）仅由其值（或说“key”）构成，因此迭代器指向的就是这个值本身。由于容器内部维持了元素的排序（根据元素的键值），因此迭代器不允许直接修改其所指向元素的值（即“key”），因为这会破坏容器的排序特性。尝试修改 set 或 multiset 迭代器所指向的值将导致未定义行为。

2. map 和 multimap

• 基本概念：map 是一个存储键值对的集合，其中每个键都是唯一的，而 multimap 则允许存储具有相同键的多个键值对。每个键值对由一个键（key）和一个与之相关联的值（value）组成。

• 迭代器行为：map 和 multimap 的迭代器指向的是键值对。通过迭代器，我们可以访问和修改与键相关联的值（即“data”），但不能直接修改键本身。这是因为修改键可能会改变键值对在容器中的位置，从而破坏容器的排序特性（map 和 multimap 都是按键排序的）。然而，需要注意的是，C++标准并没有直接禁止通过迭代器访问的引用来修改键，但这样做是危险的，因为它会破坏容器的内部一致性。正确的做法是，如果需要修改键，应该先从容器中删除旧键值对，然后插入新的键值对。

总结

• 对于 set 和 multiset：迭代器不允许修改其所指向的元素（即“key”），因为元素的值和键是合一的，修改它会破坏容器的排序特性。

• 对于 map 和 multimap：迭代器允许修改与键相关联的值（即“data”），但不建议（且实际上在技术上也是困难的）修改键本身。如果需要修改键，应该采用先删除后插入的策略。

在面试中，回答这类问题时，除了准确描述迭代器的行为外，还可以进一步讨论为什么有这样的限制（即维护容器的排序特性和内部一致性），以及如何在需要时绕过这些限制（如在 map 和 multimap 中修改键的正确方法）。

---

当然，关于map和multimap，这里有一些更详细的信息，包括它们的基本特性、使用场景、内部实现以及一些高级用法。

基本特性

• 键值对存储：map和multimap都存储键值对（key-value pairs）。在map中，每个键都是唯一的，而在multimap中，可以有多个键值对具有相同的键。

• 排序：这两个容器都自动按键的升序对元素进行排序。默认情况下，使用<运算符来比较键，但你可以通过提供自定义的比较函数或对象来改变排序规则。

• 快速查找：由于它们是基于红黑树实现的，因此map和multimap都提供了对数时间复杂度的查找、插入和删除操作。

使用场景

• map：当你需要存储唯一键及其关联的值时，map是一个很好的选择。例如，它可以用来存储学生的ID和姓名、员工的ID和工资等信息。

• multimap：当你需要存储可能具有多个值的键时，multimap是更合适的选择。例如，它可以用来存储学生的姓名和他们选修的课程（一个学生可以选修多门课程）。

内部实现

• 红黑树：map和multimap通常使用红黑树作为底层数据结构。红黑树是一种自平衡的二叉搜索树，它确保了树的高度大致保持在对数级别，从而保证了操作的效率。

• 节点：每个节点都包含三个部分：键（key）、值（value）和指向子节点的指针（通常是左子节点和右子节点）。在红黑树中，节点还可能包含额外的信息（如颜色）来帮助维护树的平衡。

高级用法

• 迭代器：map和multimap的迭代器提供了对容器中元素的顺序访问。你可以使用迭代器来遍历容器中的所有元素，或者查找具有特定键的元素。

• 范围访问：C++11及更高版本引入了基于范围的for循环，这使得遍历map或multimap变得更加简单。

• 自定义比较：你可以通过提供一个自定义的比较函数或对象来改变map或multimap的排序规则。这允许你根据复杂的条件对键进行排序。

• 插入和删除：你可以使用insert成员函数来向map或multimap中添加元素。如果尝试向map中插入一个已经存在的键，则插入操作将失败（尽管在某些情况下，你可以通过提供自定义的比较函数来允许键的“等价”但不相等的插入）。你可以使用erase成员函数来删除元素，它接受迭代器或键值对作为参数。

• 查找：你可以使用find成员函数来查找具有特定键的元素。如果找到了该元素，find将返回一个指向该元素的迭代器；否则，它将返回一个指向容器末尾的迭代器（即end()迭代器）。

• 性能考虑：虽然map和multimap提供了高效的查找、插入和删除操作，但它们的性能可能会受到键的比较操作复杂度的影响。因此，在选择键的类型和比较函数时，应该考虑其对性能的影响。

13. map 与 unordered_map 的区别

- hash_map 需要 hash 函数及等于函数
- map 只需小于函数

在C++中，std::map和std::unordered_map是两个非常常用的关联容器，它们各自有着独特的设计理念和性能特性。以下是它们之间的一些关键区别，以及对您提到的hash_map（注意，在C++标准库中并不存在名为hash_map的容器，但这里可能是指unordered_map的类似概念）和map所需函数的解释。

1. 内部实现

• std::map：map是基于红黑树（一种自平衡二叉搜索树）实现的。它保持元素按键的排序顺序（默认情况下是升序，但可以通过自定义比较函数来改变）。由于红黑树的性质，map在插入、删除和查找元素时提供了对数时间复杂度（O(log n)）。

• std::unordered_map：unordered_map（有时被非正式地称为hash_map）是基于哈希表实现的。它通过哈希函数将键映射到表的索引上，从而允许常数时间复杂度（平均情况下为O(1)）的插入、删除和查找操作。然而，在最坏情况下（例如，当哈希函数导致大量冲突时），这些操作的时间复杂度可能会退化到O(n)。

2. 所需的函数

• std::unordered_map：unordered_map需要两个关键的函数：

  • 哈希函数：用于将键映射到哈希表的索引上。unordered_map允许用户通过模板参数指定自定义的哈希函数，但如果不指定，则会使用键类型的默认哈希函数（如果可用）。
  • 等于函数：用于比较两个键是否相等。这是为了处理哈希冲突时的情况，即两个不同的键可能具有相同的哈希值。同样，如果不指定，则会使用键类型的默认等于操作符。

• std::map：map只需要一个函数：

  • 小于函数（或更一般地，比较函数）：用于定义键之间的排序顺序。map允许用户通过模板参数指定自定义的比较函数，但如果不指定，则会使用键类型的默认小于操作符（<）。

3. 性能特性

• 内存使用：由于map是基于树的，它通常比unordered_map使用更多的内存（因为树结构需要额外的指针或引用）。然而，unordered_map的内存使用可能因哈希冲突而增加（例如，通过增加链表长度来处理冲突）。

• 迭代顺序：map保证按照键的排序顺序遍历元素，而unordered_map不保证任何特定的迭代顺序。

4. 适用场景

• 如果你需要保持元素的排序顺序，那么map是更好的选择。
• 如果你关心查找、插入和删除操作的速度，并且不关心元素的排序顺序，那么unordered_map可能更合适。

总结来说，std::map和std::unordered_map在内部实现、所需的函数、性能特性和适用场景等方面都存在显著的差异。在选择使用哪一个时，应该根据你的具体需求来做出决定。

14. set(multiset) 和 map(multimap)的迭代器++操作、–操作的时间复杂度？

在C++标准库中，set、multiset、map和multimap都是基于红黑树（一种自平衡二叉搜索树）实现的关联容器。这些容器的迭代器行为在很大程度上是由它们底层的红黑树数据结构决定的。

迭代器++（递增）和–（递减）操作的时间复杂度

对于set、multiset、map和multimap，无论是递增（++）还是递减（--）迭代器，其时间复杂度都是O(1)。

解释

红黑树是一种特殊的二叉搜索树，它通过确保树大致平衡（通过旋转和重新着色操作）来保持较低的树高，从而保证了良好的搜索、插入和删除性能。在红黑树中，每个节点都保存有指向其子节点的指针（对于map和multimap，每个节点还保存了键和值）。

• 递增迭代器（++）：当对set、multiset、map或multimap的迭代器执行递增操作时，迭代器简单地移动到当前节点的右子节点（如果右子节点存在）或沿着树向上移动直到找到一个节点，其左子节点有一个右子树（这个右子树包含了我们想要的下一个元素）。由于红黑树的平衡性质，从根节点到任何叶节点的路径长度都是对数级别的，但这个操作本身并不涉及遍历整条路径，只是简单地跟随几个指针移动，因此是O(1)的。

• 递减迭代器（--）：递减操作与递增操作类似，但方向相反。迭代器会移动到当前节点的左子节点（如果左子节点存在）或沿着树向上移动直到找到一个节点，其右子节点有一个左子树（这个左子树包含了我们想要的前一个元素）。同样，由于红黑树的平衡性质，这个操作也是O(1)的。

总结

在C++标准库中，set、multiset、map和multimap的迭代器递增（++）和递减（--）操作的时间复杂度都是O(1)。这是由它们底层红黑树数据结构的性质决定的，使得这些操作能够快速完成，而无需遍历大量节点。

15. 空间分配器 allocator

C++ 中的空间分配器（Allocator）

在C++中，allocator是一个用于封装内存分配和释放策略的模板类，它允许用户自定义内存管理的方式。这对于需要精细控制内存使用（如内存池、对象池等）的场景特别有用。标准库中的std::allocator是最基本的分配器，但C++也允许开发者实现自定义的分配器。

将 new 和 delete 的 2 阶段操作分离

通常，new操作符执行两个主要操作：内存分配（通过operator new）和对象构造；delete操作符则执行对象析构和内存释放（通过operator delete）。allocator将这两个阶段明确分离：

• allocate 和 deallocate 负责内存分配和释放，但不涉及对象的构造或析构。
• construct 和 destroy 则负责在已分配的内存上构造和析构对象。

SGI 的空间分配器

SGI（Silicon Graphics Inc.）实现了一系列空间分配器，包括std::allocator和一些特殊的分配器，如std::alloc（注意，std::alloc并不是标准C++库的一部分，但这里可能是指SGI实现的类似功能的分配器）。

• std::allocator：符合C++标准的最基本分配器，使用全局的new和delete进行内存分配和释放。

第一级分配器

第一级分配器通常直接调用全局的malloc和free（或在C++中，间接通过operator new和operator delete），并可能仿真new-handler机制。

• 如何仿真 new-handler 机制？：在自定义分配器中，可以通过设置一个全局或静态的回调函数（类似于std::set_new_handler），当内存分配失败时调用此函数。然而，由于不直接使用::operator new，需要在分配器内部实现检查机制，当malloc（或类似函数）返回nullptr时，调用此回调函数。

第二级分配器

第二级分配器通常更复杂，引入了内存池和多个free-list来优化内存分配和释放的性能。

• 为什么要二级分配器？：二级分配器旨在通过减少内存分配和释放的开销来提高性能。通过维护一个或多个内存池和free-list，可以更快地找到和重用之前释放的内存块，减少了对全局内存分配器的调用次数。

• 内存池与 16 个 free-list：内存池是预先分配的大块内存，而free-list是这些内存块中已释放但可重用的对象的链表。SGI的实现可能包含多个free-list，每个free-list针对特定大小的内存块，以优化内存利用率和分配速度。16个free-list可能意味着分配器为不同大小的内存块维护了不同的链表。

• 空间分配和释放的步骤：

  • 分配：首先检查是否有合适的free-list中有现成的内存块。如果有，直接从该free-list中取出一个内存块返回。如果没有，则可能从内存池中分配新的内存块，或者调用第一级分配器（如全局的malloc）。
  • 释放：将释放的内存块添加到对应的free-list中，以便将来重用。如果free-list已满或不存在对应的列表，则可能需要将内存块返回给内存池或第一级分配器。

通过这些机制，allocator不仅提供了灵活的内存管理策略，还能够在一定程度上提高程序的性能和效率。

16. traits 与迭代器相应类型

在C++中，traits和迭代器（Iterators）是两个非常重要的概念，它们各自在泛型编程和标准库设计中扮演着关键角色。当面试官提到“traits与迭代器相应类型”时，他可能是想了解如何在C++中利用traits技术来处理或获取迭代器的特定类型信息。

Traits技术

Traits技术是一种在C++中实现类型信息抽象和查询的技术。它通常通过模板特化和模板元编程来实现，允许在不修改类型本身的情况下，为类型提供额外的信息或行为。Traits通常用于泛型编程中，以解决类型相关的信息或行为在编译时无法直接获得的问题。

迭代器

迭代器是C++标准库中的一个核心概念，它提供了一种通用的方法来访问容器中的元素，而无需了解容器的内部结构。迭代器可以看作是一种“智能指针”，它能够遍历容器中的元素，但不知道容器的具体类型或大小。迭代器定义了如operator*（解引用），operator++（递增），operator--（递减）等操作，以支持对容器元素的访问和遍历。

Traits与迭代器相应类型

在C++标准库中，迭代器根据其功能被分为多个类别，如输入迭代器（Input Iterators）、输出迭代器（Output Iterators）、前向迭代器（Forward Iterators）、双向迭代器（Bidirectional Iterators）和随机访问迭代器（Random Access Iterators）。每种类型的迭代器都支持不同的操作集。

为了编写与迭代器类型无关的泛型代码，C++标准库定义了一系列traits类，用于在编译时查询迭代器的类型信息。这些traits类通常位于<iterator>头文件中，并允许程序员编写不依赖于具体迭代器类型的代码。

以下是一些与迭代器类型相关的traits类的例子：

• std::iterator_traits<Iter>::iterator_category：用于获取迭代器的类别（如std::input_iterator_tag、std::forward_iterator_tag等）。
• std::iterator_traits<Iter>::value_type：用于获取迭代器所指向元素的类型。
• std::iterator_traits<Iter>::difference_type：用于获取迭代器之间差异的类型（通常是整数类型，表示两个迭代器之间的距离）。
• std::iterator_traits<Iter>::pointer：如果迭代器支持解引用为指针，则提供指向元素的指针类型；否则，通常是value_type*的别名。
• std::iterator_traits<Iter>::reference：提供对迭代器所指向元素的引用类型（可能是左值引用或右值引用）。

示例

以下是一个使用std::iterator_traits来获取迭代器类型的简单示例：

#include <iostream>
#include <iterator>
#include <vector>

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

    // 获取迭代器所指向元素的类型
    using value_type = typename std::iterator_traits<decltype(it)>::value_type;
    std::cout << "The value type is: " << typeid(value_type).name() << std::endl;

    // 获取迭代器的类别
    using iterator_category = typename std::iterator_traits<decltype(it)>::iterator_category;
    std::cout << "The iterator category is: "
              << (std::is_same<iterator_category, std::random_access_iterator_tag>::value ? "Random Access"
                 : (std::is_same<iterator_category, std::bidirectional_iterator_tag>::value ? "Bidirectional"
                  : (std::is_same<iterator_category, std::forward_iterator_tag>::value ? "Forward"
                   : (std::is_same<iterator_category, std::input_iterator_tag>::value ? "Input"
                    : "Unknown"))))
              << std::endl;

    return 0;
}

在这个示例中，我们使用了std::iterator_traits来获取std::vector<int>::iterator的类型信息和类别，并打印了它们。注意，typeid(value_type).name()的输出可能因编译器而异，因此它可能不会直接显示为"int"。