Colin’s Blog

A C++ Programmer

面试常见问题 1

部分内容为GPT的回答。

和红黑树的功能类似的还有哪些数据结构

红黑树是一种自平衡的二叉搜索树，它通过特定的属性和操作保持树的平衡，从而实现在最坏情况下仍能保持对数级别的查找、插入和删除时间复杂度。和红黑树提供相似功能的数据结构主要包括其他类型的自平衡二叉搜索树和一些特殊的数据结构，它们都能提供高效的查找、插入和删除操作。下面列出一些常见的例子：

AVL树

AVL树是最早被发明的自平衡二叉搜索树之一。它严格保持二叉树的平衡，即任何节点的两个子树的高度最大差为1。这种严格的平衡要求使得AVL树在查找操作中表现得非常好，但在频繁的插入和删除操作中可能会有较多的旋转调整，相比于红黑树可能略显低效。

B树及其变种

B树是一种平衡的多路搜索树，主要用于数据库和文件系统。B树通过将节点中存储多个元素并允许节点有多个子节点来减少树的高度，从而优化磁盘读写操作。B+树和B*树是B树的变种，它们在B树的基础上做了进一步的优化，广泛应用于数据库索引。

Splay树

Splay树是一种自调整的二叉搜索树，它通过一种称为“伸展”的操作来保证最近进行的操作可以在较快的时间内完成。伸展树不保证树的严格平衡，但它能保证分摊的时间复杂度为O(log n)。

Treap

Treap是一种结合了二叉搜索树和堆的数据结构，节点既按键排序又按优先级堆组织。它利用旋转操作来维持二叉搜索树的性质和堆的性质，实现了平衡树的效果。

Skip List

跳跃表是一种概率性的数据结构，通过在多层链表上添加“快速通道”来实现快速查找。虽然不是树结构，跳跃表在功能上与红黑树相似，提供了高效的查找、插入和删除操作，其平均时间和空间复杂度都是O(log n)。跳跃表的实现相比于红黑树和AVL树更为简单，易于理解和实现。

AA树

AA树是一种变种的红黑树，它简化了红黑树的平衡规则和旋转操作。通过限制只有右链接可以是红色，AA树使得实现变得更加简单，同时保持了与红黑树相似的操作性能。

这些数据结构各有特点，适用于不同的场景。选择合适的数据结构需要根据实际的应用场景和性能要求来决定。

五千万个整数求和，尽量降低时间消耗。怎么做？

对于五千万个整数求和的问题，主要目标是优化时间复杂度和减少执行时间。以下是一些优化策略，可以帮助提高求和操作的效率：

1. 使用有效的数据结构

  • 确保整数存储在连续的内存空间中，比如使用数组或列表，这样可以减少内存访问的开销。

2. 循环优化

  • 尽可能使用高效的循环结构，减少循环内不必要的计算和条件判断。

3. 多线程或并行计算

  • 利用现代计算机多核心的优势，可以将五千万个整数分成几个部分，每个核心处理一部分数据，然后将结果汇总。这种方式可以大大减少总的计算时间。
  • 使用如OpenMP、Intel TBB（Thread Building Blocks）、Python的concurrent.futures模块或Java的java.util.concurrent包等并行框架和库来简化多线程编程的复杂性。

4. 向量化运算

  • 在支持向量化的编程语言中（如使用NumPy库的Python），可以利用向量化运算来提高性能，因为这些运算是在底层进行优化的。

5. 减少函数调用

  • 在求和过程中尽量减少函数调用，比如避免在循环中调用函数，因为函数调用会增加额外的时间开销。

实践示例（Python 并行计算）

这里是一个使用Python的concurrent.futures模块进行并行计算求和的简单例子：

 1import concurrent.futures
 2import numpy as np
 3
 4def parallel_sum(arr, n_workers=4):
 5    # 分割数组为多个子数组
 6    chunk_size = len(arr) // n_workers
 7    futures = []
 8    with concurrent.futures.ThreadPoolExecutor(max_workers=n_workers) as executor:
 9        for i in range(n_workers):
10            chunk = arr[i*chunk_size : (i+1)*chunk_size]
11            futures.append(executor.submit(np.sum, chunk))
12    
13    # 收集结果
14    result = sum(f.result() for f in futures)
15    return result
16
17# 生成五千万个整数的数组
18arr = np.random.randint(1, 100, 50000000)
19result = parallel_sum(arr)
20print(result)

这个例子展示了如何使用Python的并发特性和NumPy库来提高求和操作的效率。通过将数据分割成多个块并并行计算每个块的和，然后再将这些和加起来，可以显著减少计算所需的时间。注意，实际效果会根据你的硬件配置、Python版本和其他因素而有所不同。

static关键字在C++中的作用

在C++中，static关键字有几个不同的用途，根据其应用的上下文，它可以用于控制变量的存储期（生命周期）、可见性（链接性）、以及在类定义中控制成员的属性。以下是static在不同情况下的用法概述：

1. 控制局部变量的存储期

在函数内部声明的局部变量通常在函数调用时创建，在函数返回时销毁。如果将局部变量声明为static，则该变量的生命周期会被延长到程序的整个运行期间，即使它的作用域仍然局限于声明它的那个函数内部。这意味着函数在多次调用之间可以保留变量的值。

1void function() {
2    static int counter = 0; // counter的值在函数调用之间保持
3    counter++;
4    std::cout << counter << std::endl;
5}

2. 控制全局变量的链接性

在文件范围内声明的static变量或函数，其链接性为内部的（internal linkage），这意味着它们只在定义它们的文件内可见，对其他文件是隐藏的。这有助于避免命名冲突，并保护数据不被其他文件意外访问或修改。

1static int globalVar = 0; // 仅在此文件内可见
2
3static void helperFunction() { // 仅在此文件内可用
4    // 函数实现
5}

3. 类的静态成员

在类定义中，static关键字用于声明静态成员变量和静态成员函数。静态成员属于整个类而不是类的任何特定对象，因此即使没有创建类的实例，也可以访问静态成员。所有实例共享同一静态成员数据。

 1class MyClass {
 2public:
 3    static int staticVar; // 静态成员变量
 4
 5    static void staticFunction() { // 静态成员函数
 6        std::cout << "Accessing static function." << std::endl;
 7    }
 8};
 9
10int MyClass::staticVar = 0; // 静态成员变量的定义和初始化
11
12void example() {
13    MyClass::staticVar = 5; // 访问静态成员变量
14    MyClass::staticFunction(); // 调用静态成员函数
15}

总结

  • 当static用于函数内的局部变量时，它延长了变量的生命周期。
  • 当static用于文件范围内的全局变量或函数时，它限制了变量或函数的链接性，使其仅在定义它们的文件内可见。
  • 在类的上下文中，static用于声明属于整个类而不是某个实例的成员，允许在没有类实例的情况下访问这些成员。

这些特性使得static成为C++编程中一个非常有用和灵活的关键字。

Static 成员函数

在C++中，类的静态成员函数是属于整个类而不是类的任何特定对象的函数。静态成员函数与静态成员变量一样，它们不依赖于类的实例。这意味着即使没有创建类的对象，也可以调用静态成员函数。静态成员函数只能访问其类的静态成员变量和其他静态成员函数；它们不能直接访问类的非静态成员变量或函数，因为这些成员需要一个具体的类实例。

特性

  • 类级别的函数：静态成员函数作用于类级别而非实例级别。
  • 访问限制：只能直接访问静态成员变量和其他静态成员函数，不能直接访问非静态成员。
  • 调用方式：通过类名和作用域解析操作符::调用，而不是通过类的实例。

使用场景

  • 工具函数：当需要一个与类相关但不需要类实例就能执行的功能时，静态成员函数很有用。例如，计算两个参数的最大值或最小值等。
  • 单例模式：在实现单例模式时，用于获取类的唯一实例的函数通常声明为静态的。
  • 访问静态成员变量：用于访问和修改静态成员变量的值，尤其是当这些变量被声明为私有时，提供公共的静态成员函数来获取和设置它们的值是一种常见的做法。

示例代码

 1#include <iostream>
 2
 3class Example {
 4public:
 5    static int staticVar;
 6
 7    static void staticFunction() {
 8        std::cout << "Accessing staticVar: " << staticVar << std::endl;
 9    }
10
11    void nonStaticFunction() {
12        // 静态成员函数可以被非静态成员函数调用
13        staticFunction();
14    }
15};
16
17// 静态成员变量的初始化
18int Example::staticVar = 10;
19
20int main() {
21    // 通过类名调用静态成员函数
22    Example::staticFunction(); // 输出: Accessing staticVar: 10
23
24    // 修改静态成员变量
25    Example::staticVar = 20;
26
27    // 再次调用静态成员函数
28    Example::staticFunction(); // 输出: Accessing staticVar: 20
29
30    // 创建类实例并调用非静态成员函数
31    Example example;
32    example.nonStaticFunction(); // 输出: Accessing staticVar: 20
33
34    return 0;
35}

在这个例子中，staticFunction是一个静态成员函数，它访问了同一个类的静态成员变量staticVar。即使没有Example类的实例，也可以通过Example::staticFunction()来调用这个函数。静态成员函数是类的一部分，而不是任何特定实例的一部分，因此它们在设计类时提供了一种灵活的工具，尤其是在实现只与类相关而不依赖于类实例的行为时。

不同文件中的static变量的初始化顺序有规定吗

在C++中，不同文件（编译单元）中的静态变量（也称为静态存储期变量，包括全局变量、文件作用域的静态变量以及类的静态成员变量）的初始化顺序涉及到两个主要概念：在单个编译单元内的初始化顺序和跨多个编译单元的初始化顺序。

单个编译单元内的初始化顺序

在一个给定的编译单元（通常是一个源文件）内，静态变量按照它们出现的顺序被初始化。这意味着第一个声明的静态变量会先被初始化，以此类推。这部分是明确且可预测的。

跨多个编译单元的初始化顺序

跨多个编译单元（不同的源文件）的静态变量初始化顺序是未定义的。这意味着，如果你有两个源文件，每个文件中都定义了一个静态变量，那么你不能保证这两个变量哪一个会先被初始化。这种情况通常被称为“静态初始化顺序问题”或“静态初始化顺序地狱”。

静态初始化顺序问题的解决办法

为了解决或避免跨编译单元的静态初始化顺序问题，C++提供了一种被称为“构造函数初始化”（Construct On First Use）的技巧。它通过将静态变量封装在函数内部来延迟变量的初始化，直到这个变量被首次使用时才进行。这样做的好处是确保了初始化的顺序性和确定性。

例如：

1// 获取静态变量的函数
2SomeClass& getStaticInstance() {
3    static SomeClass instance; // 首次调用此函数时初始化
4    return instance;
5}

在这个例子中，instance变量在getStaticInstance()函数首次被调用时初始化。这保证了无论变量在程序中被首次访问的时间点或顺序如何，instance的初始化都是安全和确定的。

总结

虽然C++标准没有规定不同编译单元中静态变量的初始化顺序，但通过使用特定的设计模式和技巧，如“构造函数初始化”模式，可以有效地避免由此产生的问题。这种方法不仅可以解决初始化顺序问题，还可以延迟对象的初始化直到真正需要时，从而提高程序的启动性能和资源使用效率。

C++单例模式代码

单例模式是一种设计模式，确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。在C++中实现单例模式通常涉及以下几个关键步骤：

  1. 将构造函数、复制构造函数和赋值运算符标记为私有或删除，以防止外部创建类的多个实例。
  2. 在类内部提供一个静态私有指针变量，用于持有唯一的类实例。
  3. 提供一个公有的静态方法，用于获取这个唯一实例。

下面是单例模式的一个基本实现示例：

 1#include <iostream>
 2
 3class Singleton {
 4private:
 5    // 私有静态成员变量，指向唯一实例
 6    static Singleton* instance;
 7
 8    // 私有构造函数，防止外部直接创建实例
 9    Singleton() {}
10
11    // 私有复制构造函数和赋值运算符，防止复制实例
12    Singleton(const Singleton&) = delete;
13    Singleton& operator=(const Singleton&) = delete;
14
15public:
16    // 公有静态方法，用于获取唯一实例的引用
17    static Singleton& getInstance() {
18        if (instance == nullptr) {
19            instance = new Singleton();
20        }
21        return *instance;
22    }
23
24    // 示例方法
25    void doSomething() {
26        std::cout << "Doing something." << std::endl;
27    }
28};
29
30// 初始化静态成员变量
31Singleton* Singleton::instance = nullptr;
32
33int main() {
34    // 获取单例的引用并调用方法
35    Singleton::getInstance().doSomething();
36
37    return 0;
38}

这个例子展示了单例模式的核心要素：私有的构造函数和静态方法getInstance()确保全局只能通过该方法访问唯一的实例。通过将复制构造函数和赋值运算符设置为私有或删除，防止了实例的复制。

需要注意的是，这个基本实现在多线程环境下可能不是线程安全的。在多线程程序中，可能需要额外的同步机制（如互斥锁）来确保在创建单例实例时只有一个线程可以执行初始化代码。

对于多线程安全的单例实现，C++11及以后的版本提供了一个更简洁的方法，依靠局部静态变量的特性来保证线程安全：

 1class Singleton {
 2public:
 3    // 删除复制构造函数和赋值运算符
 4    Singleton(const Singleton&) = delete;
 5    Singleton& operator=(const Singleton&) = delete;
 6
 7    // 提供一个静态方法获取单例引用
 8    static Singleton& getInstance() {
 9        static Singleton instance; // 局部静态变量
10        return instance;
11    }
12
13    void doSomething() {
14        std::cout << "Doing something." << std::endl;
15    }
16
17private:
18    // 私有构造函数
19    Singleton() {}
20};

在这个版本中，instance是一个局部静态变量，C++标准保证了当getInstance()第一次被调用时，instance将被创建，并且只会创建一次，即使在多线程环境下也能保证这一点。这种方法简化了代码，同时保证了线程安全性。

静态变量和线程安全的关系？

静态变量和线程安全之间的关系是一个重要的考虑点，特别是在多线程程序设计中。理解这一关系有助于开发出安全且高效的并发应用。

静态变量

静态变量在程序的生命周期内只被初始化一次，并在后续的程序运行过程中保持其状态。在C++中，静态变量可以是全局静态变量、局部静态变量、或是类的静态成员变量。全局静态变量和类的静态成员变量在所有对象和函数调用中共享，而局部静态变量在其所在函数的所有调用中共享。

线程安全

线程安全是指代码在多线程环境中被执行时，能够正确处理多个线程同时访问相同资源的情况，而不会导致数据损坏或不一致。如果一个函数或数据结构可以在多个线程中安全地被并发使用，不需要额外的同步机制，就称它为线程安全的。

静态变量与线程安全

由于静态变量在多个线程中共享，如果多个线程试图同时修改同一个静态变量，就可能导致数据冲突和不一致的问题。因此，静态变量本身不是线程安全的，除非采取了适当的同步措施。

  • 全局静态变量和类的静态成员变量：当多个线程访问和修改这些变量时，如果没有适当的锁机制（例如互斥锁）来控制访问，就可能导致数据竞争和不一致性问题。
  • 局部静态变量：在C++11及以后的版本中，局部静态变量的初始化是线程安全的，即在第一次访问变量时进行的初始化操作是由编译器自动加锁的，确保只有一个线程可以初始化变量。然而，初始化之后对变量的访问和修改仍然需要额外的同步措施来保证线程安全。

保证线程安全的策略

  • 互斥锁：使用互斥锁（mutex）来同步对静态变量的访问。任何线程在访问变量之前必须首先获得锁，并在访问完成后释放锁。
  • 原子操作：对于简单的数据类型，可以使用原子操作来更新静态变量，原子操作保证了操作的不可分割性，从而避免了数据竞争。
  • 线程局部存储：如果静态变量不需要在多个线程间共享，可以考虑将其改为线程局部存储（Thread Local Storage, TLS），使得每个线程都有自己的变量副本。

总之，虽然静态变量在多线程程序中提供了便利和效率，但正确管理对它们的访问至关重要，以确保程序的线程安全性和稳定性。在设计多线程程序时，应该仔细考虑如何同步对静态资源的访问，以避免潜在的竞争条件和其他线程安全问题。

输入url到网页显示的过程

当你在浏览器中输入一个URL并按下回车键后，发生了一系列复杂的过程，这些过程一起工作，将网页内容呈现到你的屏幕上。以下是这个过程的高级概述：

1. 解析URL

  • **URL（统一资源定位符）**分析成不同的部分：协议（如HTTP或HTTPS）、服务器地址（域名）和资源路径。
  • 浏览器会检查URL格式是否正确，如果URL不完整或有误，浏览器可能会尝试修正它或使用搜索引擎来寻找正确的地址。

2. 域名解析（DNS查询）

  • 浏览器会查找URL中域名对应的IP地址。这通常涉及到DNS（域名系统）查询。
  • 首先，浏览器检查本地缓存中是否有此域名的记录；如果没有，浏览器会向配置的DNS服务器发送查询请求。

3. 建立连接

  • 一旦获取到服务器的IP地址，浏览器会向服务器发起连接。对于HTTP协议，这意味着建立一个TCP连接；对于HTTPS协议，还需要进行TLS握手以建立一个加密连接。

4. 发送HTTP请求

  • 浏览器构建一个HTTP请求，并通过TCP连接发送给服务器。这个请求包括请求行（如GET /index.html HTTP/1.1）、请求头（包括浏览器类型、接受的内容类型等）和请求体（对于某些类型的请求）。

5. 服务器处理请求并响应

  • 服务器接收到请求后，会根据请求类型处理请求（如查找请求的资源）。
  • 服务器将响应发送回浏览器，响应通常包括一个状态码（如200表示成功），响应头（包含内容类型、编码等信息）和响应体（即请求的资源内容）。

6. 浏览器渲染页面

  • 浏览器接收到服务器的响应数据后，会根据响应的内容类型解析响应体。
  • 如果是HTML文档，浏览器会解析HTML结构，构建DOM（文档对象模型）树。
  • 浏览器解析CSS样式，并应用到DOM树上，构建渲染树。
  • 执行JavaScript代码，可能会修改DOM树和渲染树。
  • 浏览器布局渲染树中的元素，并将它们绘制到屏幕上，呈现最终的页面。

7. 后续处理

  • 如果页面中包含了需要进一步加载的资源（如图片、CSS文件、JavaScript文件等），浏览器会重复上述过程来获取这些资源，并更新页面内容。

整个过程涉及网络、服务器、浏览器等多个层面的复杂交互。每一步都优化了速度和安全性，以确保用户能够快速、安全地获取和查看网页内容。

什么时候会返回404

HTTP 404错误状态码表示服务器无法找到请求的资源。这种情况通常发生在以下几种场景中：

1. URL错误或拼写错误

如果URL中的路径或文件名存在拼写错误，服务器会因为找不到匹配的资源而返回404错误。例如，如果用户尝试访问的网页路径拼写错误（如/hom代替/home），服务器将无法找到该资源。

2. 资源被移动或删除

如果之前存在的网页或资源被网站管理员移动到另一个位置，或者被完全删除，没有进行适当的重定向处理，那么对这个资源的请求将会返回404错误。这是导致404错误的常见原因。

3. 服务器配置问题

服务器配置错误也可能导致404错误。例如，如果Web服务器（如Apache或Nginx）的配置文件中指定的资源目录路径错误，或者配置了错误的重写规则，那么即使请求的资源存在，用户也可能收到404错误。

4. 域名解析错误

尽管这种情况较少见，但如果域名未正确解析到正确的服务器，或者服务器上没有为该域名配置虚拟主机，那么请求可能会被发送到错误的服务器，从而可能返回404错误。

5. 链接过时

对于一些内容管理系统（CMS）或动态生成的网站，页面的URL可能随着内容更新而改变。如果其他网站或用户的书签链接到了旧的URL，这将导致404错误。

6. 权限问题

在某些情况下，服务器可能配置为对未授权访问某些资源返回404错误，而不是403错误（禁止访问），这是为了隐藏资源的存在，增加安全性。

应对404错误的措施

  • 检查URL：确认URL输入正确，没有拼写错误。
  • 使用搜索功能：如果网站提供搜索功能，可以尝试搜索想要找到的内容。
  • 检查网站的站点地图：站点地图列出了网站上所有可访问的页面链接。
  • 联系网站管理员：如果认为页面应该存在，可以尝试联系网站的管理员或支持团队获取帮助。
  • 设置自定义404页面：对于网站开发者来说，设置一个友好的404错误页面可以提供返回主页的链接或者搜索框，帮助用户找到他们感兴趣的内容。

404错误虽然令人沮丧，但正确处理这些错误可以提升用户体验，并帮助访问者找到他们感兴趣的内容或返回网站的其它部分。

TCP怎么实现可靠传输

TCP（传输控制协议）通过一系列的机制来实现在不可靠的网络层之上的可靠数据传输。这些机制确保了数据正确、有序地传输，即使在网络条件不佳的情况下也能尽可能保证数据的完整性和顺序。以下是TCP实现可靠传输的主要机制：

1. 三次握手建立连接

TCP使用一种称为“三次握手”的过程来建立连接，以确保双方都准备好进行数据传输。这个过程也同步双方的序列号，以便于后续的数据传输可以被正确排序，并跟踪哪些数据已被成功接收。

2. 数据包排序

每个TCP段都包含一个序列号，这允许接收方对接收到的数据包进行排序，以确保数据的正确顺序。

3. 确认应答与超时重传

接收方对收到的TCP段发送确认（ACK）回复，表明它已成功接收到该段。如果发送方在一个预定的超时期限内没有收到确认，它将重新发送该数据段。这个机制确保了数据的成功传输。

4. 流量控制

TCP使用窗口大小来进行流量控制，这个窗口大小告诉发送方接收方还能接收多少数据。这避免了发送方发送太多数据，导致接收方处理不过来而丢失数据。

5. 拥塞控制

TCP实现了几种拥塞控制算法（如慢启动、拥塞避免、快重传和快恢复）来减少网络中的拥塞。这些算法调整数据的传输速率，以响应网络中的拥塞情况，避免过多的数据包同时传输导致的网络拥塞和数据包丢失。

6. 保活机制

TCP保活机制可以检测出空闲的连接，防止连接由于长时间的无活动而被意外关闭。通过定期发送保活探针，TCP可以判断对方是否仍然可达。

7. 四次挥手断开连接

TCP使用四次挥手的过程来安全地关闭连接。这个过程确保了双方都已经发送和接收了所有的数据。

通过上述机制，TCP能够提供一种可靠的数据传输服务，即使在网络状况不稳定的情况下也能尽可能保证数据的完整性和顺序。这些特性使得TCP成为许多需要可靠数据传输的应用（如Web浏览、电子邮件和文件传输）的理想选择。

TCP连接过多怎么办

当TCP连接过多时，可能会导致服务器资源紧张，性能下降，甚至服务不可用。处理这种情况需要综合考虑，采取多种策略来优化和管理TCP连接。以下是一些常见的处理方法：

1. 优化服务器配置

  • 增加最大连接数：调整操作系统和服务器软件的配置，增加可以同时打开的最大连接数。
  • 调整TCP参数：比如调整TCP Keepalive时间，减少TIME_WAIT状态持续的时间，以便更快地回收和重用端口。

2. 使用负载均衡

  • 部署负载均衡器：在服务器前端部署负载均衡器，将流量分发到后端的多个服务器上。这样可以分散压力，提高整体的处理能力和可用性。

3. 采用更高效的架构

  • 使用异步IO：传统的同步IO模型在处理大量并发连接时可能会遇到瓶颈。采用异步IO模型（如IO多路复用）可以更高效地处理大量并发连接。
  • 事件驱动架构：事件驱动的服务器架构（如Node.js）能够更好地支持高并发连接，提高资源利用率。

4. 优化应用层

  • 连接复用：在应用层面，尽量复用已建立的TCP连接（如HTTP Keep-Alive），减少频繁建立和断开连接的开销。
  • 限制连接时间：对于某些不需要长时间保持连接的应用，可以设定超时时间，超过时间限制后自动关闭连接。

5. 资源监控和自动扩展

  • 监控资源使用：持续监控服务器的CPU、内存、网络等资源使用情况，及时发现瓶颈。
  • 自动扩展：在云环境中，可以设置自动扩展策略，根据负载情况自动增减服务器实例。

6. 防御拒绝服务攻击

  • 如果TCP连接过多是由拒绝服务攻击（DoS/DDoS攻击）引起的，需要采取相应的防御措施，如部署专业的DDoS防御系统，限制IP连接速率等。

处理TCP连接过多的问题需要从系统、网络和应用多个层面进行综合考虑和优化。在设计系统时，考虑到高并发和高可用性的需求，并采取适当的架构和技术来应对可能的高负载情况，是避免此类问题的关键。

为什么有IP地址还有MAC地址

IP地址和MAC地址都是网络中设备通信的重要组成部分，但它们在网络通信中扮演着不同的角色，服务于不同的网络层。理解它们之间的区别和为什么两者都需要，可以帮助我们更好地理解网络是如何工作的。

IP地址

IP地址（Internet Protocol Address）是网络层（特别是在TCP/IP模型中的第三层）的一个标识符，用于标识网络上的每个设备，以及帮助路由数据包从源头到目的地。IP地址主要用于不同网络或网络段之间的通信。因为网络设备可能频繁改变位置，进入不同的网络环境，IP地址可能会改变，特别是在使用DHCP服务时。

IP地址的主要功能包括：

  • 标识：为每个连接到网络的设备提供唯一标识。
  • 路由：帮助网络中的路由器决定如何将数据包从源地址转发到目的地址。

MAC地址

MAC地址（Media Access Control Address），也称为物理地址，是数据链路层（在TCP/IP模型中的第二层）的一个标识符，嵌入到网络接口卡（NIC）硬件中。MAC地址是在设备制造过程中分配的，通常是不变的（尽管可以通过软件进行修改）。MAC地址主要用于同一个物理网络内的设备之间的通信。

MAC地址的主要功能包括：

  • 物理地址标识：为网络上每个物理设备提供唯一标识。
  • 局域网通信：在局域网（LAN）内部，数据包的传输是基于MAC地址的。设备使用MAC地址来确定数据包是否是发往自己的。

为什么两者都需要

  • 不同的网络层：IP地址和MAC地址分别服务于TCP/IP模型的不同层次。IP地址用于网络层，实现跨网络的数据传输。而MAC地址用于数据链路层，实现同一局域网内的设备通信。
  • 不同的功能和作用范围：IP地址提供逻辑地址，使得设备可以在全球范围内通信，而MAC地址提供物理地址，用于局域网内部的通信。
  • 路由和交换：在数据包传输过程中，路由器利用IP地址来路由数据包到正确的目的网络，而交换机则使用MAC地址来将数据包转发到正确的设备。

综上所述，IP地址和MAC地址共同确保了数据能够在复杂的网络环境中，从源设备准确、高效地传输到目标设备。

路由器有IP地址吗

是的，路由器具有IP地址。实际上，路由器通常会有至少两个IP地址：一个是用于局域网（LAN）侧的内部网络接口的IP地址，另一个是用于广域网（WAN）侧的外部网络接口的IP地址。这些IP地址使路由器能够在不同的网络环境中正确地路由数据包。

局域网（LAN）侧IP地址

  • 私有IP地址：路由器的LAN侧IP地址通常是一个私有IP地址，这个地址是路由器内部网络的默认网关地址。设备在发送数据到局域网外部的互联网时，数据包会被发送到这个地址。
  • 网关地址：在家庭或小型办公室网络中，路由器的LAN侧IP地址通常被配置为192.168.x.1或10.0.x.1这样的地址（x是0到255之间的任意数字），它作为内部网络中所有设备的默认网关。

广域网（WAN）侧IP地址

  • 公有IP地址：路由器的WAN侧IP地址通常是由互联网服务提供商（ISP）分配的一个公有IP地址。这个地址是路由器在互联网上的标识，允许局域网内的设备通过路由器访问互联网。
  • 唯一性：为了能在互联网上被其他系统识别和访问，每个连接到互联网的设备必须有一个唯一的公有IP地址。由于公有IP地址是有限的，家庭和小型办公网络通常只有路由器拥有一个公有IP地址，而内部设备则使用NAT（网络地址转换）技术通过这个公有IP地址共享互联网连接。

管理IP地址

  • 用于管理的IP地址：除了用于路由的IP地址外，路由器还可能配置有一个特别的管理IP地址，用于访问路由器的管理界面（如Web界面）。这通常是路由器LAN侧的IP地址。

总之，路由器拥有IP地址是它完成数据包路由、网络通信和管理任务的基础。通过这些IP地址，路由器能够在局域网内提供连接到互联网的通道，同时允许网络管理员对其进行配置和管理。

内存泄露怎么解决

内存泄露是指程序中已分配的内存未能成功释放，导致无法再被程序利用的情况。长时间运行或多次执行这样的程序可能会导致可用内存逐渐减少，最终影响程序性能或导致程序崩溃。解决内存泄露的问题通常需要几个步骤，包括检测、定位和修复泄露。

检测内存泄露

  1. 使用内存分析工具：大多数编程语言都提供了内存分析工具或库，如Valgrind、LeakSanitizer、Visual Studio的诊断工具、Xcode的Instruments等，可用于检测内存泄露。

  2. 代码审查：定期进行代码审查，特别关注内存分配和释放的逻辑，可以帮助识别潜在的内存泄露问题。

  3. 监控系统性能：通过监控应用程序的内存使用情况，可以发现异常的内存增长模式，这可能是内存泄露的迹象。

定位内存泄露

  1. 分析内存分配：利用内存分析工具，可以获取内存分配和释放的详细报告，从而定位未被释放的内存块。

  2. 日志和调试信息：在关键的内存分配和释放点添加日志信息，可以帮助追踪内存使用情况，进而定位泄露的位置。

  3. 代码分析：静态代码分析工具可以帮助识别内存管理的常见问题，例如未匹配的内存分配和释放。

修复内存泄露

  1. 确保匹配的内存释放：每次内存分配（例如new、malloc）都应该有对应的释放操作（例如delete、free）。

  2. 使用智能指针（C++）：在C++中，使用智能指针（如std::unique_ptr、std::shared_ptr）可以自动管理内存，减少显式释放内存的需要。

  3. 利用RAII原则（资源获取即初始化）：确保资源（包括内存）的分配和释放都在同一个对象的构造函数和析构函数中进行，利用作用域自动管理资源。

  4. 避免内存泄露的编程模式：例如，在C++中避免循环引用（可通过std::weak_ptr解决），在Java或C#中注意事件处理器的注册和注销等。

  5. 内存池：对于频繁分配和释放的小对象，使用内存池可以减少内存碎片和泄露的可能性。

解决内存泄露的关键在于深入理解代码的内存使用情况，以及利用合适的工具和策略来监控、定位和修复问题。持续的性能监控、代码审查和测试是防止内存泄露的重要手段。

为什么要有虚拟内存空间

虚拟内存空间是现代计算机系统中的一个关键概念，它提供了一个抽象层，使得软件开发者和操作系统能够更有效地管理硬件资源。虚拟内存的引入主要基于以下几个原因和优势：

1. 内存扩展

  • 扩大可用内存：虚拟内存允许系统使用硬盘空间作为额外的内存，从而扩大了可供程序使用的内存空间。这意味着即使物理RAM不足，程序也能运行，因为操作系统可以将部分数据暂时存储在硬盘的虚拟内存页中。

2. 进程隔离

  • 提供进程间隔离：每个进程都在其自己的虚拟地址空间中运行，这使得进程之间的内存访问相互隔离，防止一个进程的错误操作（如越界访问）影响到其他进程。

3. 内存管理简化

  • 简化内存管理：虚拟内存使得操作系统可以为每个进程提供一致的地址空间，简化了内存的分配和管理。程序员无需担心物理内存的具体位置和限制，可以认为有一个几乎无限大的内存空间。

4. 内存保护

  • 增强安全性和稳定性：操作系统可以通过虚拟内存来控制每个进程对内存的访问权限（如只读、读写或执行权限），增加了系统的安全性和稳定性。

5. 数据共享

  • 方便数据共享与通信：虚拟内存机制也使得不同进程间共享内存成为可能，便于进程间的数据共享和通信。

6. 物理内存优化

  • 优化物理内存使用：虚拟内存允许操作系统更灵活地管理物理内存，如通过页面置换算法（如最近最少使用LRU算法）来决定哪些数据应当保留在RAM中，哪些可以被移动到硬盘，从而最优化物理内存的使用。

7. 支持多任务

  • 支持多任务处理：虚拟内存为多任务操作系统提供了基础，使得多个应用程序能够同时运行，同时保证它们的运行环境互不干扰，提高了计算机系统的效率和响应速度。

虚拟内存通过上述优势，不仅提高了计算机的性能和资源利用率，也极大地简化了程序设计和系统管理，是现代操作系统不可或缺的一部分。

i++是原子性的吗

i++操作（自增操作）在多数编程语言中并不是原子性的，尽管在单个线程的上下文中这个操作看起来只是简单地增加变量的值。i++实际上包含了三个独立的步骤：读取变量i的当前值、增加这个值、将新值写回到变量i。在多线程环境中，如果没有适当的同步机制，这三个步骤之间可能会被其他线程的操作打断，导致竞态条件和数据不一致的问题。

为什么i++不是原子性的

  1. 读取：首先，程序需要读取变量i的当前值到CPU寄存器。
  2. 修改：在CPU寄存器中，给这个值加1。
  3. 写回：最后，将新值写回内存中的变量i。

这个过程中的任何步骤都可能被其他线程打断，特别是在没有锁或其他同步机制保护的情况下。例如，两个线程几乎同时读取i的值，然后分别增加1并尝试写回，结果是i实际上只增加了1而不是2。

如何确保操作的原子性

要确保类似i++这样的操作在多线程环境中的原子性，可以采用以下一种或多种方法：

  • 使用互斥锁（Mutex）：通过在执行i++操作之前获取互斥锁，然后执行操作，最后释放锁，可以确保这个操作在完成之前不会被其他线程打断。
  • 原子操作函数：许多编程语言和库提供了原子操作API，比如C++11引入的std::atomic类型和相关操作，或Java的java.util.concurrent.atomic包中的类。这些API能够保证变量操作的原子性。
  • 使用硬件同步原语：某些平台提供了CPU指令级的支持来执行原子操作，如x86架构的CMPXCHG指令。编程语言或库的原子操作API底层可能会利用这些硬件特性。

总之，i++操作本身在多线程环境下不是原子性的，需要通过同步机制或使用特定的原子操作API来保证其安全性。在设计多线程程序时，正确处理这类操作至关重要，以避免数据不一致和竞态条件。

子类中变量初始化顺序和销毁顺序

在面向对象的编程中，特别是在使用如Java、C++等语言时，子类和父类中变量的初始化和销毁顺序遵循特定的规则，这些规则保证了对象的构造和析构过程的正确性和逻辑性。下面是这些语言中常见的初始化和销毁顺序的概述：

Java

初始化顺序

  1. 父类静态变量和静态初始化块：按照它们在父类中出现的顺序。
  2. 子类静态变量和静态初始化块：按照它们在子类中出现的顺序。
  3. 父类非静态变量和非静态初始化块：按照它们在父类中出现的顺序。
  4. 父类构造器。
  5. 子类非静态变量和非静态初始化块：按照它们在子类中出现的顺序。
  6. 子类构造器。

销毁顺序

Java中，对象的销毁是由垃圾回收器(GC)处理的，没有像C++中析构函数那样直接的销毁过程。但是，可以通过finalize()方法提供一定的清理逻辑。通常，finalize()方法的调用顺序与构造器的调用顺序相反，但依赖于GC的具体实现和行为，finalize()方法的调用时机和顺序可能是不确定的。

C++

初始化顺序

  1. 父类构造器：首先调用基类的构造函数。
  2. 成员变量初始化：按照它们声明的顺序初始化父类的成员变量。
  3. 父类构造器体内的代码。
  4. 成员变量初始化：按照它们声明的顺序初始化子类的成员变量。
  5. 子类构造器体内的代码。

销毁顺序

销毁顺序与初始化顺序相反：

  1. 子类析构器体内的代码。
  2. 子类成员变量的析构：按照初始化顺序的逆序进行销毁。
  3. 父类析构器体内的代码。
  4. 父类成员变量的析构：按照初始化顺序的逆序进行销毁。

在C++中，析构函数是显式定义的，它们提供了在对象销毁时执行清理资源等操作的机会。与Java不同，C++的对象销毁是确定的，由程序员或对象作用域结束时自动触发。

这些初始化和销毁的规则确保了对象在其生命周期内的状态和行为的正确性，是面向对象编程中重要的概念。理解这些规则对于编写可靠和高效的代码至关重要。

cpu如何实现除法

CPU实现除法的方法可以根据其设计和指令集架构的不同而不同。在硬件层面，有几种常见的方法用于实现除法运算：

1. 长除法（硬件实现）

这是最直观的方法，类似于我们在纸上执行的长除法过程，但是在二进制下进行。CPU通过一系列的移位、比较和减法操作来实现除法。这个过程涉及将被除数左移（相当于在二进制下的乘以2），然后与除数比较，如果被除数大于等于除数，就从被除数中减去除数，并在商的相应位置上放置一个1，否则放置一个0。这个过程重复进行，直到完成所有的位操作。

2. 逼近法（硬件实现）

  • 牛顿-拉弗森迭代法（Newton-Raphson）：这种方法利用迭代逼近来找到除法的结果。它基于牛顿迭代法求解函数零点的数学原理，通过迭代计算逐步逼近真实的除法结果。这种方法特别适用于浮点除法。

  • 高德（Goldschmidt）迭代法：这是另一种迭代逼近方法，通过同时对被除数和除数进行乘法操作来逼近结果，最终将除法问题转化为乘法问题。

3. 查表法（软件/硬件辅助实现）

对于一些特定的除数，可以通过查找预先计算好的除法结果表来快速得到结果。这种方法在执行小范围内的除法操作时效率很高，但对于大数的除法则不太实用，因为查表需要大量的存储空间。

4. 软件实现

对于一些没有硬件除法支持的简单CPU或者特定应用场景，除法运算可能通过软件实现，即编译器将除法操作转换为一系列的基本操作，如移位、加法和减法。这种方法比直接的硬件支持要慢，但可以在不支持硬件除法的CPU上执行除法运算。

性能考虑

在CPU中，除法是相对较慢的操作，特别是浮点除法。因此，现代CPU设计采用高级算法和技术（如流水线处理、并行执行等）来优化除法操作的性能。在软件开发中，避免不必要的除法运算或将其替换为更快的操作（如移位）是常见的性能优化手段。

总的来说，CPU中除法的实现是复杂的，涉及多种算法和技术，旨在平衡计算的准确性和执行的效率。

三个线程如何交替打印ABC循环100次，用C++实现

实现三个线程交替打印ABC循环100次的任务，可以通过同步机制来控制线程间的执行顺序。在C++中，可以使用std::mutex和std::condition_variable来实现这一目标。下面是一个具体的实现示例：

 1#include <iostream>
 2#include <thread>
 3#include <mutex>
 4#include <condition_variable>
 5
 6class ABCPrinter {
 7public:
 8    ABCPrinter(int count) : count_(count) {}
 9
10    void printA() {
11        for (int i = 0; i < count_; ++i) {
12            std::unique_lock<std::mutex> lock(m_);
13            cv_.wait(lock, [this]() { return currentChar_ == 'A'; });
14            std::cout << 'A';
15            currentChar_ = 'B';
16            cv_.notify_all();
17        }
18    }
19
20    void printB() {
21        for (int i = 0; i < count_; ++i) {
22            std::unique_lock<std::mutex> lock(m_);
23            cv_.wait(lock, [this]() { return currentChar_ == 'B'; });
24            std::cout << 'B';
25            currentChar_ = 'C';
26            cv_.notify_all();
27        }
28    }
29
30    void printC() {
31        for (int i = 0; i < count_; ++i) {
32            std::unique_lock<std::mutex> lock(m_);
33            cv_.wait(lock, [this]() { return currentChar_ == 'C'; });
34            std::cout << 'C';
35            currentChar_ = 'A';
36            cv_.notify_all();
37        }
38    }
39
40private:
41    std::mutex m_;
42    std::condition_variable cv_;
43    char currentChar_ = 'A';
44    int count_;
45};
46
47int main() {
48    const int count = 100;
49    ABCPrinter printer(count);
50
51    std::thread t1(&ABCPrinter::printA, &printer);
52    std::thread t2(&ABCPrinter::printB, &printer);
53    std::thread t3(&ABCPrinter::printC, &printer);
54
55    t1.join();
56    t2.join();
57    t3.join();
58
59    std::cout << std::endl;
60
61    return 0;
62}

这个程序中，ABCPrinter类控制着打印行为。类中有一个std::mutex用于同步，一个std::condition_variable用于线程间的条件等待和通知，以及一个currentChar_变量来标记当前应该打印哪个字符。

  • 每个打印函数（printA、printB、printC）都会尝试获得锁，并通过条件变量等待直到它们各自负责的字符（currentChar_）是当前应该打印的字符。
  • 当条件满足时，打印相应的字符，并更新currentChar_为下一个字符，然后通过cv_.notify_all()唤醒所有等待的线程，这些线程再次检查条件是否满足自己打印的条件。
  • 这个循环持续进行，直到打印了指定的次数。

通过这种方式，三个线程可以协同工作，依次交替打印ABC，共计100次。

unique_lock是什么

std::unique_lock是C++标准库中的一个实用工具，提供了一种灵活的方式来管理带有互斥锁（std::mutex）的锁定和解锁操作。它是头文件<mutex>的一部分，是对基本互斥锁管理的一个封装，提供了比std::lock_guard更多的功能和灵活性。尽管std::unique_lock比std::lock_guard占用的资源稍多，但它在需要更复杂锁管理的场景下非常有用。

主要特点和用途

  1. 灵活的锁管理：std::unique_lock允许在运行时进行锁的获取和释放，而std::lock_guard仅在构造时加锁，在析构时解锁，不提供中途手动控制锁的功能。

  2. 支持条件变量：std::unique_lock可以与std::condition_variable一起使用，用于等待条件或通知其他线程。std::condition_variable需要与std::unique_lock<std::mutex>一起使用来等待条件或发送通知。

  3. 支持移动语义：std::unique_lock支持移动操作，这意味着可以将锁的所有权从一个std::unique_lock对象转移到另一个。这对于从函数返回已锁定的互斥锁或将其作为参数传递给函数等操作非常有用。

示例用法

 1#include <mutex>
 2#include <thread>
 3#include <iostream>
 4
 5std::mutex mtx; // 全局互斥锁
 6
 7void print_block(int n, char c) {
 8    // 在std::unique_lock对象构造时加锁
 9    std::unique_lock<std::mutex> lock(mtx);
10    for (int i = 0; i < n; ++i) { std::cout << c; }
11    std::cout << '\n';
12    // lock在析构时自动解锁
13}
14
15int main() {
16    std::thread t1(print_block, 50, '*');
17    std::thread t2(print_block, 50, '$');
18
19    t1.join();
20    t2.join();
21
22    return 0;
23}

在这个例子中，两个线程使用同一个互斥锁来同步对std::cout的访问。std::unique_lock<std::mutex>在print_block函数中创建并自动管理锁的生命周期：自动加锁和在离开作用域时解锁。

总之，std::unique_lock提供了一种灵活的方式来控制互斥锁的锁定和解锁，特别适合需要条件变量、可移动锁、或者需要在运行时进行更复杂的锁管理操作的场景。

CV的条件变为真的时候，谁来唤醒呢？

条件变为真时，线程被唤醒通常是由其他线程执行的操作导致的。这些操作包括调用std::condition_variable的notify_one或notify_all成员函数。这两个函数的作用是通知正在等待的一个或所有线程（分别对应notify_one和notify_all），条件可能已经满足，等待的线程应该再次检查条件。

这里是如何使用它们的简化示例：

  • notify_one: 当条件变为真时，某个线程调用cv.notify_one()会唤醒一个正在等待（通过cv.wait()或cv.wait_for()等方法）的线程。如果有多个线程在等待，只有一个线程（由调度程序随机选择）会被唤醒。

  • notify_all: 相比之下，当条件变为真时，调用cv.notify_all()会唤醒所有正在等待的线程。这对于需要多个线程响应同一个事件的情况特别有用。

示例场景

假设有两个线程A和B：

  • 线程A执行某个任务，完成后需要通知线程B任务已完成，线程B可以开始执行依赖于A的任务。
  • 线程A在完成任务后调用cv.notify_one()或cv.notify_all()（假设只有线程B在等待，两者效果相同）。
  • 线程B在开始自己的任务前调用cv.wait(lock, predicate)等待线程A的通知。一旦线程A调用了notify_one()或notify_all()，线程B被唤醒。
  • 被唤醒后，线程B会自动重新获得之前wait操作中释放的锁，并重新检查条件（谓词函数）。如果条件满足，线程B继续执行后续操作；如果不满足（虽然被唤醒，但条件可能由于某些原因未真正满足），线程B会再次进入等待状态。

这种机制确保了线程间的协作和同步，允许线程在适当的时间点安全地进行操作，避免了资源竞争和不一致的风险。

如何实现断点续传

实现断点续传的关键在于能够记录下载或上传的当前进度，并在传输被中断后能够从该进度处恢复而不是重新开始。断点续传通常用于处理大文件传输，尤其是在网络条件不稳定的情况下。以下是实现断点续传功能的基本步骤和策略：

1. 记录传输进度

  • 客户端和服务器都需要记录文件的传输进度。这可以通过保存已经传输的数据量（字节）来实现，或者记录已经成功传输的文件块的标识。

2. 支持范围请求

  • 服务器需要支持范围请求（HTTP协议的Range头部）。这允许客户端请求文件的特定部分而不是整个文件。客户端可以通过发送一个包含Range头部的HTTP请求来实现，指定需要下载的文件部分的起始和结束字节位置。

3. 客户端请求特定数据块

  • 客户端在恢复下载时请求未完成的数据块。基于已记录的进度，客户端计算出需要从哪个字节位置开始恢复下载，并发送带有Range头部的请求。

4. 服务器响应范围请求

  • 服务器识别Range请求并发送相应的文件片段。服务器需要正确处理带有Range头部的请求，只发送请求的文件部分。

5. 校验和完整性验证

  • 使用校验和或哈希来确保数据完整性。在传输完成后，客户端可以对接收到的文件片段或整个文件计算校验和或哈希值，与服务器端提供的值进行比较，以验证数据的完整性和正确性。

示例：HTTP断点续传

假设客户端已经下载了文件的前1024字节，现在希望从第1025字节开始继续下载：

1GET /path/to/file HTTP/1.1
2Host: example.com
3Range: bytes=1025-

服务器响应：

1HTTP/1.1 206 Partial Content
2Content-Range: bytes 1025-2048/2049
3Content-Length: 1024
4
5[数据块]

实现注意事项

  • 持久化进度信息：为了在客户端或服务器重启后能够恢复传输，进度信息需要被持久化存储，例如保存在文件系统或数据库中。
  • 并发控制：如果支持多个客户端同时对同一文件进行断点续传，需要实现适当的并发控制机制，以防止数据冲突。
  • 安全性：在设计断点续传功能时，应考虑到数据传输的安全性，使用加密连接（如HTTPS）来保护传输过程中的数据。

通过上述步骤和策略，可以有效实现文件的断点续传功能，提高大文件传输的效率和可靠性，尤其是在网络环境不稳定的情况下。

explicit关键字在C++中的作用

在C++中，explicit关键字用于修饰类的构造函数，以防止隐式类型转换或拷贝初始化。使用explicit关键字可以避免因不经意的类型转换而导致的错误，使代码的意图更加清晰。

隐式类型转换

默认情况下，如果一个构造函数只接受一个参数，或者所有参数除了一个都有默认值，那么它可以被用于隐式类型转换。例如：

 1class MyClass {
 2public:
 3    MyClass(int x) {
 4        // 构造函数的实现
 5    }
 6};
 7
 8void func(MyClass obj) {
 9    // func的实现
10}
11
12int main() {
13    func(10); // 隐式调用 MyClass(int) 构造函数
14    return 0;
15}

在上面的例子中，当func(10)被调用时，整数10会隐式地被用来构造一个MyClass的对象，因为MyClass有一个接受int类型参数的构造函数。

使用explicit防止隐式转换

要防止这种隐式类型转换，可以在构造函数前加上explicit关键字：

 1class MyClass {
 2public:
 3    explicit MyClass(int x) {
 4        // 构造函数的实现
 5    }
 6};
 7
 8void func(MyClass obj) {
 9    // func的实现
10}
11
12int main() {
13    func(10); // 这会引发编译错误
14    func(MyClass(10)); // 正确的调用方式
15    return 0;
16}

通过将构造函数声明为explicit，你告诉编译器不允许使用该构造函数进行隐式类型转换。这样，除非显式地调用构造函数（如MyClass(10)），否则编译器会报错。

explicit的作用域

  • C++11之前，explicit关键字只能用于修饰只接受一个参数的构造函数。
  • 从C++11开始，explicit可以用于修饰接受多个参数的构造函数，以及转换运算符。

例如，防止类的对象被隐式转换为其他类型：

 1class MyClass {
 2public:
 3    // 构造函数
 4    explicit MyClass(int x) {}
 5
 6    // 转换运算符
 7    explicit operator bool() const {
 8        return true;
 9    }
10};
11
12int main() {
13    MyClass obj(10);
14    bool flag = obj; // 这会引发编译错误
15    bool flag2 = static_cast<bool>(obj); // 正确的调用方式
16    return 0;
17}

使用explicit关键字是一种良好的编程实践，它可以增加代码的安全性和可读性，防止意外的类型转换导致的错误。

链表和数组的区别

队列和栈的区别

二叉树先序遍历、中序遍历、后序遍历

引用和指针的区别

using,typedef和define有什么区别

using、typedef和define在C++中都是与类型和符号定义相关的语法元素，但它们在用法、功能和适用范围上有着明显的不同。

typedef

typedef是C和C++中用来为类型定义一个新名字的关键字。它常用于简化复杂类型的名称，提高代码的可读性。

1typedef unsigned long ulong;
2typedef void (*FuncPtr)(int, double);

上述例子中，ulong成为了unsigned long的别名，FuncPtr成为了指向特定函数的指针类型的别名。

using

using是C++11引入的类型别名声明的新语法，功能上与typedef相似，但语法更加直观，尤其是在定义模板别名时。

1using ulong = unsigned long;
2using FuncPtr = void (*)(int, double);

对于模板别名，using的优势更为明显：

1template<typename T>
2using Ptr = T*;

上述代码定义了一个模板别名Ptr，可以用于任意类型的指针。

#define

#define是C和C++中的预处理指令，用于定义宏。它在编译前对代码进行文本替换，可以用来定义常量值、函数宏，或是进行条件编译等。

1#define PI 3.14159
2#define MAX(a, b) ((a) > (b) ? (a) : (b))

主要区别

  • 作用范围：typedef和using仅用于类型别名，增强代码可读性和简化复杂类型声明。#define是预处理指令，功能更广泛，但主要用于宏定义和条件编译。
  • 类型安全：typedef和using是类型安全的，它们定义的别名完全等同于原类型。#define进行的是文本替换，不涉及类型检查，有可能导致难以追踪的错误。
  • 适用范围：typedef和using仅适用于类型定义，而#define几乎可以用于定义任何文本替换。
  • 编译阶段：typedef和using在编译阶段处理，#define在预处理阶段处理。

总结来说，尽管typedef、using和#define在某些场景下可能看起来有相似的作用（如定义别名），但它们的用途、功能和适用范围有很大差别。在现代C++编程中，推荐使用using来定义类型别名，因为它比typedef更灵活，且语义更清晰。而#define因其灵活性和潜在的风险，在定义常量和类型别名时应谨慎使用，更多的是用于条件编译等场景。

const修饰成员函数会怎么样？可以有两个f(),其中一个带const,另一个不带吗?

static定义的变量默认值是多少？普通变量呢？

extern有什么作用

简述指针常量与常量指针区别

构造函数能否为虚函数

为什么基类的析构函数需要是序函数？

重载、隐藏、重写（覆盖）三者的区别？

重载：是指同一可访问区内被声明的几个具有不同参数列（参数的类型，个数，顺序不同）的同名函数，根据参数列表确定调用哪个函数，重载不关心函数返回类型（统一为void，否则报错）。

隐藏：是指派生类的函数屏蔽了与其同名的基类函数，注意只要同名函数，不管参数列表是否相同，基类函数都会被隐藏。

重写(覆盖)：是指派生类中存在重新定义的函数。其函数名，参数列表，返回值类型，所有都必须同基类中被重写的函数一致。只有函数体不同（花括号内），派生类调用时会调用派生类的重写函数，不会调用被重写函数。重写的基类中被重写的函数必须有virtual修饰。

重载的参数不同,函数体不同；隐藏的参数可以不同，函数体不同；重写或者覆盖仅仅函数体不同。

重载为什么改变参数就可以实现调用不同的函数？

重载（Overloading）是一种允许多个在同一作用域内的函数或操作符拥有相同名称，但是参数类型、个数或顺序不同的编程技术。编译器根据这些不同的参数列表来区分它们，这个过程称为重载解析（Overload Resolution）。当一个重载的函数被调用时，编译器通过匹配调用中使用的参数类型和数量，选择最合适的重载版本执行。下面解释为什么通过改变参数可以实现调用不同的函数：

参数类型、数量和顺序的不同

  1. 类型：如果两个函数的参数数量相同，但参数类型不同，编译器可以根据传递给函数的实参类型来决定调用哪个函数。

  2. 数量：如果两个函数的参数类型相同或者兼容，但参数数量不同，编译器会根据传递的参数数量来决定调用哪个函数。

  3. 顺序：如果两个函数的参数数量和类型都相同，但参数的顺序不同，编译器同样可以根据传递的参数的顺序来决定调用哪个函数。

编译器的重载解析过程

当调用一个重载的函数时，编译器执行一个重载解析过程，按照以下步骤：

  1. 候选函数集合：收集所有与调用匹配的重载函数，包括那些参数可以通过隐式转换匹配的函数。

  2. 可行函数集合：从候选函数中筛选出实参可以被隐式转换以匹配形参类型的函数。

  3. 最佳匹配：从可行函数中选择“最佳匹配”的函数。编译器会根据类型匹配的精确度（如是否需要类型转换，转换的复杂程度等）来决定最佳匹配。

  4. 调用：根据最佳匹配调用相应的函数。

如果编译器无法找到一个明确的最佳匹配，或者找到多个同样好的匹配，就会产生一个重载解析的歧义，编译时会报错。

重载的实用性

重载使得函数名可以根据上下文有不同的行为，提高了代码的可读性和易用性。例如，标准库中的std::cout就重载了多种类型的<<操作符，使得我们可以方便地输出不同类型的数据。

示例

 1void print(int i) {
 2    std::cout << "Integer: " << i << std::endl;
 3}
 4
 5void print(double f) {
 6    std::cout << "Double: " << f << std::endl;
 7}
 8
 9void print(const std::string& s) {
10    std::cout << "String: " << s << std::endl;
11}
12
13int main() {
14    print(10);    // 调用 print(int)
15    print(3.14);  // 调用 print(double)
16    print("Hello"); // 调用 print(const std::string&)
17}

在这个例子中，print函数被重载了三次，分别接受int、double和std::string类型的参数。编译器根据传递给print函数的参数类型来决定调用哪一个重载版本。

通过这种方式，重载为编程提供了更高的灵活性和表达力。

重载对链接有什么影响？重载的底层实现？

函数重载在编译阶段对函数名进行了修饰（或称为名字改编、名字矫正、mangling），以保证每个重载函数在程序的链接阶段有一个唯一的标识。这个过程对链接有重要影响，因为它确保了链接器可以正确地区分和链接各个重载函数，即使它们有相同的基础名称。

名字修饰（Name Mangling）

  • 定义：名字修饰是一种编译器技术，用于在内部符号表中生成唯一的函数和变量标识符。对于重载函数，编译器将函数的名称、参数类型列表（有时还包括命名空间或类名称）编码到生成的唯一标识符中。
  • 目的：主要目的是解决名称冲突问题，特别是在函数重载和模板实例化的情况下，这些情况下可能会有多个实体共享相同的名称。

链接阶段的影响

在链接阶段，链接器需要解析程序中的所有外部符号引用，将它们与相应的符号定义匹配起来。由于名字修饰，每个重载函数都有了独特的内部名称，链接器可以正确地识别和链接到正确的函数实现，即使多个函数具有相同的基本名称。

不同编译器的差异

不同的编译器可能采用不同的名字修饰规则。这意味着用不同编译器编译的代码在链接时可能会因为名字修饰的不兼容而遇到问题，尤其是在尝试链接不同编译器生成的二进制库时。为了解决这个问题，可以采用以下策略：

  • 使用相同的编译器：对于需要链接在一起的所有模块，尽量使用相同的编译器和编译选项。
  • C语言接口：对于C++库，如果需要与使用不同编译器的代码链接，可以提供一个“纯C”的接口，因为C语言没有函数重载，也不进行名字修饰，具有更好的二进制兼容性。
  • 外部接口（Extern “C”）：在C++中，可以使用extern "C"来告诉C++编译器对于特定的函数或变量不要进行名字修饰，从而使得这些符号能够被不同编译器编译的代码所链接。

通过这些方法，可以减少或避免由于名字修饰规则差异导致的链接问题，确保重载函数的正确链接和使用。

构造函数可以被重载么？析构函数呢？

new和malloc有什么区别?

new operator和operator new的区别？

在C++中，new操作符和operator new函数经常令人混淆，但它们有着明显的不同和各自的作用。

new操作符

new操作符用于动态分配内存并调用构造函数初始化对象。它是一个高级操作，执行了两个主要步骤：

  1. 内存分配：首先，new操作符调用operator new函数分配足够的内存以容纳特定类型的对象。这是一个底层操作，仅负责分配内存，并不负责构造对象。
  2. 构造对象：然后，在分配的内存上调用对象的构造函数来初始化对象。

这个过程可以通过下面的例子来说明：

1MyClass* obj = new MyClass();

上面的代码首先使用operator new分配足够的内存来存储一个MyClass类型的对象，然后在这块内存上调用MyClass的默认构造函数初始化对象。

operator new函数

operator new是一个全局函数或者类成员函数，仅负责分配内存，不涉及对象的构造。它是new操作符背后的内存分配机制。当你使用new操作符时，实际上是隐式调用了operator new函数来分配内存。

如果需要，可以重载operator new来提供自定义的内存分配策略。例如：

1void* operator new(size_t size) {
2    // 自定义内存分配逻辑
3    void* p = malloc(size);
4    // 处理内存分配失败的情况
5    if (!p) throw std::bad_alloc();
6    return p;
7}

需要注意的是，重载operator new需要非常谨慎，因为它会改变程序的基本内存分配行为。

总结

  • new操作符是一个高级操作，用于分配内存并初始化对象。
  • operator new函数是一个底层操作，仅用于分配内存，不负责对象的构造。
  • 在执行new操作符时，实际上会调用operator new函数来分配内存，然后在分配的内存上调用构造函数来构造对象。
  • 可以重载operator new和operator delete来提供自定义的内存分配和释放策略，但需要谨慎操作，以避免意外的行为。

深入解析new、operator new、::new、placement new

https://blog.csdn.net/songchuwang1868/article/details/81353577

在C++中，new操作的不同形式提供了内存分配和对象构造的灵活手段。深入理解它们之间的区别对于编写高效、可靠的C++代码非常重要。下面是对new、operator new、::new和placement new的深入解析：

1. new操作符

new操作符用于动态分配内存，并调用构造函数初始化对象。它是一个高级操作，封装了内存分配和对象构造两个步骤：

1MyClass* obj = new MyClass(args);

上述代码首先调用operator new函数分配足够的内存来存储MyClass类型的对象，然后在分配的内存上调用MyClass的构造函数，使用args作为参数。

2. operator new函数

operator new是一个全局函数或类成员函数，负责分配内存。当使用new操作符时，背后就是调用operator new来进行内存分配。与new操作符不同，operator new仅分配内存，不负责构造对象：

1void* ptr = operator new(sizeof(MyClass));

可以重载operator new来自定义内存分配策略。

3. ::new

::new指的是全局作用域下的new操作符，用来明确调用全局的operator new函数，而不是某个类的重载版本。这在有重载operator new的情况下很有用，确保调用的是全局版本：

1MyClass* obj = ::new MyClass(args);

4. Placement new

placement new允许在已分配的内存上构造对象。这种方式不分配内存，只调用对象的构造函数。placement new非常有用，特别是在需要在特定位置构造对象的场景中：

1void* ptr = malloc(sizeof(MyClass)); // 先分配内存
2MyClass* obj = new(ptr) MyClass(args); // 在ptr指向的内存上构造对象

需要注意的是，使用placement new时，应当手动调用对象的析构函数，并负责释放内存：

1obj->~MyClass(); // 调用析构函数
2free(ptr); // 释放内存

总结

  • new操作符：高级操作，分配内存并构造对象。
  • operator new函数：底层操作，仅分配内存，可被重载。
  • ::new：使用全局operator new，避免调用类的重载版本。
  • placement new：在指定内存位置构造对象，不分配内存，需要手动管理内存和析构。

理解这些不同的new形式及其用途，可以帮助开发者更有效地管理内存和对象的生命周期，编写出更加精细控制和高效的C++代码。

虚函数表的结构是怎样的？

虚函数表是一个函数指针数组，数组里存放的都是函数指针，指向虚函数所在的位置。 对象调用虚函数时，会根据虚指针找到虚表的位置，再根据虚函数声明的顺序找到虚函数在数组的哪个位置，找到虚函数的地址，从而调用虚函数。

A,B两个类，类中有虚函数。C继承AB，有几张虚函数表？

答：2张

再问：为什么2张？

多继承就会有多个虚函数表。因为每个父类的虚函数是不同的，指针也是不同的。

如果共用一张虚函数表，就分不清到底子类的实例化是针对哪一个基函数的。

为什么不应该在构造函数中调用虚函数

在C++中，父类（基类）的构造函数中调用虚函数是合法的，但这可能不会按照初学者期望的方式工作。在基类构造期间调用虚函数时，并不会调用派生类（子类）中的重写版本，即使是在构造派生类对象的过程中。相反，会调用基类中该虚函数的版本，或者是更上层基类中该虚函数最近的重写版本。这是因为在基类构造期间，对象类型被视为基类类型，而不是派生类类型，从而防止了对尚未完全构造的对象执行操作。

为什么不应该在构造函数中调用虚函数

调用尚未完全构造的对象的成员函数可能会导致未定义行为或错误。如果虚函数依赖于派生类中的某些成员变量，而这些成员变量在基类构造函数被调用时尚未初始化，那么虚函数可能无法正常工作或产生错误结果。

示例

考虑以下示例代码：

 1#include <iostream>
 2
 3class Base {
 4public:
 5    Base() {
 6        callVirtual();
 7    }
 8
 9    virtual void callVirtual() {
10        std::cout << "Base version of callVirtual\n";
11    }
12};
13
14class Derived : public Base {
15public:
16    Derived() : Base() {}
17
18    void callVirtual() override {
19        std::cout << "Derived version of callVirtual\n";
20    }
21};
22
23int main() {
24    Derived d;
25    return 0;
26}

输出将是：

1Base version of callVirtual

尽管Derived对象被构造，但在Base构造函数中调用callVirtual()时，只会调用Base类中的callVirtual()版本，而不是Derived类中重写的版本。

最佳实践

为了避免潜在的错误和混淆，最佳实践是在构造函数和析构函数中避免调用虚函数。如果需要在对象构造期间执行某些操作，并且这些操作需要在派生类中进行特定的实现，考虑使用其他设计模式，如工厂模式，其中对象在完全构造后立即进行初始化，或者通过非虚成员函数调用虚函数，该非虚成员函数在对象构造完成后明确调用。

在构造函数中调用虚函数通常不是一个好的做法，原因主要涉及到对象的构造过程和多态行为的安全性。这里有几个关键点解释了为什么在构造函数中调用虚函数可能会导致问题：

1. 对象构造的阶段性

当创建一个派生类的对象时，对象的构造是按顺序进行的，从基类开始，然后是派生类。在基类的构造函数执行期间，派生类的部分还没有被构造。这意味着，如果在基类构造函数中调用了一个虚函数，该虚函数如果被派生类重写，那么调用的将是基类版本的实现，即使这个调用发生在派生类的构造函数的上下文中。这是因为此时对象的动态类型仍然是基类，而非派生类，C++的多态性在此时还未完全建立。

2. 安全性和一致性

如果虚函数在基类构造期间被调用，并且该虚函数被派生类重写，由于派生类的构造器尚未执行，任何由派生类添加的成员变量都还未被初始化。如果重写的虚函数依赖于这些成员变量，那么它可能会访问未初始化的变量，导致未定义行为或程序错误。

3. 设计上的限制

在构造函数中调用虚函数强加了设计上的限制，即要求派生类在其虚函数实现中只能使用那些在基类构造期间就已经初始化完毕的资源。这限制了派生类设计的灵活性，使得派生类的开发者需要对基类的内部实现细节有深入的了解。

替代方案

为了避免这些问题，通常建议不在构造函数（以及析构函数）中调用虚函数。作为替代，可以考虑以下设计策略：

  • 延迟初始化：通过在构造函数之后显式调用初始化函数来进行操作，这可以确保对象完全构造后再进行多态行为的相关操作。
  • 非虚成员函数调用：在构造函数中调用一个非虚成员函数，该非虚成员函数然后再调用一个虚函数。这样做同样需要小心，以确保不违反上述原则。
  • 设计模式：考虑使用工厂模式或者建造者模式来创建对象，这样可以在对象完全构造好之后再执行需要多态行为的操作。

通过遵循这些指导原则，可以避免在对象构造期间因调用虚函数而可能引入的问题，使得代码更加安全和健壮。

上面都是GPT，下面是人话

对于在构造函数中调用一个虚函数的情况，被调用的只是这个函数的本地版本。也就是说，虚机制在构造函数中不工作。

这种行为有两个理由：

第一个理由是概念上的。

在概念上，构造函数的工作是生成一个对象。在任何构造函数中，可能只是部分形成对象——我们只能知道基类已被初始化，但并不能知道哪个类是从这个基类继承来的。然而，虚函数在继承层次上是“向前”和“向外”进行调用。它可以调用在派生类中的函数。如果我们在构造函数中也这样做，那么我们所调用的函数可能操作还没有被初始化的成员，这将导致灾难发生。

第二个理由是机械上的。

当一个构造函数被调用时，它做的首要的事情之一就是初始化它的VPTR。然而，它只能知道它属于“当前”类——即构造函数所在的类。于是它完全不知道这个对象是否是基于其它类。当编译器为这个构造函数产生代码时，它是为这个类的构造函数产生代码——既不是为基类，也不是为它的派生类（因为类不知道谁继承它）。所以它使用的VPTR必须是对于这个类的VTABLE。而且，只要它是最后的构造函数调用，那么在这个对象的生命期内，VPTR将保持被初始化为指向这个VTABLE。但如果接着还有一个更晚派生类的构造函数被调用，那么这个构造函数又将设置VPTR指向它的VTABLE，以此类推，直到最后的构造函数结束。VRTP的状态是由被最后调用的构造函数确定的。这就是为什么构造函数调用是按照从基类到最晚派生类的顺序的另一个理由。

但是，当这一系列构造函数调用正发生时，每个构造函数都已经设置VPTR指向它自己的VTABLE。如果函数调用使用虚机制，它将只产生通过它自己的VTABLE的调用，而不是最后派生的VTABLE（所有构造函数被调用后才会有最后派生的VTABLE）。另外，许多编译器认识到，如果在构造函数中进行虚函数调用，应该使用早绑定，因为它们知道晚绑定将只对本地函数产生调用。无论哪种情况，在构造函数中调用虚函数都不能得到预期的结果。

静态函数可以是虚函数么？为什么？

static成员不属于任何类对象或类实例，所以即使给此函数加上virutal也是没有任何意义的。

静态与非静态成员函数之间有一个主要的区别。那就是静态成员函数没有this指针。所以无法访问vptr. 进而不能访问虚函数表。

析构函数可以是纯虚函数么？

是的，析构函数可以被声明为纯虚函数（pure virtual destructor）在C++中。这通常用于定义抽象基类（Abstract Base Class，ABC），即这样的类不打算被实例化，而是作为派生类的基础。声明纯虚析构函数的目的是确保基类有一个虚析构函数，允许通过基类指针正确地删除派生类的对象。

纯虚析构函数

当你将析构函数声明为纯虚函数时，你表明了类是抽象的，不能直接实例化，并且你期望从它派生出新的类。但与其他纯虚函数不同，纯虚析构函数必须提供一个定义，因为派生类的析构过程中会调用它。

示例

1class AbstractBase {
2public:
3    virtual ~AbstractBase() = 0; // 纯虚析构函数
4};
5
6AbstractBase::~AbstractBase() {
7    // 必须提供实现，即使是空实现
8}

在这个示例中，AbstractBase有一个纯虚析构函数，使得AbstractBase成为一个抽象基类。尽管析构函数是纯虚的，我们仍然提供了它的定义，这是必须的。

注意事项

  • 即使类中有纯虚析构函数，这个类也需要提供析构函数的定义。这是因为当派生类被销毁时，析构函数的调用会沿着继承链向上进行，最终会调用到基类的析构函数。
  • 如果一个类有纯虚析构函数，它可以没有其他的纯虚函数。但是，这样的类仍然是抽象类，不能直接实例化。
  • 纯虚析构函数的存在不影响派生类的析构函数的实现。派生类应该提供自己的析构函数来确保正确的资源清理。派生类的析构函数会自动调用基类的析构函数。

声明纯虚析构函数是一种表明类是为了被继承而设计，并且不应该直接实例化的方式。同时，它确保了派生类对象通过基类指针被正确销毁的能力，这对于避免内存泄漏等问题至关重要。

定义一个A* pa= new A[5]; delete pa; 类A的构造函数和析构函数分别执行了几次？

构造函数执行了5次，每new一个对象都会调用一个构造函数，析构函数只调用一次，如果调用delete[] pa 析构函数才会调用5次。

reserve和resize的区别是什么？

智能指针有几种？分别介绍一下他们的底层实现？

为什么需要智能指针

你刚才说到循环引用，那你口述一个循环引用的实例。在你说的这个实例中，那你怎么用weak_ptr来解决呢？

说一下lambda表达式的底层实现

C++中的lambda表达式在底层实现上可以被视为一个匿名类（或称为闭包类型）的实例。当编译器遇到lambda表达式时，它会生成一个与lambda行为相匹配的唯一的类类型，这个类会重载函数调用操作符operator()，使得该类的实例（对象）可以像函数那样被调用。这个自动生成的类通常被称为闭包类型，而生成的对象称为闭包对象。

Lambda表达式的组成

一个lambda表达式通常包含三个部分：捕获列表（capture list）、参数列表（parameter list）以及函数体（function body）。例如：

1auto lambda = [capture](parameters) -> return_type { body };

底层实现细节

  1. 闭包类型的生成：对于每个lambda表达式，编译器生成一个唯一的未命名（匿名）类。这个类实现了operator()，使得其对象可以通过函数调用语法使用。

  2. 捕获列表的处理：

    • 值捕获（By Value）：被捕获的变量在闭包对象创建时通过拷贝初始化。每个被捕获的变量都会成为闭包类型的一个数据成员。
    • 引用捕获（By Reference）：通过引用捕获的变量不会被拷贝，相反，闭包对象存储的是变量的引用。
    • 隐式捕获：编译器根据lambda表达式体中使用的外部变量自动生成捕获列表。

  3. 构造函数：闭包类型会有一个构造函数，用于初始化闭包对象中的数据成员。这个构造函数根据捕获列表来定义。

  4. operator()的实现：闭包类型重载的operator()会包含lambda表达式的函数体作为其实现。这个重载允许闭包对象像函数那样被调用。

例子

考虑下面的lambda表达式：

1int x = 4;
2auto lambda = [x](int y) { return x + y; };

编译器会为这个lambda生成类似于以下伪代码的闭包类型：

1class UniqueClosure {
2    int captured_x;
3public:
4    UniqueClosure(int x) : captured_x(x) {}
5    int operator()(int y) const {
6        return captured_x + y;
7    }
8};

然后，lambda变量实际上是UniqueClosure类型的一个实例：

1UniqueClosure lambda(x);

总结

C++中的lambda表达式底层通过生成一个特殊的闭包类型来实现，这个类型重载了函数调用操作符并存储了所有必要的捕获变量，使得lambda表达式既可以捕获周围的上下文，也可以像普通函数那样被调用。这个过程完全由编译器自动完成，对程序员透明。

深拷贝和浅拷贝的区别

讲一下四种类型转换符？

进程间通信

线程间通信

协程是什么？

用户态和内核态区别

死锁产生的原因及四个必要条件

系统调用是什么，有哪些系统调用

孤儿进程、僵尸进程

单核机器上写多线程程序，是否需要考虑加锁，为什么？

静态链接和动态链接

硬链接和软链接

为什么是成倍扩容，而不是等差扩容

:: 范围解析运算符有哪些用法

inline关键字

union关键字

using关键字用法

friend关键字

volatile关键字

为避免对同一对象进行赋值操作，this指针，用法

在C++中，this指针是一个特殊的指针，它指向当前对象。使用this指针的一个常见场景是在成员函数中，特别是在赋值操作符operator=的重载函数中，来避免自赋值的情况。自赋值发生在一个对象被赋值给自身的时候，如果不进行检测，这可能导致意想不到的错误，尤其是在涉及动态内存分配的时候。

下面是如何使用this指针来避免自赋值的一个例子：

 1class MyClass {
 2public:
 3    MyClass& operator=(const MyClass& other) {
 4        // 检查自赋值
 5        if (this == &other) {
 6            // 是自赋值，直接返回*this
 7            return *this;
 8        }
 9
10        // 不是自赋值，执行赋值操作
11        // 例如，释放当前对象持有的资源
12        //delete[] this->data;
13
14        // 然后复制other的数据到当前对象
15        //this->data = new int[...];
16        //std::copy(...);
17
18        return *this; // 返回当前对象的引用
19    }
20};

自赋值检查的工作原理

  • 比较this和&other：通过比较当前对象的this指针和赋值右侧对象的地址&other，可以检查赋值操作是否试图将对象赋值给自身。
  • 提前返回：如果检测到自赋值，函数直接返回*this，避免执行无意义或可能危险的资源释放和重新分配操作。
  • 正常赋值流程：如果不是自赋值，函数则继续执行正常的赋值逻辑，如释放旧资源，分配新资源，复制数据等。

为什么要避免自赋值

在某些情况下，如果不检查自赋值，赋值操作可能会破坏对象的状态。例如，如果赋值操作首先释放了对象持有的资源，然后试图从自身复制这些资源，那么在释放资源之后，对象将尝试从已经被释放的资源复制数据，这将导致未定义行为。

通过在赋值操作中添加自赋值检查，可以保证即使在自赋值的情况下，对象的状态也能保持一致和安全。这是一个良好的编程实践，特别是在处理涉及动态内存管理的复杂类时。

什么是copy on write

模板特化与偏特化

在C++模板编程中，模板特化和偏特化是两种重要的技术，它们允许程序员为模板提供特定类型的实现。虽然它们的目的相似，即为某些特定情况提供定制的模板代码，但它们在使用和概念上有着明显的区别。

模板特化（Template Specialization）

模板特化是指为模板的一个具体类型或类型组合提供一个特定的实现。当模板参数满足特化条件时，编译器会使用特化的实现而不是通用模板。模板特化可以应用于函数模板和类模板。

全特化（Full Specialization）

当为模板的所有参数提供特定的类型时，称之为全特化。

类模板全特化示例：

1template<typename T>
2class MyTemplate { /* 通用实现 */ };
3
4// 全特化为int类型
5template<>
6class MyTemplate<int> { /* 特化实现 */ };

函数模板全特化示例：

1template<typename T>
2void myFunction(T value) { /* 通用实现 */ }
3
4// 全特化为int类型
5template<>
6void myFunction<int>(int value) { /* 特化实现 */ }

模板偏特化（Partial Specialization）

模板偏特化是类模板的一种特殊形式，它允许为模板的一部分参数提供特定的类型，而不是全部参数。注意，函数模板不支持偏特化，偏特化仅适用于类模板。

类模板偏特化示例：

假设我们有一个模板用于处理指针，我们可以为指针类型提供一个偏特化版本：

1template<typename T>
2class MyTemplate { /* 通用实现 */ };
3
4// 偏特化为指针类型
5template<typename T>
6class MyTemplate<T*> { /* 指针类型的特化实现 */ };

在这个例子中，当MyTemplate的模板参数是任何类型的指针时，会使用偏特化版本。

区别总结

  • 全特化：为模板提供一个针对特定类型或类型组合的完全定制的实现。适用于函数模板和类模板。
  • 偏特化：只针对类模板，允许为模板的一部分参数提供特定的类型。它是对模板的进一步泛化，用于处理更具体的情况，但不像全特化那样针对全部参数。

模板特化和偏特化是C++模板编程中强大的特性，允许开发者根据不同的类型参数定制模板的行为，提高了代码的灵活性和可重用性。

为什么函数模板不支持偏特化

写一个宏版本的MIN

auto作为返回值和模板一起怎么用

TCP和UDP区别

C++ 类对象的初始化顺序，有多重继承情况下的顺序

如果三次握手时候每次握手信息对方没收到会怎么样，简答

AVL 和红黑树的差别

数据库事务的特点

虚拟地址如何转为物理地址

说一下滑动窗口，如果接收方滑动窗口满了，发送方会怎么做

页面置换算法

既然有了malloc/free，C++中为什么还需要new/delete呢？

delete[]怎么实现

计算类的sizeof

解决哈希冲突的方式？

结构体内存对齐方式和为什么要进行内存对齐？

调试程序的方法

遇到coredump要怎么调试

成员初始化列表的概念，为什么用成员初始化列表会快一些（性能优势）？

有三种情况是必须使用成员初始化列表进行初始化

常量成员的初始化，因为常量成员只能初始化不能赋值 引用类型 没有默认构造函数的对象必须使用成员初始化列表的方式进行初始化

见：C++ 初始化列表

C++的调用惯例（简单一点C++函数调用的压栈过程）

一个函数或者可执行文件的生成过程或者编译过程是怎样的

定义和声明的区别

被free回收的内存是立即返还给操作系统吗？为什么

引用作为函数参数以及返回值的好处

建立TCP服务器的各个系统调用

TCP和UDP相关的协议与端口号

http的请求方法有哪些？get和post的区别。

TCP三次握手时的第一次的seq序号是怎样产生的

一个机器能够使用的端口号上限是多少，为什么？可以改变吗？那如果想要用的端口超过这个限制怎么办？

对称密码和非对称密码体系

数字证书是什么？

服务器出现大量close_wait的连接的原因以及解决方法

消息摘要算法列举一下，介绍MD5算法，为什么MD5是不可逆的，有什么办法可以加强消息摘要算法的安全性让它不那么容易被破解呢？

介绍一下ping的过程，分别用到了哪些协议

TCP/IP的粘包与避免介绍一下

一个ip配置多个域名，靠什么识别？

DNS的工作过程和原理

ARP协议

关系型和非关系型数据库的区别

说一下 MySQL 执行一条查询语句的内部执行过程？

数据库的索引类型有哪些

说一下事务是怎么实现的

MySQL怎么建立索引，怎么建立主键索引，怎么删除索引？

索引的优缺点，什么时候使用索引，什么时候不能使用索引

索引的底层实现

B树和B+树的区别

Mysql的优化

高频访问

并发优化

索引最左前缀/最左匹配

数据库中事务的ACID

什么是脏读，不可重复读和幻读？

数据库的隔离级别，mysql和Oracle的隔离级别分别是什么

Mysql的表空间方式，各自特点

数据库的范式

乐观锁与悲观锁解释一下

乐观锁与悲观锁是怎么实现的

Linux的I/O模型介绍以及同步异步阻塞非阻塞的区别

文件系统的理解（EXT4，XFS，BTRFS）

什么是IO多路复用

IO复用的三种方法（select,poll,epoll）深入理解，包括三者区别，内部原理实现？

Epoll的ET模式和LT模式（ET的非阻塞）

文件权限怎么看（rwx）

文件的三种时间（mtime, atime，ctime），分别在什么时候会改变

Linux监控网络带宽的命令，查看特定进程的占用网络资源情况命令

怎么修改一个文件的权限

coredump是什么 怎么才能coredump

Linux理论上最多可以创建多少个进程？一个进程可以创建多少线程，和什么有关

冯诺依曼结构有哪几个模块？分别对应现代计算机的哪几个部分？

进程之间的通信方法有哪几种

进程调度方法详细介绍

什么是饥饿

可重入函数是什么

内核空间和用户空间是怎样区分的

同一个进程内的线程会共享什么资源？

brk和mmap是什么

什么是字节序？怎么判断是大端还是小端？有什么用？

写单例模式，线程安全版本

写三个线程交替打印ABC

二维码登录的实现过程

不使用临时变量实现swap函数

找到数组里第k大的数字

Top K问题

B树 B+树

怎么写sql取表的前1000行数据

布隆过滤器

实现一个队列，并且使它支持多线程

100层楼，只有2个鸡蛋，想要判断出那一层刚好让鸡蛋碎掉，给出策略

毒药问题，1000瓶水，其中有一瓶可以无限稀释的毒药，要快速找出哪一瓶有毒，需要几只小白鼠

先手必胜策略问题：100本书，每次能够拿1-5本，怎么拿能保证最后一次是你拿

放n只蚂蚁在一条树枝上，蚂蚁与蚂蚁之间碰到就各自往反方向走，问总距离或者时间。

瓶子换饮料问题：1000瓶饮料，3个空瓶子能够换1瓶饮料，问最多能喝几瓶

在24小时里面时针分针秒针可以重合几次

生成随机数问题：给定生成1到5的随机数Rand5()，如何得到生成1到7的随机数函数Rand7()？

蓄水池采样算法

赛马：有25匹马，每场比赛只能赛5匹，至少要赛多少场才能找到最快的3匹马？

烧 香/绳子/其他 确定时间问题：有两根不均匀的香，燃烧完都需要一个小时，问怎么确定15分钟的时长？

掰巧克力问题 NM块巧克力，每次掰一块的一行或一列，掰成11的巧克力需要多少次？（1000个人参加辩论赛，1V1，输了就退出，需要安排多少场比赛）（快手提前批）

介绍一下Hadoop

说一下MapReduce的运行机制

消息队列是什么

为什么kafka吞吐量高？/介绍一下零拷贝

spark是什么

kafka如何选举leader

斐波那契数列第n项，O(log n)求出

react的特点以及数据流向，diff算法主要做了啥？

内存为什么要分段？分段就只是为了方便程序员吗？

https可以防止DNS劫持吗？

设计一款聊天软件，你打算采用什么方案？

cpu3级缓存

快表（TLB）是什么

http无状态优劣—cookie

什么是局部性原理

rabbitMQ怎么用的

redis怎么用的

数据库中哪些地方用了链表

HTTP了解吗，怎么样不用框架用原生语言解析请求的Json数据

怎么样用数据结构和算法写一个定时器

tcp是怎么样超时重传的

MQTT

webserver 项目中如果所有线程都在工作，收到请求怎么做？

python routine

自己写一个协程控制器，包括添加协程，暂停等功能

写个生产者消费者模型

线程安全的数据结构

线程池的创建方法

C++反射是什么

https加密协商出来的密钥的类型是什么

海量数据问题

https://wangpengcheng.github.io/2019/12/17/hailiangshuju_problems/

C++问题大全

https://zhuanlan.zhihu.com/p/603532168