C++ 常见面试题

面试一

1.  c++结构体的内存对齐是怎么样的

C++结构体的内存对齐是由编译器决定的，对齐的目的是为了提高内存访问的效率。对齐规则可以因编译器和平台而异，但通常遵循以下原则：

1. 字节对齐：结构体的每个成员被放置在内存中的地址必须是其类型大小（以字节为单位）的整数倍。例如，一个int类型通常需要4个字节的对齐。

2. 最大成员对齐：结构体的对齐要求通常取决于最大的成员变量的对齐需求。例如，如果结构体中包含一个成员是double类型（通常需要8个字节的对齐），那么整个结构体往往需要满足8字节对齐。

3. 填充字节：为了满足对齐要求，编译器可能会在成员之间或结构体的末尾插入额外的填充字节。

以下是一个示例结构体和对齐的解释：

c++

插入代码复制代码

struct MyStruct { char a; // 1字节 int b; // 4字节 (按4字节对齐) double c; // 8字节 };

根据对齐规则，a的地址是一个字节对齐的地址，b将从下一个4字节对齐的地址开始存储，而c则需要从下一个8字节对齐的地址开始存储。因此，由于b的对齐需求，编译器会在a后面插入3个填充字节。

请注意，具体的对齐规则可能因编译器和平台而异。为了确保程序的可移植性，在关键的地方最好使用特定对齐方式的修饰符（如alignas）来指定所需的对齐方式。

(1条消息) C/C++---＞结构体内存对齐详解_c++结构体内存对齐_arize的博客-CSDN博客

2. mysql的索引是怎么设计的

        

1. 确定需要索引的列：需要索引的列应该是经常用于查询、连接或排序的列。通常，主键列和外键列都是很好的选择。

2. 考虑索引的类型：MySQL支持多种类型的索引，包括B-tree索引、哈希索引、全文索引等。B-tree索引是最常用的一种类型，适用于大多数查询情况。哈希索引适用于等值比较查询，而全文索引则用于全文搜索。

3. 考虑索引的长度：索引长度应该根据列的数据类型和存储需求来确定。过长的索引可能会浪费存储空间，降低性能。

4. 注意索引的选择性：选择性是指索引中不同值的数量占总记录数的比例。选择性越高，索引越有用。通常情况下，选择性大于10%的索引被认为是高选择性的。

5. 调整索引顺序：对于多列索引，索引列的顺序也很重要。一般来说，将选择性高的列放在索引列的前面可以提高索引效果。

6. 避免过多的索引：过多的索引会增加数据维护的开销，并可能降低插入和更新操作的性能。因此，只建立必要的索引。

3. 有哪些常见的索引失效的场景

1. 数据量过大：当数据量超过索引能够处理的范围时，索引可能会失效。这通常发生在数据表中包含大量记录的情况下。

2. 数据分布不均匀：如果数据在索引列上的分布不均匀，索引的效率可能会下降。例如，如果某个索引列的某些值非常频繁地出现，而其他值很少出现，索引的效果可能会受到影响。

3. 数据更新频繁：当索引列的数据频繁更新时，索引的效率可能会降低。每次更新操作都需要重新构建索引或者更新索引的信息，这可能导致索引失效。

4. 不恰当的索引设计：索引的设计需要根据具体的查询需求来选择合适的索引列。如果索引设计不当，可能会导致索引无法被查询所使用，从而失去了索引的作用。

5. 多列索引的顺序不当：对于使用多列索引的查询，索引列的顺序也非常重要。如果索引列的顺序不符合查询语句的条件顺序，索引可能无法生效。

6. 数据类型不匹配：索引列的数据类型需要与查询条件的数据类型一致，否则索引可能无法被使用

4. c++标准库里优先队列是怎么实现的？

        

C++标准库中的优先队列是通过堆（heap）来实现的。堆是一种特殊的完全二叉树结构，满足堆属性：对于每个节点的值都要大于或小于其子节点的值。

具体来说，优先队列是一个容器，其中的元素按照一定的优先级顺序存储，并且可以以常数时间在队列的开头（具体取决于具体实现）插入元素和删除优先级最高的元素。

在C++标准库中，优先队列是通过std::priority_queue类来实现的。该类位于<queue>头文件中。优先队列默认使用的是std::less作为比较函数，即优先级高的元素具有较小的值。可以通过提供自定义的比较函数来调整优先级的顺序。

实质上，std::priority_queue是通过使用堆作为底层数据结构来提供高效的插入和删除操作。插入操作会使得堆的结构维持不变，而删除操作会将堆的根节点（即具有最高优先级的元素）删除并重新调整堆。

总结来说，C++标准库中的优先队列实现是基于堆结构，并且提供了高效的插入和删除操作，使得元素按照一定的优先级顺序存储和访问

5. 堆排序是怎么做的

堆排序是一种基于完全二叉堆的排序算法。它将待排序的元素构建成一个最大堆或最小堆，然后逐步取出堆顶的元素并重新调整堆，直到所有元素都被取出并按序排列。

以下是堆排序的详细步骤：

1. 构建堆：将待排序的元素依次插入到一个空堆中，可以通过从下至上的方式依次将元素插入，并进行堆调整操作，以保持堆的完全二叉堆性质。这一步将使得堆顶元素成为最大（或最小）值。

2. 取出堆顶元素：将堆顶元素取出，并将其与堆尾元素进行交换。

3. 调整堆：对堆进行调整操作，以再次使其满足最大堆（或最小堆）的性质。这可以通过从上至下的方式进行堆调整操作来完成。

4. 重复步骤2和步骤3，直到所有元素都被取出。每次取出堆顶元素后，堆的大小减一。

5. 最终得到的元素序列即为有序序列。

堆排序的时间复杂度是O(n * log n)，其中n是待排序序列的长度。它是一种原地排序算法，不需要额外的辅助空间，因此空间复杂度为O(1)。由于堆排序的特性，它在大规模数据的排序中表现出良好的性能。

#include <iostream>
#include <set>
#include <map>
#include <list>
#include <vector>
#include <unordered_map>
using namespace std;



 
void heapify(std::vector<int> &arr, int n, int i)
{
    int largest = i;       // 假设根节点是最大值
    int left = 2 * i + 1;  // 左子节点
    int right = 2 * i + 2; // 右子节点

    // 如果左子节点大于根节点
    if (left < n && arr[left] > arr[largest])
        largest = left;

    // 如果右子节点大于根节点
    if (right < n && arr[right] > arr[largest])
        largest = right;

    // 如果根节点不是最大值，则进行交换，并递归地调整子树
    if (largest != i)
    {
        std::swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(std::vector<int> &arr)
{
    int n = arr.size();

    // 构建最大堆，从最后一个非叶子节点开始进行堆化
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    // 逐个取出堆顶元素，放到数组末尾，并进行堆化
    for (int i = n - 1; i > 0; i--)
    {
        std::swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}
void test01()
{
    std::vector<int> arr = {2, 9, 6, 2, 1, 8, 5, 7, 4};

    heapSort(arr);

    // 输出排序后的结果
    for (const auto &num : arr)
    {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

6. 快排是怎么实现的

快速排序（Quicksort）是一种常用的排序算法，它使用分治法（Divide and Conquer）的思想来快速地将一个数组分成两个子数组，并对这两个子数组进行递归排序。以下是快速排序算法的一般实现步骤：

1. 选择基准元素（pivot）：从待排序数组中选择一个元素作为基准元素。通常选择第一个元素、最后一个元素或随机位置的元素作为基准元素。

2. 分区（Partition）：将数组中小于基准元素的元素放在基准元素的左侧，将大于基准元素的元素放在其右侧。同时，基准元素左侧的元素都小于或等于基准元素，基准元素右侧的元素都大于基准元素。分区可以使用双指针法或单指针法来实现。

3. 递归调用：对基准元素左侧和右侧的子数组分别进行递归排序。重复上述分区和递归调用过程，直到每个子数组只包含一个元素或为空。

4. 合并：递归调用结束后，数组已经有序。不需要合并操作，因为在分区过程中已经完成了元素的位置交换。

#include <vector>

// 交换数组中两个元素的位置
void swap(std::vector<int> &arr, int i, int j)
{
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

// 分区函数，基于基准元素将数组划分为左右两个子数组
int partition(std::vector<int> &arr, int low, int high)
{
    // 选择最右边的元素作为基准元素
    int pivot = arr[high];
    int i = low - 1; // 记录小于基准元素的指针

    for (int j = low; j < high; j++)
    {
        // 如果当前元素小于等于基准元素，交换位置并移动指针
        if (arr[j] <= pivot)
        {
            i++;
            swap(arr, i, j);
        }
    }
    // 将基准元素放到最终的位置上
    swap(arr, i + 1, high);

    return i + 1; // 返回基准元素的索引
}

// 快速排序函数
void quickSort(std::vector<int> &arr, int low, int high)
{
    if (low < high)
    {
        int pivotIndex = partition(arr, low, high);
        // 对基准元素左右两侧的子数组递归地进行快速排序
        quickSort(arr, low, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, high);
    }
}

// 接口函数，用于调用快速排序
void quickSortI(std::vector<int> &arr)
{
    int low = 0;
    int high = arr.size() - 1;
    quickSort(arr, low, high);
}

void test01()
{

    std::vector<int> arr = {3, 9, 6, 2, 1, 8, 5, 7, 4};

    quickSortI(arr);

    // 输出排序后的结果
    for (const auto &num : arr)
    {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

7. tcp四次挥手过程

TCP四次挥手是指在TCP连接中，当其中一方想要关闭连接时，需要经过四个步骤来完成连接的关闭。以下是TCP四次挥手的步骤：

1. 第一次挥手（FIN_WAIT_1）：当主动关闭方（称为Client）想要关闭连接时，它发送一个FIN（Finish）报文段给被动关闭方（称为Server）。Client向Server表示它已经完成发送数据的工作，并准备关闭连接。

2. 第二次挥手（CLOSE_WAIT）：被动关闭方（Server）接收到Client发送的FIN报文段后，回复一个ACK（Acknowledgment）报文段给Client，确认收到了FIN报文段。

3. 第三次挥手（LAST_ACK）：被动关闭方（Server）在完成自己的发送后，也向Client发送一个FIN报文段。Server通知Client它也准备关闭连接。

4. 第四次挥手（TIME_WAIT）：Client接收到Server发送的FIN报文段后，回复一个ACK报文段给Server，确认收到了FIN报文段。此时，Client进入TIME_WAIT状态，在这个状态下等待一段时间，确保Server收到了ACK报文段，并且等待一段时间，以处理可能由于网络延迟引起的重复的FIN报文段。

在完成四次挥手之后，连接被完全关闭，并且释放了双方使用的资源。

需要注意的是，四次挥手过程中的报文段交换可能受到网络延迟、丢包和重传等因素的影响，因此在实际应用中需要考虑这些情况，并采取相应的处理机制来确保连接的可靠关闭。

8. 乐观锁怎么实现的

乐观锁是一种并发控制机制，旨在解决多个线程同时访问和修改共享资源时可能发生的冲突问题。它的实现基于以下几个主要的步骤：

1. 版本标记：在数据表中添加一个表示版本号或时间戳的字段，用于标识数据的版本信息。

2. 读取数据：当一个线程想要读取数据时，它会获取当前数据行的版本号，并将其保存在本地。

3. 修改数据：当一个线程想要修改数据时，它首先会读取当前数据行的版本号。然后，线程会进行修改，并尝试将所修改的数据及原有的版本号写回到数据库中。

4. 检查并更新：在写回数据之前，线程会检查数据库中当前数据行的版本号是否与其本地保存的版本号相同。如果相同，说明在读取数据之后没有其他线程对数据进行修改，线程可以安全地更新数据库中的数据，并将版本号加1。如果不同，说明在读取数据之后有其他线程对数据进行了修改，线程需要根据具体情况选择相应的处理方式，如重试操作或者放弃本次修改。

通过将版本号与数据关联在一起，并在数据更新时进行版本号的检查，乐观锁实现了一种乐观的做法，即假设在大多数情况下并发冲突不会发生，以提高并发性能。当发生冲突时，线程会根据实际情况采取相应的处理策略，保证数据的一致性和完整性。

需要注意的是，乐观锁适用于读操作频繁、冲突概率较低的场景，它可以避免了显式的加锁和解锁操作，提高了并发性能。但是，当冲突概率较高时，较多的冲突回滚操作可能会带来一定的性能开销。因此，在使用乐观锁时需要根据具体场景和业务需求进行评估和选择。

9. 常用linux命令

        

以下是一些常用的 Linux 命令：

1. ls - 列出目录内容
2. cd - 切换目录
3. pwd - 显示当前工作目录的路径
4. mkdir - 创建新目录
5. rm - 删除文件或目录
6. cp - 复制文件或目录
7. mv - 移动或重命名文件或目录
8. touch - 创建新文件或更新文件的时间戳
9. cat - 查看文件内容或将多个文件合并成一个
10. grep - 在文件中搜索匹配的字符串
11. find - 在指定目录下查找文件
12. chmod - 修改文件或目录的权限
13. chown - 修改文件或目录的所有者
14. chgrp - 修改文件或目录的所属组
15. tar - 创建、解压或打包文件或目录
16. gzip / gunzip - 压缩或解压文件或目录
17. ssh - 远程登陆到另一台计算机
18. scp - 在本地与远程计算机之间拷贝文件
19. top - 实时显示系统资源使用情况
20. ps - 显示当前运行进程的快照
21. kill - 终止运行的进程
22. df - 显示磁盘空间使用情况
23. du - 估算文件或目录的磁盘使用情况
24. ifconfig - 显示或配置网络接口信息
25. ping - 向另一台计算机发送网络请求以测试连接
26. wget - 下载文件到本地
27. tar - 创建、解压或打包文件或目录
28. uname - 显示当前操作系统的信息
29. man - 显示命令的帮助手册

这些只是一些常用的 Linux 命令，Linux 提供了丰富的命令行工具和选项，可以根据具体需要进行学习和使用。可以通过 man 命令或在互联网上搜索命令名来获取更详细的命令用法和选项说明。

 

字节跳动C/C++方向面经

一面：
      

1.虚拟地址是怎么转化到物理地址的？页表的构成？mmu了解过吗？

        

虚拟地址到物理地址的转化是通过操作系统中的页表机制完成的。页表是一种数据结构，用于将虚拟地址映射到物理地址，以实现虚拟内存管理。

在典型的操作系统中，虚拟地址空间被分为多个固定大小的页（page），每个页的大小通常为4KB或更大。物理内存也被划分为相同大小的物理页框（page frame）。页表记录了每个虚拟页与物理页框之间的映射关系。

虚拟地址到物理地址的转换过程如下：

1. CPU生成的虚拟地址被发送给内存管理单元（MMU）进行转换。

2. MMU从虚拟地址中提取页号，用于查找对应的页表项。

3. MMU使用页表项中的页框号替换虚拟地址的页号部分，生成一个新的物理地址。

4. MMU将新的物理地址提供给内存系统，进行实际的内存访问操作。

页表的构成可以分为多级页表或者单级页表两种形式。

多级页表是指将页表分为多个级别结构，以减小页表的大小。典型的多级页表结构包括两级或三级页表。例如，x86架构中的两级页表结构包括页目录表（Page Directory）和页表（Page Table）。

单级页表即为单级结构，将所有的页表项存储在一个大的页表中。

在页表中，每个页表项记录了虚拟页和物理页框之间的映射关系，可能包含一些附加信息。例如，标志位可以用于记录权限、脏位（dirty bit）用于表示页面是否被修改过、访问位（access bit）用于表示页面是否被访问过等。

MMU（Memory Management Unit）是位于CPU中的硬件或虚拟主机中的软件，负责虚拟地址到物理地址的转换。MMU通过访问页表来完成地址转换，并处理页面访问权限、页面替换等一些与内存管理相关的操作。

MMU在虚拟地址到物理地址的转换过程中，起着关键的作用，能够保证访问虚拟内存的透明性，使得操作系统能够管理更大的虚拟地址空间，并提供灵活的虚拟内存管理功能。

      2.操作系统中的原子操作是怎么实现的？

在操作系统中，原子操作是指不可中断的、不可分割的基本操作。它们具有以下特点：在执行过程中无法被其他操作中断或共享资源的竞争，并且要么完全执行，要么完全不执行。

原子操作的实现常常依赖于硬件的支持和操作系统提供的机制。以下是几种常见的实现方式：

1. 硬件原子指令：一些处理器提供了硬件级别的原子操作指令，例如比较交换（Compare-and-Swap）指令。这些指令可以在一个原子操作中完成读取-修改-写入的操作，确保在多线程环境下的原子性。

2. 中断禁用：操作系统可以通过禁用中断来保证某段代码的原子性。禁用中断会阻止处理器响应任何中断请求，从而保证当前代码的执行不会被其他中断干扰。然而，这种方式会带来一定的副作用，如可能影响系统的响应性和并发性。

3. 锁机制：操作系统提供了互斥锁（Mutex）等同步机制来保证临界区的原子性。线程在进入临界区之前先尝试获取锁，如果锁已经被其他线程持有，则线程进入等待状态，直到锁可用的正确性和一致性。具体选择哪种方式取决于特定的场景和需求，需要根据实际情况进行权衡和选择。这种方式通常会使用原子指令来实现锁的获取和释放操作。

4. 原子操作库：操作系统提供了一系列原子操作函数或库，这些函数通过一些特殊的技术或锁机制来保证原子性。例如，使用内存屏障（Memory Barrier）、自旋锁（Spinlock）等。

以上提到的方法都可以通过操作系统的底层机制来实现原子操作，确保对共享资源的访问和修改在并发环境中

      3.C++中的内存分区？bss段了解过吗？未初始化的全局变量和初始化的全局变量放在哪里？

在C++中，内存分为几个不同的区域，包括：

1. 栈（Stack）：用于存储局部变量和函数调用的上下文信息。栈上的数据的生命周期是自动的，当其作用域结束时，会自动释放。

2. 堆（Heap）：用于动态分配内存，通过new/delete或malloc/free来管理。在堆上分配的内存的生命周期需要手动管理，需要显式地释放分配的内存。

3. 全局区（Global/static data）：用于存储全局变量和静态变量。全局区在程序启动时被分配，在程序结束时释放。全局变量和静态变量的生命周期与程序的执行周期相关。

4. 常量区（Read-only data）：用于存储常量数据，如字符串常量等。该区域的数据只能读取，不能写入。

5. 代码区（Code/text）：用于存储可执行程序的指令代码。该区域是只读的，存储着程序的指令集。

bss（Block Started by Symbol）段是位于可执行文件中的一块特殊的内存区域，用于存储未初始化的全局变量和静态变量。bss段在程序加载时会得到自动初始化的值（通常为0）。由于未初始化的全局变量和静态变量没有显式的初始值，因此可以在可执行文件中通过bss段来节约空间。

初始化的全局变量和静态变量会存储在全局区。这些变量在程序加载时会得到初始值，并在整个程序的执行过程中保持可见。它们的内存分配和释放由操作系统负责。

需要注意的是，对于局部变量来说，如果其存储在栈上，则其生命周期与其所在的作用域有关；如果其存储在堆上，则需要手动管理其生命周期，包括分配和释放的操作。

      4.内存对齐?为什么字节对齐

内存对齐是指将变量存储在内存中时，按照一定规则将其地址对齐到特定的边界。具体而言，内存对齐要求变量的地址是某个特定值的倍数。

字节对齐是为了优化内存访问的效率。许多计算机体系结构在处理未对齐的内存访问时会引入额外的开销，例如性能下降或者内存访问出错。这是因为在这些架构中，处理器一次读取内存的数据宽度通常是固定的，如果访问的数据没有按照所需的对齐方式存储，就会需要多次内存访问，增加了访问内存的开销。

举个例子，假设一个整型变量需要4字节对齐。如果该变量被存储在地址0x100处，它是按照对齐方式存储的。但如果它被存储在地址0x101处，则需要两次内存访问才能完全读取或写入该变量的值。因此，通过内存对齐，可以减少内存访问次数，提高程序的执行效率。

编译器会在编译时自动进行对齐操作，保证变量按照特定的对齐要求进行存储。对齐规则可能因编译器、体系结构和操作系统而异。一般来说，基本类型的对齐要求为其自身大小，例如一个4字节的整型变量需要4字节对齐。

此外，为了进一步优化内存访问，有些编译器还提供了对齐属性（alignment attribute），允许程序员显式地指定变量的对齐方式。

总结起来，字节对齐是为了提高内存访问效率，避免未对齐访问导致的额外开销。编译器会自动进行对齐操作，而程序员也可以利用对齐属性来显式指定变量的对齐方式。

      5.vector中push_back和emplace_back的区别？

在C++中，vector是一种动态数组（动态连续内存空间）容器，提供了高效的随机访问和动态添加元素的功能。push_back和emplace_back都用于向vector容器中添加元素，但它们有一些区别。

1. push_back：

   • push_back接受一个参数，该参数会被拷贝（复制）到容器中。
   • 它会先构造一个临时对象，然后将这个对象的副本插入到vector的末尾。
   • 如果插入的是已经存在的对象，则需要进行拷贝构造。

2. emplace_back：

   • emplace_back接受可变数量的参数或一个初始化列表，用于构造元素。
   • 它会直接在容器的末尾创建一个元素，避免了额外的拷贝（复制）操作。
   • 它会使用传递的参数直接在容器的内存空间中构造对象，避免了临时对象的创建和拷贝构造的开销。
   • emplace_back对于大型对象或者有显著的移动语义的对象，可以比push_back更高效。

总结起来，push_back用于将已有对象复制到容器中，而emplace_back用于在容器的末尾直接构造新的对象，避免了额外的拷贝操作。emplace_back对于构造开销较大的对象，或涉及移动语义的情况，可以提供更好的性能。

      6.C++中的多态？说一下虚函数的多态？

在C++中，多态是面向对象编程中的一个重要概念，它允许通过基类的指针或引用调用派生类的方法。多态能够实现运行时的动态绑定，使得程序可以根据实际对象的类型来决定调用哪个函数。

虚函数是实现多态的一种机制。在C++中，通过在基类中将成员函数声明为虚函数，并在派生类中对其进行重写，就能够实现动态调用不同类的相同函数。

使用虚函数实现多态的步骤如下：

1. 在基类中声明虚函数。使用关键字virtual将成员函数声明为虚函数，比如：virtual void func();。

2. 在派生类中重写虚函数。派生类中对基类的虚函数进行重写，即提供相同的函数签名和返回类型，以确保函数的兼容性和可替换性。

3. 使用指向基类的指针或引用调用虚函数。通过指向基类的指针或引用，可以调用实际对象的派生类的重写函数。在运行时，根据指针或引用指向的对象的类型，动态地选择执行相应的函数实现。

虚函数的多态机制能够通过对象的实际类型来确定函数的实现，而不是通过指针或引用的类型来确定。这种动态绑定的特性使得在继承关系中可以实现更灵活和可扩展的代码结构，允许以一致的方式处理不同派生类的对象。

需要注意的是，为了确保虚函数机制正常工作，通常将基类的析构函数声明为虚函数。这样，在通过基类指针或引用删除派生类对象时，能够正确调用派生类的析构函数，确保释放对象的资源。

      7.内联函数？内联函数的缺点？

内联函数是在C++中的一种优化机制，用于在编译时将函数的定义直接插入到调用处，而不是通过函数调用的方式进行函数体的执行。这样可以减少函数调用的开销，提高程序的执行效率。

内联函数的特点和使用方式如下：

1. 内联函数的定义通常放在头文件中，以便在每个使用它的源文件中都可以展开函数的定义。

2. 使用关键字inline来声明内联函数。例如：inline int add(int a, int b) { return a + b; }。

3. 内联函数的调用与普通函数调用方式相同，没有额外的开销。编译器将内联函数的函数体插入到函数调用的地方，作为一段内联代码。

内联函数的优点包括：

1. 减少函数调用的开销：函数调用涉及栈帧的创建、参数的传递以及跳转指令的执行等操作，通过将函数体直接插入调用处，可以消除这些开销。

2. 提高执行速度：内联函数的展开能够直接将函数体插入调用处，减少了函数调用的开销，从而提高了程序的执行速度。

然而，内联函数也存在一些缺点：

1. 增大编译后的代码体积：每个使用内联函数的地方都会复制函数的代码，如果函数体较大或被频繁调用，会增加可执行文件的大小。

2. 编译时间增加：内联函数需要在每个调用处进行展开，如果函数体较大或被频繁调用，会增加编译时间。

3. 可能导致缓存失效：如果内联函数很大，可能会导致代码在缓存中无法全部保存，从而引起缓存失效，影响程序的执行效率。

因此，在使用内联函数时需要谨慎权衡，仅在需要提高性能的场景下使用，避免滥用。编译器也会根据实际情况自动决定是否进行函数内联。

      8.tcp的可靠传输？拥塞控制？流量控制？

TCP（传输控制协议）是一种面向连接的、可靠的传输协议。TCP的可靠传输、拥塞控制和流量控制是其关键的特性之一。

1. 可靠传输：TCP通过采用以下机制来实现可靠传输：

   • 序列号和确认：TCP将每个传输的数据字节进行编号，接收方通过发送确认消息来确认已经接收到的数据，发送方需要等待确认后才会发送下一段数据。
   • 超时重传：如果发送方在超时时间内没有接收到对应的确认消息，它会假设数据丢失并重新发送该数据。
   • 流量控制窗口：接收方可以通过调整通知发送方的窗口大小来控制发送方的发送速率，确保接收方的处理能够跟得上发送方的速度。

2. 拥塞控制：TCP的拥塞控制机制用于控制网络中的数据拥塞，以避免网络传输过载。主要的拥塞控制算法包括：

   • 慢开始：初始时，发送方以较慢的速度递增发送窗口的大小，不超过网络的容量。
   • 拥塞避免：当发送方的拥塞窗口达到一定阈值时，发送方以较慢的速度递增发送窗口的大小，以平稳地逼近网络容量。
   • 快重传和快恢复：如果发送方收到相同序列号的冗余确认，它会认为有数据丢失，立即进行重传并减少拥塞窗口的大小。

3. 流量控制：TCP的流量控制机制用于协调发送方和接收方之间的传输速率，以避免接收方被过多的数据淹没。流量控制基于接收方通告的窗口大小，发送方需要根据接收方的窗口大小来调整发送速率。

综上所述，TCP通过可靠传输、拥塞控制和流量控制机制，实现了高效而可靠的数据传输，能够适应不同网络环境和传输需求。

      9.IP数据报的报头字段？TTL的设置了解过吗？

IP（Internet Protocol）数据报是在网络中传输的数据单元，它包含了源地址、目的地址以及其他一些控制和管理信息。IP数据报的报头字段是指IP数据包头部中的各个字段，包括如下内容：

1. 版本（Version）：用于指示IP协议的版本，一般是IPv4或IPv6。

2. 首部长度（Header Length）：指示IP头部的长度，以4字节为单位。

3. 服务类型（Type of Service）：用于指定数据包的服务类型、优先级、处理方式等特性。

4. 总长度（Total Length）：指示整个IP数据包的总长度，包括头部和数据部分，以字节为单位。

5. 标识（Identification）：用于标识该数据报的唯一标识符，通常与分片处理有关。

6. 标志（Flags）：包含分片标志，用于指示数据报是否被分片以及如何重组。

7. 片偏移（Fragment Offset）：用于标识该片段在原始数据报中的位置。

8. 生存时间（Time to Live，TTL）：表示数据报在网络中存活的最长时间（以秒为单位），以防止数据报在网络中无限循环。

9. 协议（Protocol）：指示上层协议，例如TCP、UDP或ICMP等。

10. 头部校验和（Header Checksum）：用于检测IP头部数据的传输错误。

11. 源地址（Source Address）：指示IP数据包的源IP地址。

12. 目的地址（Destination Address）：指示IP数据包的目标IP地址。

TTL是IP数据报中的一个字段，用于设置数据报在网络中的生存时间。TTL的主要目的是限制数据报在网络中存活的时间，防止因路由环路或其他原因导致的数据包无限循环。每经过一个路由器，TTL的值就会减少1，当TTL值减为0时，数据报会被丢弃，并发送一个ICMP超时消息给数据报的源地址，告知数据报的丢失。

通过设置适当的TTL值，可以限制数据报在网络中传播的跳数，保证网络资源的有效利用和避免网络拥堵。通常情况下，TTL的初始值由操作系统或应用程序设置，默认为一个较小的固定值，例如64或128。

      10.怎么实现断点续传？

实现断点续传的关键是将文件分成多个块，并记录已成功传输的部分。下面是一种基本的实现方式：

1. 将文件分成固定大小的块：将要传输的文件分成固定大小的块。块的大小可以根据实际需求确定，一般为几KB或几MB。

2. 传输和保存已传输的块：在传输过程中，将每个传输成功的块保存在接收端（例如服务器）和发送端（例如客户端）的存储介质中（例如硬盘或内存）。

3. 记录已传输的块信息：每个块传输完成后，在接收端和发送端分别记录该块的偏移量或编号等信息，用于恢复和继续传输。

4. 断点续传时的传输逻辑：当传输中断或终止后，下次继续传输时，根据记录的已传输块信息，可以跳过已传输的块，仅传输未传输的块。这样可以节省时间和网络流量。

5. 传输校验和实现数据完整性：为了保证数据的完整性，在传输过程中可以使用校验和机制，例如计算每个块的校验和并与发送端进行验证。

需要注意的是，实现断点续传时需要考虑以下因素：

• 文件的分块大小：需要权衡块的大小，以避免每个块的传输时间过长或过短，影响传输效率。
• 传输的顺序：需要确定分块的顺序，并在继续传输时按照相应的顺序进行传输。
• 传输的可靠性：需要处理传输中的错误和异常情况，例如网络中断、超时等，以确保数据的可靠传输。
• 数据的重组：接收端需要根据块的偏移量或编号等信息，将接收到的块按照正确的顺序进行重组，以还原原始文件。

断点续传的具体实现方式会因应用场景和需求而有所差异，上述步骤提供了一种基本框架，可以根据实际情况进行调整和扩展。

      11.算法题：最长回文子串

见leetcode 05

二面：
      1.介绍一下项目？

      2.http状态码有哪些？

        

HTTP（Hypertext Transfer Protocol）状态码用于表示服务器对请求的处理结果。以下是常见的HTTP状态码及其对应的含义：

• 1xx（Informational 信息性状态码）：指示请求已被接收并正在处理。

  • 100 Continue：请求已成功接收到，客户端应该继续发送请求的剩余部分。
  • 101 Switching Protocols：服务器将切换到客户端请求的新协议。

• 2xx（Successful 成功状态码）：指示请求已成功处理。

  • 200 OK：请求成功，返回对应的资源。
  • 201 Created：请求已成功处理，并且已创建了新的资源。
  • 204 No Content：请求已成功处理，但没有需要返回的内容。

• 3xx（Redirection 重定向状态码）：指示需要客户端采取进一步的操作，以完成请求。

  • 301 Moved Permanently：请求的资源已永久性移动到新位置。
  • 302 Found：请求的资源临时移动到新位置。
  • 304 Not Modified：客户端的缓存副本是最新的，可以直接使用缓存的版本。

• 4xx（Client Error 客户端错误状态码）：指示客户端的请求有错误。

  • 400 Bad Request：请求有语法错误，服务器无法理解。
  • 401 Unauthorized：请求需要身份验证。
  • 403 Forbidden：服务器理解请求，但拒绝执行。
  • 404 Not Found：请求的资源不存在。

• 5xx（Server Error 服务器错误状态码）：指示服务器在处理请求时发生错误。

  • 500 Internal Server Error：服务器内部错误，无法完成请求。
  • 502 Bad Gateway：服务器作为网关或代理，从上游服务器接收到无效的响应。
  • 503 Service Unavailable：服务器当前无法处理请求，处于临时过载或维护状态。

还有其他一些状态码，每个状态码都有特定的含义，用于标识请求和响应的处理过程。根据实际情况，选择适当的状态码可以提供有用的信息和反馈给客户端。

      3.http1.0，2.0版本的区别？

        

HTTP/1.0和HTTP/2.0是不同版本的HTTP协议，它们在性能、功能和传输方式等方面有一些明显的区别。

1. 性能方面的区别：

   • 多路复用：HTTP/1.0使用串行的方式发送请求和响应，即每个请求需要等待前一个请求的响应完成后才能发送，而HTTP/2.0引入了多路复用的机制，可以同时发送多个请求和响应，提高了传输效率。
   • 头部压缩：HTTP/1.0的请求和响应中的头部信息没有进行压缩，而HTTP/2.0使用了帧和首部表等机制来对头部信息进行压缩，减少了传输的字节数。
   • 服务器推送：HTTP/2.0支持服务器主动推送资源，当客户端请求一个资源时，服务器可以将一些相关资源主动推送给客户端，减少了客户端的请求次数。

2. 功能方面的区别：

   • 请求优先级：HTTP/2.0引入了优先级和流的概念，可以为不同的请求设置优先级，确保重要请求的优先处理。
   • 流控制：HTTP/2.0支持流量控制，可以根据接收端的处理能力和网络状况动态调整数据的传输速率，避免了数据拥塞。
   • 服务器推送：HTTP/2.0允许服务器在客户端请求之前主动将相关资源推送给客户端，提高了效率。

3. 传输方式方面的区别：

   • HTTP/1.0使用明文方式进行传输，安全性有限。而HTTP/2.0可以通过TLS（Transport Layer Security）协议进行加密，提供更安全的传输方式。

总而言之，HTTP/2.0相对于HTTP/1.0在性能和功能上有显著改进，主要通过多路复用、头部压缩、服务器推送等机制提高了传输效率和用户体验。它更适合于现代网络环境和复杂的Web应用程序

      4.在游览器输入URL之后，具体流程是什么？

当在浏览器输入URL后，以下是一般的流程：

1. URL解析：浏览器会解析输入的URL，将其分为不同的组成部分，包括协议、主机名、路径和查询参数等。

2. DNS解析：浏览器会通过域名系统（DNS）将主机名解析为IP地址。首先，浏览器会检查浏览器缓存中是否已解析该主机名。如果没有，它将向本地操作系统的DNS缓存发出请求。如果仍然未找到，则浏览器将向域名服务器发送DNS解析请求。

3. 建立连接：浏览器与服务器之间建立TCP连接。浏览器将使用解析得到的IP地址和端口号与服务器建立连接。这通常涉及三次握手过程，确保连接的稳定性。

4. 发起HTTP请求：一旦建立了TCP连接，浏览器就会向服务器发送HTTP请求。请求中包含请求方法（例如GET、POST）、路径、头部信息（例如用户代理、Cookie等）和请求主体（对于POST请求）等。

5. 服务器处理请求：服务器收到HTTP请求后，会根据请求的特定路径和方法来处理请求。这可能涉及查询数据库、处理逻辑或获取文件等。

6. 服务器发送响应：服务器根据请求处理的结果生成HTTP响应。响应包括状态码（表示请求的处理结果）、头部信息（例如内容类型、内容长度）和响应主体（响应的具体内容）等。

7. 接收和渲染响应：浏览器接收到服务器的响应后，会根据响应的内容类型进行相应的处理。例如，对于HTML响应，浏览器会解析HTML文档，并根据HTML、CSS和JavaScript来渲染页面。

8. 关闭连接：一旦响应被完全接收和处理，浏览器会关闭与服务器的TCP连接。但它可能会在同个域名下的请求之间保持持久连接，以提高性能。

这是一个简化的描述，实际的流程可能会有更多的细节和步骤。但总体而言，这个流程涉及了URL解析、DNS解析、建立连接、发送请求、处理响应和渲染页面等关键步骤。

      5.说一下事务？说一下隔离性？

        

事务是指作为单个逻辑工作单元执行的一系列操作的集合。事务具有以下四个特性（通常称为ACID特性）：

1. 原子性（Atomicity）：事务被视为一个原子操作，要么全部执行成功，要么全部回滚。如果事务中的任何一步操作失败，那么整个事务都会被回滚到初始状态，不会对数据库产生影响。

2. 一致性（Consistency）：事务的执行应使数据库从一个一致状态转变为另一个一致状态。这意味着事务中的操作必须遵守预定义的完整性约束和规则，以确保数据的有效性与完整性。

3. 隔离性（Isolation）：事务的执行应该与其他并发执行的事务相互隔离，以避免并发访问数据时出现不一致的结果。事务应该具有隔离性，使得在并发执行时，每个事务看到的数据库状态都是一致的，并且不会受到其他事务的干扰。

4. 持久性（Durability）：一旦事务提交，其对数据库的修改应该永久保存，即使在数据库系统发生故障的情况下也是如此。持久性保证了事务提交后的数据是持久性的，并且不会丢失。

隔离性是事务的重要特性之一，它确保事务在并发执行时保持相互隔离，以防止数据的不一致和冲突。在数据库中，隔离级别规定了事务之间的隔离程度，有以下四个标准的隔离级别：

1. 读未提交（Read Uncommitted）：最低级别的隔离性，事务可以读取到其他事务未提交的数据，会发生脏读（Dirty Read）问题。

2. 读已提交（Read Committed）：事务在读取数据时，只能看到已经提交的数据，避免了脏读问题。但可能会出现不可重复读（Non-repeatable Read）问题。

3. 可重复读（Repeatable Read）：事务在执行过程中多次读取同一数据时，能保证所读数据一致，避免了不可重复读问题。但可能会出现幻读（Phantom Read）问题。

4. 串行化（Serializable）：最高级别的隔离性，事务串行执行，保证了最高的数据一致性，但并发性能较低。

隔离性级别的选择应根据应用的需求和并发访问的特性来确定。较低的隔离级别可以提供更好的并发性能，但可能导致数据的不一致性。较高的隔离级别可以确保数据的一致性，但可能影响并发性能。

      6.进程间通信？说一下原理?共享内存是如何确定物理地址的？

进程间通信（Inter-Process Communication，IPC）是指不同进程之间进行数据交换和共享资源的机制。常用的进程间通信方式包括管道、消息队列、共享内存和Socket等。

共享内存是一种高效的进程间通信方式，它允许多个进程直接访问同一块内存区域，从而避免了复制数据的开销。以下是共享内存的基本工作原理：

1. 创建共享内存区域：一个进程创建一个共享内存区域，并将其与一个唯一的标识符相关联。通常使用操作系统提供的函数（如shmget()）来创建共享内存区域。

2. 连接共享内存区域：其他进程需要访问共享内存时，需要通过标识符连接到共享内存区域。使用函数（如shmat()）将共享内存映射到进程的地址空间中。

3. 写入和读取：一旦多个进程都连接到了共享内存区域，它们可以直接读取和写入内存区域中的数据。由于所有进程都共享同一份内存，因此对共享内存中的数据的读写是实时可见的。

4. 分离共享内存区域：当进程完成对共享内存的访问后，需要通过函数（如shmdt()）将共享内存从进程的地址空间中分离。

至于共享内存如何确定物理地址，这是由操作系统内核来管理和决定的。操作系统会为共享内存区域分配一块物理内存，并将其映射到各个进程的虚拟地址空间中。虚拟地址与物理地址之间的映射通过页表来实现，页表记录了虚拟地址与物理地址之间的对应关系。当进程访问共享内存时，CPU将根据页表将虚拟地址转换为相应的物理地址，从而进行实际的内存访问操作。

总结起来，共享内存通过操作系统提供的接口实现多个进程之间直接访问同一块内存区域。操作系统负责管理和映射这块共享内存区域的物理地址到各个进程的虚拟地址空间，使得不同进程可以实时共享数据。

      7.纯虚函数？使用场景有哪些？

纯虚函数（Pure Virtual Function）是在基类中声明但没有具体实现的虚函数。它的声明形式为 virtual void functionName() = 0;。纯虚函数在基类中用于定义接口规范，要求派生类必须实现该函数。

使用纯虚函数的场景包括：

1. 抽象类（Abstract Class）：纯虚函数使得基类成为抽象类，因为它们不可实例化。抽象类通常用于定义一个接口规范，规定派生类必须实现一组特定的函数。

2. 接口定义：纯虚函数用于定义接口，它提供了一组特定的功能和行为，需要不同的类根据自身的需求来实现这些功能。

3. 多态性的实现：通过基类指针或引用调用纯虚函数，可以实现多态性的效果。不同派生类的实现会根据自己的特性和行为来重写纯虚函数，从而实现不同的功能。

4. 工厂模式（Factory Pattern）：在工厂模式中，基类通常定义一个纯虚函数作为工厂方法，由派生类实现该方法以创建具体的对象。

5. 回调机制：纯虚函数可以用于实现回调机制，基类定义一个纯虚函数（回调函数），派生类通过实现这个纯虚函数来提供自己的回调逻辑。

总之，纯虚函数提供了一种在基类中定义接口规范的方式，要求派生类必须实现它们。通过使用纯虚函数，可以实现多态性、接口定义、工厂模式、回调机制等功能，使得代码更加灵活和可扩展。

      8.为什么一般将析构函数设置为虚函数？

        

一般情况下，将析构函数设置为虚函数是为了支持多态性和确保正确释放资源。以下是设置析构函数为虚函数的原因：

1. 多态性（Polymorphism）：如果有一个基类指针指向一个派生类对象，而析构函数不是虚函数，当使用基类指针进行删除时，只会调用基类的析构函数而不会调用派生类的析构函数。这会导致派生类中析构函数的特定清理代码不被执行，可能导致资源泄露或不正确的对象析构。通过将析构函数声明为虚函数，可以确保在删除对象时，会正确调用相应的派生类析构函数。

2. 基类指针的删除：使用基类指针指向派生类对象，并在需要时使用delete删除该对象。如果析构函数不是虚函数，则会导致只调用基类析构函数，派生类的析构函数不会被调用，这可能会导致派生类对象的内存泄漏。

3. 多继承情况下的析构函数调用：当一个类同时继承自多个基类时，如果这些基类的析构函数不是虚函数，通过派生类指针只能正确调用派生类和其中一个基类的析构函数，而无法调用其他基类的析构函数。

总之，将析构函数声明为虚函数可以保证在使用基类指针删除派生类对象时，会正确调用派生类的析构函数，确保资源正确释放。这是面向对象编程中保证多态性和正确释放资源的重要机制。

      9.C++11中的auto是怎么实现识别自动类型的？模板是怎么实现转化成不同类型的？

在C++11中，auto关键字用于让编译器根据初始化表达式的类型自动推导变量的类型。当使用auto声明变量时，编译器会根据初始化表达式的类型进行类型推导，并将其作为变量的类型。

auto的类型推导规则如下：

1. 对于具有明确类型的初始化表达式，编译器将推导出与初始化表达式类型相同的变量类型。

2. 对于使用初始化列表或表达式的初始化表达式，编译器将根据初始化表达式的结果类型进行推导。如果初始化表达式是个右值引用，则推导结果也是右值引用。

3. 对于函数返回值的类型推导，可以使用auto来推导函数返回值类型，编译器将根据函数返回语句中的表达式类型进行推导。

模板是通过类型参数化的方式实现将代码转化成不同类型的。模板机制允许开发人员编写通用的代码，其中的类型参数可以替换为具体的类型。当使用模板生成实际的代码时，编译器会根据使用的具体类型进行模板实例化。

模板的转化成不同类型的过程如下：

1. 模板定义：首先，开发人员编写一个模板定义，其中包含了一个或多个类型参数。

2. 模板实例化：当需要使用模板时，将会实例化它，将具体的类型传递给类型参数，用以替代模板中的类型参数。

3. 编译器生成代码：编译器根据传递的具体类型，将进行模板实例化，并生成相应的代码。

4. 编译和链接：将模板实例化生成的代码编译成二进制文件，并在链接阶段将多个编译单元中的模板实例化代码进行合并。

总结起来，auto关键字通过编译器根据初始化表达式类型进行自动推导变量类型。而模板机制通过参数化类型的方式，在编译时将通用代码转化成具体类型的代码。这两个特性使得C++语言更加灵活和通用。

      10.编程题：三个线程，依次打印1-100

        

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
int current = 0;
const int target = 100;
int numThreads = 3;

void printNumber(int threadId, int number)
{
    std::cout << "Thread " << threadId << ": " << number << std::endl;
}

void worker(int threadId)
{
    std::unique_lock<std::mutex> lock(mtx);

    while (current <= target)
    {
        if (current % numThreads == threadId)
        {
            printNumber(threadId, current);
            current++;
            cv.notify_all();
        }
        else
        {
            cv.wait(lock);
        }
    }
}

int main()
{
    std::thread threads[numThreads];

    for (int i = 0; i < numThreads; ++i)
    {
        // threads[i] = std::thread(worker, i);
        //这里的i是worker 的参数列表
        threads[i] = std::thread(worker, i);
    }
    // threads[0].join();
    std::cout << "Hello1111" << std::endl;

    // for (int i = 0; i < numThreads; ++i)
    // {
    //     threads[i].join();
    // }
    system("pause");
    return 0;
}

程序中使用了一个互斥锁（std::mutex）和一个条件变量（std::condition_variable）来实现线程同步操作。

在printNumbers函数中，每个线程都会进入循环，当当前要打印的数字满足线程id的条件时，打印数字并通知其他线程。否则，当前线程等待，直到被唤醒。

在main函数中，创建了三个线程并启动它们。最后，使用join函数等待三个线程完成。运行程序将按顺序打印1到100，其中每个线程依次打印了符合条件的数字。

      11.编程题：输出字符串的全排列

见leetcode 46

三面：
      1.介绍项目？

      2.职业规划是什么？

      3.为什么想从事客户端开发？

      4.大学期间学习路径是什么，怎么学习的？

      5.项目过程中遇到过什么困难？

      6.哪一个项目对你学习帮助最大？

      7.项目有应用层的设计吗？
 

      8.编程题：k个一组，反转链表

        见leetcode.25