C++STL面试题_c++ stl面试题-CSDN博客

本文链接：https://blog.csdn.net/qq_71286244/article/details/140932071

1. C++vector原理？resize和reserve的区别是什么？size和capacity的区别？

C++中的 std::vector 是一个动态数组，能够存储可变大小的元素集合。它提供了许多方便的操作，允许开发者以类似数组的方式访问元素，同时能够自动管理内存。

std::vector 的基本原理

动态数组：std::vector 在内部维护一个可动态调整大小的数组。
内存管理：当元素数量超出当前容量（capacity）时，vector 会重新分配内存，通常会扩展到原来的两倍，并将现有元素移动到新的内存地址中。
随机访问：vector 提供随机访问特性，可以用下标直接访问任意元素。

size 和 capacity 的区别

size：返回当前存储元素的数量。可以通过 vector.size() 获取。
capacity：返回当前分配的内存容量，也就是在不再进行重新分配的情况下，vector 可以容纳的元素数量。可以通过 vector.capacity() 获取。

std::vector<int> vec = {1, 2, 3};  
std::cout << "Size: " << vec.size() << std::endl;       // 输出 3  
std::cout << "Capacity: " << vec.capacity() << std::endl; // 输出 3 或更高的值  
vec.push_back(4); // 可能导致重新分配  
std::cout << "Size: " << vec.size() << std::endl;       // 输出 4  
std::cout << "Capacity: " << vec.capacity() << std::endl; // 有可能增加

resize 和 reserve 的区别

resize(size_type count)：

作用：改变 vector 的大小。若 count 增加，新的元素将使用默认构造（如果有）或者需提供的值初始化。若 count 减少，则会去除尾部元素。
例子：

std::vector<int> vec = {1, 2, 3};  
vec.resize(5, 0); // vec 变为 {1, 2, 3, 0, 0}  
vec.resize(2);    // vec 变为 {1, 2}

reserve(size_type new_cap)：

作用：更改 vector 的容量，但不改变其大小。仅会分配内存，以允许在未来的操作中容纳更多的元素，避免频繁的内存重新分配。
例子：

std::vector<int> vec;  
vec.reserve(10); // 现在 capacity 至少为 10，但 size 仍然是 0

总结

size 表示 vector 中当前的元素数量。
capacity 是实际可容纳的元素数量。
resize 用于更改 vector 的大小并初始化新元素。
reserve 用于增加 vector 的容量以提高性能，但不改变逻辑大小。

通过合理利用这两个函数，可以有效地管理动态数组的内存使用，优化性能。

2. C++deque的原理？它的内部是如何实现的？

C++中的 std::deque（双端队列）是一个能够在两端高效插入和删除的序列容器。与 std::vector 不同，deque 允许在两端进行快速操作，适用于需要频繁进行插入和删除的场景。

std::deque 的基本原理

双端队列：std::deque 允许在两端（头部和尾部）插入和删除元素，同时支持随机访问。
动态存储：deque 在内部使用多个动态数组（或块）来存储元素。这允许它在不同的块中动态分配内存并使得插入和删除操作更高效。

内部实现

分段存储：deque 的实现通常使用一个指针数组（或块数组），每个指针指向存储一块元素的内存。这种结构使得在 deque 的两端进行插入和删除变得高效，因为可以在块的边缘操作而不需要移动整个数组。
容量管理：deque 维护一个前哨块和一个后哨块，这两个块分别用于存储队列的头部和尾部，这样可以在两端进行有效的添加和删除，同时保持对中间元素的访问能力。
内存分配：deque 会预分配一些块，一旦块中元素达到一定数量，就会分配新的块。其具体实现可能依赖于编译器和库的实现，但基本思路是通过维护一个块池来节省内存和缩短操作时间。

性能特点

插入和删除操作：在头部或尾部插入和删除元素的复杂度为 O(1)。因为只需改变指针而不需要移动元素。
随机访问：虽然 deque 支持随机访问，复杂度为 O(1)，但由于它是分段存储的，连续性并不如 vector 高，因此，随机访问可能相对较慢。
内存使用：相较于 vector，deque 的内存使用更加灵活，但可能会导致较多的内存分配和碎片。

总结

std::deque 是一个双端队列，允许在两端进行高效的插入与删除操作。
它的内部实现基于多个动态数组（或块），使用指针数组管理存储块。
插入和删除操作是 O(1)，但由于分段存储，随机访问性能不如 std::vector。

通过这些特性，std::deque 在适用场景上提供了比 vector 和其他容器更加灵活的选择。

3. C++中map和unordered_map的区别？分别在什么场景下使用？

在 C++ 中，std::map 和 std::unordered_map 是两种主要的关联容器。它们都用于存储键值对，但在实现和性能特征上有一定的区别。

基本区别

存储结构:

std::map:

基于红黑树（自平衡的二叉搜索树）。
自动按照键的顺序保存元素。

std::unordered_map:

基于哈希表。
插入顺序不确定，元素没有特定的顺序。

访问时间复杂度:

std::map:

查找、插入和删除操作的复杂度为 O(log n)。

std::unordered_map:

查找、插入和删除操作的平均复杂度为 O(1)，最坏情况下为 O(n)（当哈希冲突严重或哈希表需要扩展时）。

键的要求:

std::map:

键必须支持 < 运算符（或者提供自定义比较器）。

std::unordered_map:

键必须支持哈希函数（默认使用 std::hash）和相等比较。

使用场景

使用 std::map 的场景:

需要维护一个键的有序集合，方便按顺序遍历。
需要频繁进行范围查询，即查找某一范围内的键（例如，查找键大于某个值的所有键）。
键的顺序非常重要或与其他逻辑相关，例如实现一个优先队列或经典的范围查询。

使用 std::unordered_map 的场景:

在查找、插入或删除操作的性能要求非常高时（尤其是在大量数据时）。
对键的顺序没有要求。
需要快速访问数据，例如常量时间的查找、更新。

示例代码

#include <iostream>  
#include <map>  
#include <unordered_map>  

int main() {  
    // 使用 std::map  
    std::map<int, std::string> ordered_map;  
    ordered_map[3] = "three";  
    ordered_map[1] = "one";  
    ordered_map[2] = "two";  

    // 按照键的顺序输出  
    for (const auto& pair : ordered_map) {  
        std::cout << pair.first << ": " << pair.second << std::endl;  
    }  

    // 使用 std::unordered_map  
    std::unordered_map<int, std::string> unordered_map;  
    unordered_map[3] = "three";  
    unordered_map[1] = "one";  
    unordered_map[2] = "two";  

    // 不确保顺序  
    for (const auto& pair : unordered_map) {  
        std::cout << pair.first << ": " << pair.second << std::endl;  
    }  

    return 0;  
}

总结

选择 std::map 还是 std::unordered_map 取决于具体的需求：

如果需要有序存储并支持范围查询，使用 std::map。
如果对性能和无序性有更高的需求，选择 std::unordered_map。

通过了解这两者的区别，能够更合理地选择合适的数据结构，以满足不同的应用场景需求。

4. C++中list的使用场景

在 C++ 中，std::list 是一个双向链表容器，提供高效的插入和删除操作。以下是 std::list 的一些使用场景及其优势和劣势：

使用场景

频繁的插入和删除操作:

当你需要在序列的中间位置频繁地插入或删除元素时，std::list 比其他容器（如 std::vector 或 std::deque）更高效，因为它只需要更新指针，而不需要移动其余元素。

不需要随机访问:

如果你不需要通过索引访问元素（例如，使用 operator[]），那么使用 std::list 是一个不错的选择。访问元素的效率是 O(n)，所以如果访问次数很少而插入和删除很频繁，使用 std::list 是合适的。

需要稳定的迭代器:

在 std::list 中，迭代器在插入和删除操作后不会失效。这意味着在遍历时可以安全地插入或删除节点，而不会影响其他迭代器。

实现队列和堆栈:

由于 std::list 提供了高效的前端和后端插入/删除功能，因此可以用作队列（FIFO）和堆栈（LIFO）的实现。

优势

高效的插入和删除：

在任意位置进行插入和删除操作的时间复杂度为 O(1)，只需修改指针。

不需要移动元素：

插入和删除操作不会影响其他元素的存储位置，因此在数据频繁变动的情况下性能较好。

劣势

内存开销：

由于每个元素需要存储两个指针（前驱和后驱），std::list 的内存开销相比 std::vector 更大。

随机访问性能差：

访问元素的时间复杂度为 O(n)，因此不适合需要频繁随机访问的应用场景。

示例代码

以下是一个简单的使用 std::list 的示例：

#include <iostream>  
#include <list>  

int main() {  
    std::list<int> myList;  

    // 插入元素  
    myList.push_back(1); // 在末尾插入  
    myList.push_front(0); // 在开头插入  
    myList.insert(++myList.begin(), 2); // 在指定位置插入  

    // 遍历输出  
    std::cout << "List elements: ";  
    for (const auto& elem : myList) {  
        std::cout << elem << " ";  
    }  
    std::cout << std::endl;  

    // 删除元素  
    myList.remove(1); // 删除值为 1 的元素  

    // 再次遍历输出  
    std::cout << "After removal: ";  
    for (const auto& elem : myList) {  
        std::cout << elem << " ";  
    }  
    std::cout << std::endl;  

    return 0;  
}

总结

std::list 适合于频繁进行插入和删除的场合，但不适合频繁需要随机访问的场合。选择合适的容器可以提高程序的性能和效率。

5.C++中为什么要使用std::array?它有什么优点？

std::array 是 C++ 标准库中提供的一种固定大小的数组封装，具有若干优点，使它在某些情况下比传统的C风格数组更具优势：

类型安全：std::array 是一个模板类，它能够确保数组元素的类型得到正确管理，避免类型不匹配的问题。
固定大小：与 C 风格的数组相比，std::array 的大小是在编译时确定的，确保数组大小的一致性和可控性。
封装：std::array 提供了类的方法来处理数组，例如大小获取 (size())、访问元素 (at() 和 operator[])，提升了代码的可读性和可维护性。
与 STL 兼容性：std::array 兼容 C++ 标准模板库的算法，能够直接与 STL 算法一起使用，而 C 风格数组则不具备这种灵活性。
更好的功能：std::array 支持常用的 STL 功能，例如复制、比较、排序等，使其在管理数组时更为方便。
重载的运算符：std::array 支持常用的运算符重载，允许数组对象之间的比较和赋值操作。
避免内存管理问题：使用 std::array 可以减少内存泄露和溢出的风险，因为它是在栈上分配的，不需要手动管理内存。

综上所述，虽然 C 风格的数组在某些性能敏感的场合仍然会被使用，但 std::array 提供的优越性使其在日常开发中成为了更为推荐的选择。

6. C++中的vector的push_back和emplace_back有什么区别？

std::vector 中的 push_back 和 emplace_back 是用于向容器中添加元素的方法，但它们之间有一些重要的区别：

参数传递方式：

push_back：

接受一个已经构造好的对象，并将其拷贝（或移动）到 vector 中。
例如，如果你有一个对象 obj，你可以通过 vector.push_back(obj); 来添加这个对象。

emplace_back：

直接在 vector 的内部构造对象，接受参数并以传递的参数在 vector 中建造新对象。
例如，如果类有一个构造函数，你可以直接调用 vector.emplace_back(arg1, arg2,…);，传递构造新对象所需的参数。

性能：

push_back 可能会涉及到对象的拷贝构造或移动构造，尤其是在对象较大或重载了拷贝构造函数时。
与 push_back 相比，emplace_back 通常更高效，因为它避免了这些额外的拷贝或移动开销。

使用场景：

push_back 更适合已经存在的对象，或者当你希望以特定方式处理对象时。
emplace_back 更适合于直接用构造函数构造对象时，尤其是在操作复杂对象时。

示例：

#include <vector>  
#include <string>  

struct MyStruct {  
    MyStruct(int x, const std::string& str) : a(x), b(str) {}  
    int a;  
    std::string b;  
};  

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

    MyStruct obj(1, "example");  
    
    // 使用 push_back：创建 obj 的拷贝  
    vec.push_back(obj);  

    // 使用 emplace_back：直接在 vec 中构造 MyStruct  
    vec.emplace_back(2, "example2");  

    return 0;  
}

总结：

push_back 是用于添加已存在对象，而 emplace_back 则是在容器内部直接构造对象。
在性能敏感的情景下，尤其是涉及到大型对象或复杂构造时，优先考虑使用 emplace_back。

7.C++迭代器和指针有什么区别？

C++ 中的迭代器和指针有许多相似之处，因为它们都可以用于遍历容器中的元素，但它们之间有一些重要区别：

定义和用途：

指针：

指向内存中的某个地址，可以直接进行算术运算（例如加减）来访问不同的内存位置。
通常用于动态内存分配和管理。

迭代器：

是一个抽象层，用于访问容器（如 std::vector, std::list, std::map 等）中的元素。
提供一种统一的方式来遍历不同的数据结构，而不需要对底层容器的实现细节进行关注。

类型和灵活性：

指针：

指针的类型是固定的，指向特定的数据类型（例如 int*, char*）。
使用时需要关注指针的所有权、生命周期和内存管理。

迭代器：

类型可以根据使用的容器而变化，迭代器可以是随机访问迭代器、双向迭代器、前向迭代器等。
使用迭代器提供了更高的灵活性，可以轻松地在不同类型的容器之间切换而不需要修改代码。

操作和语义：

指针：

支持指针算术运算，例如 ptr + 1 直接跳到下一个元素的地址。
需要手动进行内存管理，如申请和释放内存。

迭代器：

支持与指针类似的操作，但通常采用成员函数和运算符，如 ++iter 以移动到下一个元素。
迭代器通常隐藏具体的实现细节，用户无需考虑底层存储结构。

安全性：

指针：

因为是低级别的内存操作，容易受到悬空指针、内存泄露等问题的影响。

迭代器：

通常提供更高的安全性，尤其是在使用标准库容器时，管理内存和生命周期的问题会被更好地抽象化。

示例：

#include <vector>  
#include <iostream>  

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

    // 使用指针  
    int* ptr = &vec[0];  
    for (size_t i = 0; i < vec.size(); ++i) {  
        std::cout << *(ptr + i) << " "; // 通过指针访问  
    }  
    std::cout << std::endl;  

    // 使用迭代器  
    for (auto it = vec.begin(); it != vec.end(); ++it) {  
        std::cout << *it << " "; // 通过迭代器访问  
    }  
    std::cout << std::endl;  

    return 0;  
}