C++

内存分区

4个区

• 代码区：存放函数体的==二进制代码==，由操作系统进行管理的
• 全局区：存放全局变量、静态变量、==常量==
• 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等
• 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收

5个区

• 代码区：存放函数体的二进制代码，由操作系统进行管理的
• 全局区：存放全局变量和静态变量以及常量
• 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等
• 自由存储区：由存储区是 C++ 的一个概念，特指通过 new 和 delete 操作符在 C++ 中分配和释放的内存区域。
• 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收

堆和栈在效率上有啥区别

栈（Stack）

1. 内存分配和释放速度快：
   • 栈是一个连续的内存区域，内存分配和释放的过程是基于栈指针的简单移动，通常在O(1)时间内完成。
   • 内存分配通过递增栈指针来实现，释放则通过递减栈指针来实现，不需要复杂的内存管理操作。
2. 高效的缓存局部性：
   • 由于栈是连续分配的，栈上分配的内存具有较好的缓存局部性，能更有效地利用CPU缓存，从而提高程序的执行效率。
3. 生命周期自动管理：
   • 栈上的变量在函数调用结束时自动释放，无需程序员手动管理，有效减少内存泄漏的风险。
4. 空间限制：
   • 栈的大小通常是有限的，受限于操作系统或编译器设置。如果栈空间耗尽，会导致栈溢出（Stack Overflow）错误。

堆（Heap）

1. 灵活的内存管理：
   • 堆允许动态内存分配，程序可以在运行时根据需要分配和释放内存，灵活性更高。
   • 适用于需要动态调整内存大小的数据结构，如链表、树、图等。
2. 内存分配和释放速度慢：
   • 堆的内存分配和释放需要更复杂的管理操作，如查找空闲块、合并碎片等，通常比栈的操作要慢。
   • 分配和释放的时间复杂度一般不是固定的，具体取决于内存管理算法。
3. 较差的缓存局部性：
   • 堆上的内存分配是离散的，可能会导致内存碎片化，从而影响缓存的局部性和程序的执行效率。
4. 生命周期由程序员管理：
   • 堆上的内存需要程序员显式分配和释放，容易导致内存泄漏或重复释放的问题。
   • 现代编程语言和环境提供了垃圾回收机制来帮助管理堆内存，但这也可能带来额外的性能开销。

总结

• 栈适用于生命周期较短、大小固定的局部变量和函数调用，具有高效的内存分配和释放速度，以及较好的缓存局部性，但受限于有限的栈空间。
• 堆适用于需要动态内存分配的复杂数据结构，提供更大的灵活性，但内存管理操作较复杂，可能影响性能，且需要程序员小心管理内存的分配和释放。

什么样的数据在栈区，什么样的在堆区

栈区主要用于存储局部变量、函数参数、返回地址、以及函数调用的上下文信息。

堆区用于动态分配内存，也就是通过new或malloc等函数显式分配的内存。

如何用代码判断栈的增长方向

可以通过参数的入栈顺序，一般从右往左，但是由于编译器的不同，可能会不符合预期。但是函数的调用栈是肯定的，因此我们可以打印函数调用栈中变量的地址去查看

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include<bits/stdc++.h>

using namespace std;

void func2(int a)
{
    printf("%p\n", &a);
}

void func1(int a)
{
    printf("%p\n", &a);
    func2(a);
}
int main()
{
    int a = 10;
    func1(a);
}

/*
0x7fff4193ee5c
0x7fff4193ee3c
*/

/func1先调用，因此在高地址，func2后调用，其a在低地址，因此可以判断出栈从高往低

C++怎么从源码到可执行程序的过程

C++从源码到可执行程序的过程主要包括以下四个步骤：

1. 预处理（Preprocessing）：预处理器会处理C++源代码文件中的预处理指令，如#include和#define。它会替换#include指令为相应文件的内容（通常只是声明），替换宏定义（#define），并根据#if、#ifdef和#ifndef指令选择不同的文本部分。预处理器对一个C++源文件进行操作，生成一个单一的输出，这是一个由上述转换产生的标记流。变成.i文件 gcc -E source.c -o source.i
2. 编译（Compilation）：编译步骤在每个预处理器的输出上执行。编译器解析纯C++源代码（现在没有任何预处理指令），并将其转换为汇编代码。 变成汇编代码.s文件gcc -S source.i -o source.s
3. 汇编（Assembling）：将汇编代码翻译成机器代码，生成目标文件，是二进制格式的（.o或.obj）gcc -c source.s -o source.o
4. 链接（Linking）：链接器接收由编译器产生的目标文件，并生成库或可执行文件。链接过程中，链接器会解析目标文件中的符号引用，并将这些引用与其他目标文件或库（标准库，动态链接库）中定义的符号进行链接。

交叉编译

交叉编译（Cross-Compilation）是指在一种平台上编译代码，以生成能够在另一种不同平台上运行的可执行文件的过程。这种编译方式通常用于目标平台和开发平台之间存在硬件架构或操作系统的差异。

静态库和动态库的区别

1. 静态库（Static Library）

• 文件扩展名：在Windows上通常是.lib，在Linux上通常是.a。
• 编译链接时的行为：当程序被编译链接时，静态库中的代码会被完整地复制到最终的可执行文件中。这个过程是在编译时完成的，因此最终的可执行文件包含了所有必需的库代码。
• 运行时的行为：静态库的代码成为了可执行文件的一部分，这意味着在程序运行时，不需要额外的库加载。
• 优点：不需要在运行时加载额外的库文件，启动速度快，不会出现库版本不兼容的问题。
• 缺点：增加了可执行文件的大小，更新库时需要重新编译链接整个程序。

2. 动态库（Dynamic Library）

• 文件扩展名：在Windows上通常是.dll，在Linux上通常是.so。
• 编译链接时的行为：动态库在编译时不被复制到可执行文件中。相反，程序存储了对动态库中函数和变量的引用。
• 运行时的行为：当程序运行时，操作系统负责加载动态库文件。如果库文件在系统上可用，程序就可以使用库中的代码；否则，程序启动会失败。
• 优点：可执行文件大小较小，易于更新和维护库文件，多个程序可以共享同一动态库的单个实例，节约内存。
• 缺点：启动时需要加载库，可能会稍慢；依赖于正确版本的库文件在运行时的可用性，可能存在库文件缺失或版本冲突的问题。

程序运行起来以后静态库和动态库在内存中哪里

静态库：代码会复制到可执行文件中，存储在代码段

动态库：动态库（动态链接库中的代码段，数据段，BSS 段）会被加载到文件映射与匿名映射区（共享区）

如何查看程序依赖的库？

1. 使用 ldd 命令查看依赖库

ldd 命令可以列出可执行文件所依赖的共享库。

1

ldd a.out

2. 使用 objdump 命令查看依赖库

objdump 是一个强大的工具，可以显示可执行文件的各种信息。使用 objdump 查看动态依赖库：

1

objdump -p a.out

全局变量和局部变量的区别

全局变量和局部变量的主要区别在于它们的作用域、生命周期、初始化和位置。

全局变量：

• 全局变量在程序的整个生命周期内都是有效的，可以在程序的任何地方被访问。
• 全局变量在程序开始时被创建，在程序结束时被销毁。
• 如果全局变量没有被初始化，它们会被自动初始化为零（对于数字类型）或者空（对于某些其他类型）。
• 全局区

局部变量：

• 局部变量只在定义它们的函数或代码块内部有效。
• 局部变量在进入函数或代码块时被创建，在离开函数或代码块时被销毁。
• 局部变量必须在使用前被明确地初始化。
• 栈区

注意，过度使用全局变量可能会导致代码难以理解和维护，因为全局变量可以在程序的任何地方被修改。相反，局部变量的使用范围受到限制，这有助于理解和跟踪它们的使用情况。

函数调用的参数是怎么入栈的，为什么？

函数调用时，参数的入栈过程主要取决于调用约定（calling convention），这是编译器和系统共同遵循的一套规则。

在典型的调用约定下，函数的参数按照从右到左的顺序依次入栈。

原因：

支持可变参数函数：

• 可变参数函数（如 printf）可以接受不确定数量的参数。通过从右到左入栈，编译器可以确保第一个固定参数位于栈顶附近，这样可以方便地访问后续的可变参数。在C语言中，处理变长参数的机制是通过 va_list、va_start、va_arg 和 va_end 宏来实现的。

  例如：

  1	int printf(const char *format, ...);

  format 参数在最上面，因此函数可以从已知的位置开始处理可变数量的参数。

函数调用的过程

栈帧

我们调用的函数执行完之后，需要返回。需要在栈帧中存一个返回的位置，也就是返回之后应该执行哪条指令。

此外，有两个专门的寄存器来标记当前函数栈帧的起始地址和结束地址，如果是 64 位的机器，那就是 rbp 和 rsp，而 32 位机器的是 ebp 和 esp。

调用函数时栈帧的变化

1. 在调用一个函数时，我们先把函数的返回地址（也就是执行调用时 pc的值）压入栈中。
2. 为了确保返回时能恢复当前帧指针的状态，还需要把帧指针压入栈中。
3. 做完了准备工作，可以加入被调用函数的栈帧了。新栈帧当前还没有存放任何数据，所以起始地址和结束地址都是旧栈帧的结束地址。为了达到这一点，需要把帧指针的值（新栈帧起始值）设置成栈指针（老栈帧结束值）的值。
4. 现在要把数据存入新栈帧，首先会需要更新栈指针的值，扩大栈的范围，因为栈帧是向低地址增长的，所以要根据局部变量及参数的大小，把栈指针的值减小一些。
5. 栈帧已经有了足够的空间，可以放入局部变量并且执行这个函数了。至此，新栈帧的插入完全完成。

函数返回时栈帧的变化

1. 函数返回首先要释放之前占用的所有内存，所以我们直接把栈指针设置成帧指针。也就是把栈帧的结束地址直接改成开始地址，相当于撤销调用函数时的第 4 步。
2. 现在需要用到之前备份的原帧指针来恢复函数调用之前的状态。我们需要从栈中弹出这个原帧指针，然后复制到帧指针寄存器。
3. 弹出返回地址，赋值到 pc。
4. 根据 pc 的值，继续执行原函数。

char *和char []的区别

1
2

char *s1 = "hello";
char s2[] = "hello"

1. char *指向一个字符串常量，在只读数据段中，因此不能修改，而char []在栈上，可以修改

2. 大小，sizeof后，s1是指针，32位是4B，s2为6B，因为包含\0

3. 自增，由于s1是指针，可以通过自增移动指针，而s2数组名是地址常量，不能自增

4. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

   char *fun() { char *s1 = "hello"; char s2[] = "hello" 可以return s1,不能return s2，因为s1在静态存储区，生命周期直到程序结束，而s2是一个局部变量 } #include <bits/stdc++.h> using namespace std; char* mymalloc1() { char p[] = "abcd"; return p; } char* mymalloc2() { char *p = "abcd"; return p; } int main(void) { char* a = nullptr; char* b = nullptr; a = mymalloc1(); b = mymalloc2(); printf("%s", a); cout << endl; printf("%s", b); return 0; } /* (null) abcd */

四种强制类型转换

const_cast：用于移除或者添加const或volatile修饰符

static_cast：1. 代替隐式转换 2. 基类与派生类的转换：派生类转基类的安全的，基类转派生类是不安全的，因为子类内容比父类多

dynamic_cast：多用于有虚函数的基类和派生类之间的转换。用于类层次间的上下转换，在进行下转时，相比于static_cast，dynamic_cast具有类型检查，更安全

reinterpret_cast：用于进行低级别的类型转换，通常用于将指针类型转换为其他指针类型，或将指针转换为整数类型及其反向转换。适用于需要对二进制表示进行重新解释的场景。【不会进行安全类型检查】

大小端的区别以及各自的优点，哪种时候用

大小端（Big-endian 和 Little-endian）是计算机存储数据时的一种字节序排列方式，决定了多字节数据在内存中存储的顺序。以下是详细解释：

大端（Big-endian）

定义：

• 在大端模式下，多字节数据的最高有效字节（Most Significant Byte，MSB）存储在内存的低地址处，而最低有效字节（Least Significant Byte，LSB）存储在内存的高地址处。

示例： 假设我们有一个 32 位的整数 0x12345678，它在内存中的存储方式如下：

1
2
3
4
5
6

diff复制代码地址      | 值
----------|----
0x00      | 0x12
0x01      | 0x34
0x02      | 0x56
0x03      | 0x78

小端（Little-endian）

定义：

• 在小端模式下，多字节数据的最低有效字节（LSB）存储在内存的低地址处，而最高有效字节（MSB）存储在内存的高地址处。

示例： 同样假设我们有一个 32 位的整数 0x12345678，它在内存中的存储方式如下：

1
2
3
4
5
6

diff复制代码地址      | 值
----------|----
0x00      | 0x78
0x01      | 0x56
0x02      | 0x34
0x03      | 0x12

优点与应用场景

大端（Big-endian）

优点：

• 大端存储符合人类的自然阅读习惯，即从高位到低位读取数据。
• 在网络协议中，使用大端存储方式更容易进行数据交换，因为网络字节序通常是大端（称为“网络字节序”）。

应用场景：

• 网络通信：大端被广泛应用于网络协议中，如IP地址、端口号等。这种一致性使得不同计算机架构之间的数据交换更为简单。
• 跨平台数据交换：在不同系统之间进行数据传输时，使用大端可以减少数据转换的复杂性。

小端（Little-endian）

优点：

• 小端存储在某些处理器上（如x86架构）进行整数计算时更高效，因为最低有效字节可以直接用于操作。
• 小端模式下，扩展数据类型（如将16位扩展为32位）时，可以保持低地址处的数据不变，提高了内存操作的效率。

应用场景：

• 通用计算：许多PC和服务器使用的小端架构（如x86、AMD64）在进行常规计算时效率更高。
• 嵌入式系统：一些嵌入式设备使用小端存储方式以优化性能。

选择使用哪种字节序

• 网络协议和跨平台通信：大端（网络字节序）通常被选择，以确保不同平台之间的数据一致性。
• 系统架构和性能优化：小端在许多计算平台上（如x86架构）被广泛使用，因为它在处理器操作中效率更高。

如何判断计算机使用大端还是小端

将1的地址强转为字符类型，如果第一个字节的值是1，那么就是小端，否则大端

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <stdio.h>

int main() {
    unsigned int num = 1;
    char *ptr = (char*)&num;
    // char* p = reinterpret_cast<char*>(&num);

    if (*ptr) {
        printf("Little Endian\n");
    } else {
        printf("Big Endian\n");
    }

    return 0;
}

大小端如何转换

1. 手动交换：第1、4个字节交换，2、3字节交换
2. 使用库函数：可以使用标准库函数如 htons（Host to Network Short）和 htonl（Host to Network Long），来将主机字节序（一般为小端）转换为网络字节序（大端）。相应的函数 ntohs 和 ntohl 可以将网络字节序转换回主机字节序。

数据类型

int

• 类型：有符号整数类型。
• 大小：通常为4字节（32位），但在某些系统上可能不同。
• 范围：通常为 -2,147,483,648 到 2,147,483,647（即 -2^31 到 2^31 - 1）。
• 用途：表示可以为正数、负数或零的整数。

unsigned int

• 类型：无符号整数类型。
• 大小：通常为4字节（32位），但在某些系统上可能不同。
• 范围：通常为 0 到 4,294,967,295（即 0 到 2^32 - 1）。
• 用途：表示仅为非负整数的数值。在表示计数和索引等永远不会为负的情况下使用。

long long

• 类型：有符号长长整数类型。
• 大小：通常为8字节（64位），但在某些系统上可能不同。
• 范围：通常为 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807（即 -2^63 到 2^63 - 1）。
• 用途：表示可以为正数、负数或零的较大整数，通常在需要大范围整数的计算中使用。

unsigned long long

• 类型：无符号长长整数类型。
• 大小：通常为8字节（64位），但在某些系统上可能不同。
• 范围：通常为 0 到 18,446,744,073,709,551,615（即 0 到 2^64 - 1）。
• 用途：表示仅为非负的较大范围的整数。用于需要大范围的计数、索引或存储大数的场景。

有符号整数溢出

无符号整数（如 unsigned int 和 unsigned long long）在溢出时会自动取模。无符号整数表示非负整数，其存储和操作是基于直接的二进制表示法。例如，unsigned int 类型在大多数系统上是32位宽，表示范围是 0 到 232−12^{32} - 1232−1。计算时，所有操作都是基于模 2N2^N2N 算术（其中 NNN 是位宽），这意味着任何超过最大值的结果都会被自动取模。

无符号整数溢出

有符号整数（如 int 和 long long）在溢出时的行为是未定义的。这是因为有符号整数使用二进制补码（two’s complement）来表示，包括一个符号位。二进制补码允许使用简单的硬件进行加减运算，并且符号位影响结果。例如，32位 int 类型的表示范围是 −231-2^{31}−231 到 231−12^{31} - 1231−1。溢出发生时，结果不一定是合理的整数，可能会被解释为负数，甚至可能导致不可预测的行为，如程序崩溃。

原码，反码，补码的区别

1. 原码 (Sign-Magnitude)

原码是一种最直观的表示法，使用最高位表示符号位，其余位表示数值。

• 符号位：最高位（最左边的一位）表示符号，0表示正数，1表示负数。
• 数值位：剩余的位表示数值的绝对值。

2. 反码 (One’s Complement)

• 正数：与原码相同。
• 负数：反码通过将数值的每一位取反（即0变1，1变0）来表示负数。

反码有一个问题，即有两个表示零的方式：

• +0 的反码表示：00000000
• -0 的反码表示：11111111

3. 补码 (Two’s Complement)

补码是目前计算机系统中最常用的表示法，它通过对反码加1来表示负数。

• 正数：与原码相同。
• 负数：反码加1。

补码只有一个零的表示方式：

• +0 和 -0 的补码均表示为：00000000， 解决了双0问题

为什么补码是计算机最常用的？

1. 统一的零表示

在补码表示法中，零只有一种表示形式，即 00000000。这消除了反码表示法中正零和负零两种表示的矛盾，简化了硬件和软件的实现。

2. 简化的加减运算

补码表示法使得加法和减法运算可以使用同一套电路进行：

想要把减法转化成加法运算，就需要在运算时带着符号一起运算，而反码和补码可以带符号位一起运算，也就方便了将减法转换为加法。

3. 自动处理溢出和溢出检测

自动处理溢出：补码表示法能够自动处理溢出问题。在加减法运算中，任何溢出都会被最高位的进位丢弃，而不会影响结果的正确性。比如无符号类型

溢出检测：两个正数相加得到负数（正溢出），或者两个负数相加得到正数（负溢出），有符号类型

4. 对称的范围

补码表示法提供了对称的数值范围，正负数的范围几乎相等。

对于n位补码表示法：

• 正数范围：$0$ 到 $2^{n - 1} - 1$
• 负数范围：$-1$ 到 $-2^{n - 1}$

例如，8位二进制数：

• 正数范围：0 到 127
• 负数范围：-1 到 -128

指针和引用

指针和引用的区别

指针：就是存放某个对象的地址，本身就是变量， 所以可以有指向指针的指针，可变。

引用：就是变量的别名，从一而终，不可变，==必须初始化==，引用的本质就是指针常量，代表这个指针是一个常量，即地址是不可改变的。

1. sizeof运算结果：sizeof对指针操作得到的是指针本身的大小；对引用操作得到的是所引用对象的大小。
2. 自增运算意义不同：对于指针，自增操作会使其指向下一个内存单元；对于引用，自增操作会改变其所引用对象的值。

指针和引用的内存占用

指针是一个变量，它存储另一个变量的内存地址。指针的大小通常取决于所运行的系统架构：

• 在32位系统上，指针通常占用4个字节（32位）。
• 在64位系统上，指针通常占用8个字节（64位）。

无论指针指向的数据类型是什么，指针本身的大小是固定的，只取决于系统架构。

例如：

1
2
3

int* intPtr;
double* doublePtr;
char* charPtr;

在32位系统上，这些指针都占用4个字节。在64位系统上，它们都占用8个字节。

引用的内存占用

引用实际上是占空间大小的，本质就是一个指针常量，因此通常大小和指针一样。

但是通过sizeof来看话，对于一个普通变量而言，那么通常就是这个变量的大小。对于一个结构体而言，通常和指针的大小一样

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include<bits/stdc++.h>

using namespace std;

struct A{
    int a;
    double b;
    A(int _a, int _b):a(_a), b(_b){}
}; //结构体大小为16

int main()
{
    int t = 10;
    int &k = t;
    cout << sizeof t << " " << sizeof k << endl; // 4 4 
    A a(0, 0);
    cout << sizeof &a << " " << sizeof a << endl; // 8 16
    return 0;
}

但是通过sizeof去判断引用的大小是不对的。需要通过size命令去查看 size a.out

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include<iostream>

using namespace std;


int main()
{
    int x = 10;
    // int &t = x;
}

/*
   text    data     bss     dec     hex filename
   1816     640       8    2464     9a0 a.out
*/

int main()
{
    int x = 10;
    int &t = x;
}

/*
   text    data     bss     dec     hex filename
   1988     648       8    2644     a54 a.out
*/

可以看出引用占了8个字节，就是指针的大小

指针和引用自增的区别

指针的自增

指针的自增操作（++）会使指针指向下一个元素，这个下一个元素的地址由指针所指向的数据类型决定。指针增加的步长是它所指向的数据类型的大小。

例如：

1
2
3
4
5
6

int arr[] = {1, 2, 3, 4, 5};
int* ptr = arr; // 指向数组的第一个元素

std::cout << "ptr: " << ptr << ", *ptr: " << *ptr << std::endl;
ptr++; // 指向下一个元素
std::cout << "ptr: " << ptr << ", *ptr: " << *ptr << std::endl;

在这段代码中，ptr 初始时指向数组的第一个元素，ptr++ 会使 ptr 指向数组的下一个元素。如果 int 是4字节，那么 ptr 自增后会增加4个字节。

引用的自增

引用本质上是一个变量的别名，自增引用其实是在自增这个变量本身。也就是说，自增操作是对变量进行的，而不是对引用进行的。

例如：

1
2
3
4
5
6

int a = 10;
int& ref = a; // 引用a

std::cout << "a: " << a << ", ref: " << ref << std::endl;
ref++; // 增加a的值
std::cout << "a: " << a << ", ref: " << ref << std::endl;

在这段代码中，ref++ 实际上是 a++，即增加变量 a 的值。因此，引用的自增只是增加它所引用的变量的值，并不改变引用本身的指向（因为引用不能改变其引用的对象）。

什么是野指针，怎么产生的，如何避免？

野指针是指向"垃圾"内存的指针，也就是说，它的值是不确定的。野指针通常由以下几种情况产生：

1. 未初始化的指针：如果你声明了一个指针变量但没有给它赋值，那么它就是一个野指针。例如：int *ptr;。

2. 已删除的指针：如果你使用delete或free删除了一个指针，但没有将它设置为NULL，那么它就成了一个野指针(悬挂指针)。例如：

   1 2	int *p = (int*)malloc(sizeof(int)); free(p); // p 现在是一个野指针

3. 超出作用域的指针：如果你返回了一个函数内部的局部变量的地址，那么这个地址在函数返回后就不再有效，因此返回的指针就是一个野指针。或者超出了数组的范围

   1 2 3

   int arr[10]; int *p = arr; p = p + 20; // 超出数组范围，p 现在是一个野指针

为了避免野指针，你可以遵循以下几个原则：

• 初始化你的指针：当你声明一个新的指针时，总是给它一个初始值。这个值可以是一个已经分配的地址，或者是NULL。
• 删除后置空：当你删除一个指针后，立即将它设置为NULL。这样，即使你再次使用这个指针，程序也不会崩溃。
• 不要返回局部变量的地址：函数返回后，局部变量的内存会被回收，所以永远不要试图返回一个局部变量的地址。
• 使用智能指针（C++）：C++11 引入了智能指针，如 std::unique_ptr 和 std::shared_ptr，可以自动管理内存，避免手动释放内存带来的错误。

const关键字

1. 修饰变量：说明该变量不可以被改变，==必须在定义时初始化==
2. 修饰指针：1.常量指针：指针指向的==对象不可改变== const int * | int const *，不可通过解引用来改变值，但可以通过其他方法 2.指针常量： 表示==指针不可改变==int * const
3. 修饰引用：指向常量的引用（reference to const），用于形参类型，即避免了拷贝，又避免了函数对值的修改；
4. 修饰成员函数：说明该成员函数内不能修改成员变量，除非成员属性声明时加上mutable，在const修饰的成员函数中仍可以修改
5. 修饰对象：常对象只能调用const修饰的函数，即常成员函数

mutable的作用

mutable是C++中的一个关键字，用于修饰类的成员变量，表示该成员变量即使在一个const成员函数中也可以被修改。

mutable的中文意思是“可变的，易变的”，跟constant（既C++中的const）是反义词

因为在C++中，如果一个成员函数被声明为const，那么它不能修改类的任何成员变量，除非这个成员变量被声明为mutable。

关键用途：即允许在const成员函数中修改特定的成员变量，以支持内部实现所需的功能（比如缓存），同时仍然保持外部不变性。

#define和typedef

宏可以递归吗

宏表达式中不能出现递归定义，这点区别于函数，因为宏只做简单的文本替换，且只替换一次，如果出现递归定义，就会无法被完全替换，导致后续编译时原宏名被当作未定义的函数而报错；

如何防止头文件重复定义？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 使用 #ifndef
#ifndef HEADER_FILE_NAME_H
#define HEADER_FILE_NAME_H

// 头文件内容

#endif // HEADER_FILE_NAME_H

// 使用#pragma once
// myheader.h
#pragma once

// 头文件的内容
#define MAX_SIZE 100

// 函数声明
void myFunction();

第一行#ifndef表示如果没有定义HEADER_FILE_NAME_H，那么就执行下面的逻辑。

第二行定义一个宏，防止头文件重复包含。第一次包含头文件的时候，宏被定义。后面重复定义，就会跳过

#pragma once 通知编译器，即使这个头文件在其他地方被多次包含，也只会处理一次。

static

1. 修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在 main 函数运行前就分配了空间，如果有初始值就用初始值初始化它，如果没有初始值系统用默认值初始化它。
   1. 如果修饰的是函数内的局部变量，那么生命周期从它第一次被初始化的时刻延续到程序结束。这意味着该变量的值在函数调用之间会保 持不变。静态局部变量只在第一次函数调用时初始化一次。即使多次进入函数，初始化代码也只执行一次。这对于确保某些计算或设置只进行一次非常有用。
   2. 如果修饰的是全局变量，它的主要作用是修改该变量的链接属性（linkage）：默认情况下，全局变量在整个程序中都是可见的，也就是说，其他文件中的代码可以通过外部声明（extern）来访问它。但如果一个全局变量被声明为 static，它的链接属性变为内部的（internal linkage），意味着这个变量只在它被声明的文件中可见，不能被其他文件访问。
2. 修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命名空间里的函数重名，可以将函数定位为 static。
3. 修饰成员变量，修饰成员变量使所有的对象只保存一个该变量，而且不需要生成对象就可以访问该成员。在编译阶段分配内存，==类内声明，类外初始化==
4. 修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在 static 函数内不能访问非静态成员，只能访问==静态成员变量==

全局变量和static的区别

全局变量和static变量的主要区别在于它们的作用域和生命周期。

全局变量：

• 全局变量在整个程序中都是可见的，可以在程序的任何地方被访问。
• 全局变量在程序开始时被创建，在程序结束时被销毁。
• 如果全局变量没有被初始化，它们会被自动初始化为零（对于数字类型）或者空（对于某些其他类型）。

static变量：

• static变量的生命周期是整个程序执行期间，但其作用域仅限于定义它的函数或代码块。
• static变量在程序开始时被创建，在程序结束时被销毁。
• 如果static变量没有被初始化，它们会被自动初始化为零（对于数字类型）或者空（对于某些其他类型）。

总的来说，全局变量和static变量的主要区别在于它们的作用域。全局变量可以在整个程序中使用，而==static变量只能在定义它的函数或代码块中使用==。然而，两者都有相同的生命周期，即在程序执行期间一直存在。

final关键字

final修饰类

当一个类被声明为 final 时，这个类不能被继承。这意味着该类的设计已经完成，任何试图继承它的行为都会导致编译错误。

1
2
3
4
5
6
7
8

class Base final {
    // 类的内容
};

// 下面的代码会导致编译错误
class Derived : public Base {
    // 错误：Base 类是 final 的，不能继承
};

final修饰虚函数

当一个虚函数被声明为 final 时，派生类不能重写这个虚函数。这样做的目的是防止派生类改变基类的特定行为。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Base {
public:
    virtual void display() final {
        // 基类中的实现
    }
};

class Derived : public Base {
public:
    // 下面的代码会导致编译错误
    void display() override {
        // 错误：display 函数在基类中是 final 的，不能重写
    }
};

final通常和override一起使用，可以显示的指出该函数是覆盖了基类中的某个函数，并且不允许在被派生类覆盖

new和malloc的区别

new和malloc都是C++中用于动态分配内存的方法，但它们之间存在一些重要的区别：

1. 函数与操作符：new是一个操作符，而malloc是一个函数。
2. **构造函数的调用：**new会调用构造函数，而malloc不会。实际上，原始数据类型（如char、int、float等）也可以使用new进行初始化。
3. 返回类型安全性：new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。
4. 内存分配失败时的返回值：new内存分配失败时，会抛出bac_alloc异常，它不会返回NULL；malloc分配内存失败时返回NULL。
5. **内存分配位置：**new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。

在C++的术语中，我们通常说new操作符在自由存储区（free store）上为对象动态分配内存。自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。

自由存储区的位置取决于operator new的实现。自由存储区不仅可以为堆，还可以是静态存储区，这都看operator new在哪里为对象分配内存。

所以，当我们说"new在自由存储区上分配内存"时，我们实际上是在说"new在堆上分配内存"，因为在大多数情况下，自由存储区就是堆。

1. 是否需要指定内存大小：使用new操作符申请内存分配时无需指定内存块的大小，编译器会根据类型信息自行计算，而malloc则需要显式地指出所需内存的尺寸。
2. 对数组的处理：C++提供了new []与delete []来专门处理数组类型。使用new []分配的内存必须使用delete []进行释放。new对数组的支持体现在它会分别调用构造函数函数初始化每一个数组元素，释放对象时为每个对象调用析构函数。而malloc并不知道你在这块内存上要放的数组还是啥别的东西。

总的来说，你应该根据你的需求来选择使用哪个函数。如果你需要分配一块可以容纳特定类型对象的内存，并希望自动调用构造函数和析构函数，那么应该使用new。如果你只是需要分配一定数量的字节，并且不需要自动调用构造函数和析构函数，那么可以使用malloc。

C++中有几种类型的new

在C++中，new有三种典型的使用方法：plain new，nothrow new和placement new

• plain new：plain new在空间分配失败的情况下，抛出异常std::bad_alloc而不是返回NULL
• nothrow new：nothrow new在空间分配失败的情况下是不抛出异常，而是返回NULL
• placement new：这种new允许在一块已经分配成功的内存上重新构造对象或对象数组。placement new不用担心内存分配失败，因为它根本不分配内存，它做的唯一一件事情就是调用对象的构造函数。使用placement new需要注意两点：
  • palcement new的主要用途就是反复使用一块较大的动态分配的内存来构造不同类型的对象或者他们的数组
  • placement new构造起来的对象数组，要显式的调用他们的析构函数来销毁（析构函数并不释放对象的内存），千万不要使用delete，这是因为placement new构造起来的对象或数组大小并不一定在堆上，可能是栈或者静态存储区，不能通过delete删除

delete、delete[]、allocator区别

• delete：用于释放由 new 运算符分配的单个对象的内存。它会调用对象的析构函数，然后释放内存。
• delete[]：用于释放由 new[] 运算符分配的数组的内存。它会依次调用数组中每个元素的析构函数，然后释放整个数组的内存。数组中的元素按逆序的顺序进行销毁；
• new在内存分配上面有一些局限性，new的机制是将内存分配和对象构造组合在一起，同样的，delete也是将对象析构和内存释放组合在一起的。allocator将这两部分分开进行，allocator申请一部分内存，不进行初始化对象，只有当需要的时候才进行初始化操作。

malloc、calloc、reallock区别

malloc(size_t size)：分配的内存空间未初始化，其内容是随机的。需要手动计算所需内存大小。

calloc(size_t num, size_t size)：在堆上分配 num 个大小为 size 的连续内存块，并初始化为全零。

realloc(void *ptr, size_t new_size)：重新分配一块内存。可以扩大或缩小 ptr 指向的内存块的大小。

如果 new_size 大于原来的大小，则会尝试在原内存块之后分配额外的内存，并保证原有数据不变。如果原内存不够，那么找到一块新的size大小内存，拷贝旧数据，释放旧空间，返回新指针

如果 new_size 小于原来的大小，则会缩小内存块，但超出新大小的部分数据将会丢失。

如果 ptr 为 NULL，则相当于调用 malloc(new_size)。

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

malloc/free和new/delete都是用来申请内存和回收内存的。

对于非内部数据对象(eg：类对象)，只用malloc/free无法满足动态对象的要求。这是因为对象在创建的同时需要自动执行构造函数，对象在消亡之前要自动执行析构函数，而由于malloc/free是库函数而不是运算符，不在编译器的控制权限内，也就不能自动执行构造函数和析构函数。因此，不能将执行构造函数和析构函数的任务强加给malloc/free。所以，在c++中需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理和释放内存工作的运算符delete。

new建立的是一个对象，malloc分配的是一块内存区域，用指针来访问，并且可以在区域里面移动指针；

this指针

1. 由于类内的成员变量和成员函数是分开存储的。每个对象都有自己的成员变量空间（不包括static变量），但是对象是不包括成员函数的，一==个类的所有对象共享同一组成员函数==，意味着成员函数在内存中只有一份拷贝，那么成员函数是如何知道哪个对象调用的他？this 指针是一个隐含于每一个非静态成员函数中的特殊指针。它指向调用该成员函数的那个对象。
2. 当对一个对象调用成员函数时，编译程序先将对象的地址赋给 this 指针，然后调用成员函数，每次成员函数存取数据成员时，都隐式使用 this 指针。
3. 当一个成员函数被调用时，自动向它==传递一个隐含的参数==，该参数是一个指向这个成员函数所在的对象的指针。
4. this 指针被隐含地声明为: ClassName *const this，这意味着不能给 this 指针赋值；在 ClassName 类的 const 成员函数中，this 指针的类型为：const ClassName* const，这说明不能对 this 指针所指向的这种对象是不可修改的（即不能对这种对象的数据成员进行赋值操作）；
5. this 并不是一个常规变量，而是个==右值==，所以不能取得 this 的地址（不能 &this）。
6. this指针存储在寄存器中，ECX寄存器
7. this指针可以为空，当函数内部不需要用到this指针的时候
8. 当创建一个对象时，编译器会初始化一个this指针，指向创建的的对象。也就是new的时候分配了一段内存，此时this指针就已经被初始化了。
9. 在以下场景中，经常需要==显式引用==this指针：
   1. 为实现对象的链式引用；
   2. 为避免对同一对象进行赋值操作(避免自赋值)；（自己和自己赋值if(this == &other)) 移动赋值运算符例子

可以delete this吗

可以使用，但是必须非常谨慎。因为滥用可能导致未定义的行为。delete this主要是允许对象在类的成员函数中自行销毁，一般不用

析构函数调用delete this会怎么样？

会无限循环执行析构函数，直到stackoverflow， 因为delete本身也会执行析构函数，递归调用

空指针能否调用函数？虚函数？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include<bits/stdc++.h>

using namespace std;

class A{
public:
    int a;
    void func(){}
    void func1(){a = 10;}
    virtual void func2(){}
};

int main()
{
    A* a = nullptr; // 初始化了一个类型为A的空指针，没有调用构造函数
    a->func();
    a->func1(); // segmentation fault 使用了this指针
    a->func2(); // segmentation fault 找不到对象的虚表指针
}

问题一：能否调用函数？

对于类成员函数而言，并不是一个对象对应一个单独的成员函数体，而是此类的所有对象共用这个成员函数体。 当程序被编译之后，此成员函数地址即已确定。当调用a->func(); 这句话时，其实就是调用A::func(this);而成员函数的地址在编译时就已经确定， 需要注意的是，你用空指针调用成员函数，只是让this指针指向了空，所以空指针也是可以调用普通成员函数，只不过此时的this指针指向空而已，但函数func函数体内并没有用到this指针，所以不会出现问题。 当成员函数体内用到this指针时，如果你的this指针是空，那么程序就会崩溃。比如，如果func1中a = 10，程序就会出问题，原因就是this指针指向空，当进行赋值的时候，编译器不知道这个成员变量是哪一个对象的，所以他不知道给哪个对象的a赋值，因此就会出错。

问题二：能否调用虚函数？

我们知道，如果一个类中包含虚函数，那么他所实例化处的对象的前四个字节是一个虚表指针，这个虚表指针指向的是虚函数表。当然，虚函数的地址也是在编译时就已经确定了，这些虚函数地址存放在虚函数表里面，而虚函数表就在程序地址空间的数据段（静态区），也就是说虚表的建立是在编译阶段就完成的；当调用构造函数的时候才会初始化虚函数表指针，即把虚表指针存放在对象前四个字节（32位下）。试想一下，假如用空指针调用虚函数，这个指针根本就找不到对应的对象的地址，因此他也不知道虚表的地址，没有虚表的地址，怎么能调用虚函数呢。

构造函数可以memset(this, 0 ,sizeof(*this))吗

如果所有成员变量是简单的内置类型是没有问题

但是下面几种情形是不可以这么使用的：

1.类含有虚函数表：这么做会破坏虚函数表，后续对虚函数的调用都将出现异常

2. 类含有STL元素：对带有 string, map, vector 等 STL 元素的类或结构使用 memset，会产生崩溃、内存泄漏…等一系列未知的问题，问题的严重性与编译器有关。不对任何使用了 STL 容器的类或结构使用 memset 来做零初始化。

strcpy和memcpy的区别

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

char *strcpy(char *strDest, const char *strSrc);

char *strcpy(char *strDest, const char *strSrc)  
{  
    if (strDest == NULL || strSrc == NULL)  
        return NULL;  
    if (strDest == strSrc)  
        return strDest;  
    char *tempDest = strDest;  
    while((*strDest++ = *strSrc++) != '\0');  
    return tempDest;  
}

//在使用strcpy时，需要特别注意目标字符串strDest的大小。如果它没有足够的空间来存储源字符串，可能会导致缓冲区溢出，这是一种常见的安全隐患。

1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。 2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。 3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy

inline内联函数

• 相当于把内联函数里面的内容写在调用内联函数处；
• 相当于不用执行进入函数的步骤，直接执行函数体；
• 相当于宏，却比宏多了类型检查，真正具有函数特性；
• 编译器一般不内联包含循环、递归、switch 等复杂操作的内联函数；
• 在==类声明中定义的函数==，除了虚函数的其他函数都会自动隐式地当成==内联函数==。
• 内联函数声明必须在调用语句之前

优缺点

优点

1. 内联函数同宏函数一样将在被调用处进行代码展开，省去了参数压栈、栈帧开辟与回收，结果返回等，从而提高程序运行速度。

缺点

1. 代码膨胀。内联是以代码膨胀（复制）为代价，消除函数调用带来的开销。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
2. inline 函数无法随着函数库升级而升级。inline函数的改变需要重新编译，不像 non-inline 可以直接链接。（因为inline直接将代码插入到每一个调用的地方，而non-inline函数的调用通过函数地址进行，地址在程序运行时由动态链接器填充）
3. 是否内联，程序员不可控。内联函数只是对编译器的建议，是否对函数内联，决定权在于编译器。

inline和#define的区别

1. 内联函数相比宏函数来说，在代码展开时，会做安全检查或自动类型转换（同普通函数），而宏定义则不会。
2. 内联函数可以访问类的成员变量，而宏定义则不能
3. 内联函数在运行时可调试，而宏定义不可以。

虚函数是否可内联

• 虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。
• 内联是在编译期建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
• inline virtual 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 Base::who()），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。

什么是C++中的RAII？使用场景？

RAII全称是（Resource Acquisition Is Initialization）资源获取即初始化。

核心思想是将资源的获取和对象的生命周期绑定，通过构造函数获取资源（如内存，文件句柄，网络连接），通过析构函数释放资源。这样，即使程序在执行过程中抛出异常或多路径返回，也能确保资源最终得到正确释放，特别是可以避免内存泄露

使用场景

• 内存管理：标准库中的std::unique_ptr和std::shared_ptr是RAII的经典实现，用于智能管理动态内存
• 文件操作：std::fstream类在打开文件时获取资源，在析构函数中关闭文件
• 互斥锁：std::lock_guard和std::unique_lock用于在多线程编程中自动管理互斥锁的锁定和释放

RAII的好处

异常安全：使用RAII能够确保在异常发生的时候自动释放资源，避免资源泄露

简化资源管理：将资源的获取和释放逻辑封装在类内，使代码更加简洁且方便维护

lock_guard和unique_lock的区别？

两者都是RAII形式的锁管理类，用于管理互斥锁（mutex）。区别：

lock_guard是一个简单且轻量级的锁管理类。在构造的时候锁定给定的互斥体，并在销毁的时候自动解锁。它不可以显示的解锁，也不支持锁的转移

unique_lock提供了更多的灵活性。它允许显示的锁定和解锁操作，还支持锁的转移。unique_lock可以选择在构造时不锁定互斥体，在稍后时手动锁定

lock_guard

1
2
3
4
5
6

std::mutex mtx;

void example_function() {
    std::lock_guard<std::mutex> lock(mtx);  // 自动获取锁
    // 临界区代码
}// 作用域结束，mtx自动解锁

unique_lock

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// 1 延迟锁定    
std::mutex mtx;
void example_function() {
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock);  // 不立即锁定
	// 需要时再锁定
	lock.lock();  
    //互斥锁已经锁定，可以访问共享资源
}// 作用域结束，mtx自动解锁

// 2 显示解锁
1 延迟锁定    
std::mutex mtx;
void example_function() {
    std::unique_lock<std::mutex> lock(mtx);
	//访问共享资源
	lock.unlock();  
    // 其他操作
    lock.lock();
    // 再次锁定共享资源
}// 作用域结束，mtx自动解锁

// 3 锁的所有权转移
std::mutex mtx;
void example_function() {
    std::unique_lock<std::mutex> lock1(mtx); 
    std::unique_lock<std::mutex> lock2 = std::move(lock1);
	// lock1不在拥有互斥锁
    // lock2 拥有互斥锁
}// 作用域结束，mtx自动解锁

如何设计一个线程安全的类？

1. 使用互斥锁保护共享资源
2. 部分逻辑可以使用无锁编程，原子变量控制

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include<bits/stdc++.h>

class safethread{
public:
    safethread():value(0){}

    int getvalue()
    {
        std::lock_guard<std::mutex> lock(mutex_);
        return value;
    }

    void increment()
    {
        std::lock_guard<std::mutex> lock(mutex_);
        value ++;
    }
private:
    int value;
    std::mutex mutex_;
};

int main()
{
    safethread safe;
    auto increment_func = [&safe]()
    {
        for(int i = 0; i < 100000; i ++) safe.increment();
    };

    std::thread t1(increment_func);
    std::thread t2(increment_func);

    t1.join();
    t2.join();
    std::cout << safe.getvalue() << std::endl;
    return 0;
}

三个线程依次打印123

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include<bits/stdc++.h>

std::condition_variable cv;
std::mutex mut;
int turn = 0;

void print_num(int id, int num)
{
    for(int i = 0; i < 10; i ++)
    {
        std::unique_lock<std::mutex> lock(mut);
        cv.wait(lock, [id](){return id == turn;});
        std::cout << num << " ";
        turn = (turn + 1) % 3;
        cv.notify_all();
    }
}

int main()
{
    std::thread t1(print_num, 0, 1);
    std::thread t2(print_num, 1, 2);
    std::thread t3(print_num, 2, 3);

    t1.join();
    t2.join();
    t3.join();
    return 0;
}

std::condition_variable::wait 是一个用于线程同步的函数，它让线程在等待某个条件满足之前阻塞自己。常用于多线程编程中，配合 std::mutex 使用，以避免竞争条件。

基本用法

1

cv.wait(lock, pred);

• cv 是 std::condition_variable 类型的对象。
• lock 是一个 std::unique_lock<std::mutex> 对象，它在 cv.wait 被调用时必须已经锁住了互斥锁。
• pred 是一个返回布尔值的可调用对象（通常是 lambda 函数或函数对象），它表示线程应该继续执行的条件。如果 pred 返回 false，线程将继续等待。

详细解释

1. 等待与解锁： 当调用 cv.wait(lock) 时，当前线程会被阻塞，并且会临时解锁 lock 持有的互斥锁，以允许其他线程在等待的同时操作共享资源。
2. 条件满足后重新加锁： 当另一个线程调用 cv.notify_one() 或 cv.notify_all() 唤醒等待线程时，wait 会尝试重新锁住 lock，并继续执行代码。如果 pred 返回 true，线程就会继续执行，否则它将再次等待。

thread的join和detach的区别

join：阻塞当前的调用线程，直到子线程完成。这意味着主线程等待子线程执行完毕后再继续执行，确保子线程完成。

detach：将子线程从调用线程中分离开来，子线程在后台执行，不会阻塞调用线程。调用detach后，子线程的资源在它独立执行完后自动释放，但主线程将无法在与其通信或者得到执行结果

jthread和thread的区别

自动资源管理：std::jthread是C++20引入的，它通过RAII管理线程生命周期，当std::jthread对象被销毁时，它所管理的线程会join。而std::thread需要手动的调用join或者detach方法，否则在std::thread对象销毁时如果仍未join，会导致程序异常终止

中断支持：std::jthread设计更优雅的支持线程中断机制，而在std::thread中没有直接的中断支持，需要程序员手动实现中断逻辑

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
#include <thread>
#include <stop_token>

void threadFunction(std::stop_token stoken) {
    while (!stoken.stop_requested()) {
        std::cout << "Thread is running." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}

int main() {
    std::jthread jt(threadFunction);

    std::this_thread::sleep_for(std::chrono::seconds(3));
    // 自动调用 join，且支持停止
    jt.request_stop();  // 请求线程停止

    return 0;
}

原子操作

在C++中，std::atomic 是一个模板类，用于实现原子操作，能够在线程之间安全地共享和修改变量，而无需使用显式的锁或其他同步机制。原子操作是指那些在执行过程中不可分割的操作，不会被其他线程中断，从而避免了数据竞争和竞态条件。

1
2
3
4
5

#include <atomic>

std::atomic<int> atomicInt(0);  // 声明一个原子整型变量并初始化为0
atomicInt = 10;  // 原子的赋值操作
int value = atomicInt;  // 原子的读取操作

线程池

线程池

管理一个线程池，一个任务队列，每次从任务队列从取一个任务分配给一个线程去做，循环重复

其中，构造函数创建了指定数量的线程，并把它们的执行函数定义为一个无限循环，循环体中从队列中获取任务并执行。如果队列为空且线程池已经停止，线程将退出循环。其中，使用 std::unique_lock 和 std::condition_variable 实现了线程的挂起和唤醒（任务添加的时候会cv.notify_one()），从而避免了空轮询的浪费。

shared_ptr

shared_ptr内部包含两个指针，一个指向对象，另一个指向控制块(control block)，控制块中包含一个引用计数和其它一些数据。由于这个控制块需要在多个shared_ptr之间共享，所以它也是存在堆上的。shared_ptr对象本身是在栈上的，利用RAII的思想，当栈对象超出生命周期后自动析构的特征，无需手动释放资源。

shared_ptr对象本身是线程安全的，也就是说shared_ptr的引用计数增加和减少的操作都是原子的。但是对于管理的对象而言不是线程安全的。

通过unique_ptr来构造shared_ptr是可行的

1
2

unique_ptr<string> p1{ new string("senlin") };
shared_ptr<string> p2{ std::move(p1) };

反之则不行，所有权和std::shared_ptr指向的资源之间的关系是“除非死亡否则永不分离”

shared_prt内部如何实现

两个指针：

1. 托管对象：即 shared_ptr 所指向的动态分配的对象。

2. ==控制块==

   （Control Block）：这是一个单独的数据结构，用于存储与 shared_ptr相关的元数据，主要包括：

   • 引用计数（Reference Count）：跟踪有多少个 shared_ptr 实例指向同一个对象。
   • 弱引用计数（Weak Count）：跟踪有多少个 weak_ptr 实例与此 shared_ptr 相关联，即使主对象已被删除，控制块仍然存在，直到弱引用计数也归零。
   • 自定义销毁器，自定义分配器

以下是std::shared_ptr引用计数器增加和减少的情况：

• 增加：创建shared_prt对象的时候初始化为1，然后每次调用std::shared_ptr的拷贝构造函数或赋值运算时，引用计数器都会增加。也就是说，每当有新的std::shared_ptr开始共享同一个对象时，引用计数器就会增加。
• 减少：每次调用std::shared_ptr的析构函数时，引用计数器都会减少。当引用计数器减少到0时（即没有任何std::shared_ptr再共享该对象），该对象就会被自动删除。

计数器是放在堆上的还是栈上的

std::shared_ptr的引用计数器是存储在堆上的。这是因为std::shared_ptr需要动态分配一个控制块来存储引用计数器和其他信息。==这个控制块在堆上分配==，因为它的生命周期不受任何特定std::shared_ptr实例的影响。换句话说，即使最后一个指向对象的std::shared_ptr已经被销毁，控制块也可能仍然存在（例如，如果还有std::weak_ptr指向该对象）。只有当最后一个指向对象的std::shared_ptr或std::weak_ptr被销毁时，控制块才会被删除。

make_shared 和 shared_ptr的区别

1
2

std::shared_ptr<int> ptr = std::make_shared<int>(10);
std::shared_ptr<int> ptr(new int(10));

1. 内存分配方式：

• std::make_shared：std::make_shared 会一次性分配一块内存，用来存储控制块（引用计数等）和所管理的对象。这意味着控制块和对象是在同一块内存中分配的。
• std::shared_ptr 构造函数：如果直接使用 std::shared_ptr 构造函数（例如 std::shared_ptr<int> sp(new int(10));），首先会分配一块内存来存储对象，然后分配另一块内存来存储控制块。这意味着控制块和对象可能不在同一块内存中。

2. 性能和效率：

• std::make_shared：由于 std::make_shared 只进行一次内存分配，它通常比直接使用 std::shared_ptr 更高效。此外，由于控制块和对象在同一块内存中，缓存性能也会有所提高。
• std::shared_ptr 构造函数：直接使用 std::shared_ptr 会导致两次内存分配，一次用于对象，一次用于控制块，因此效率可能略低。

3. 异常安全性：

• std::make_shared：由于它只执行一次内存分配操作，所以在异常情况下（例如在分配内存或构造对象时抛出异常），不会产生内存泄漏。
• std::shared_ptr 构造函数：由于需要分别分配内存给对象和控制块，如果在对象分配完成后、控制块分配之前抛出异常，可能会导致内存泄漏。

shared_ptr的循环引用

使用shared_ptr时，不可避免地会遇到循环引用的情况，这样容易导致内存泄露。循环引用就像下图所示，通过shared_ptr创建的两个对象，同时它们的内部均包含shared_ptr指向对方。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 一段内存泄露的代码
struct Son;
struct Father　{
    shared_ptr<Son> son_;
};
struct Son {
    shared_ptr<Father> father_;
};
int main() 
{
    auto father = make_shared<Father>();
    auto son = make_shared<Son>();
    father->son_ = son;
    son->father_ = father;
  
    return 0;
}

　分析一下main函数是如何退出的，一切就都明了：

• main函数退出之前，Father和Son对象的引用计数都是2。
• son指针销毁，这时Son对象的引用计数是1。
• father指针销毁，这时Father对象的引用计数是1。
• 由于Father对象和Son对象的引用计数都是1，这两个对象都不会被销毁，从而发生内存泄露。

线程安全

shared_ptr未对指向的对象内存区域有线程安全保护，因此并发读写对应内存区域是不安全的。

由于赋值操作涉及原内存释放、修改指针指向等多个修改操作，其过程不是原子操作，因此对shared_ptr进行并发赋值不是线程安全的。

对shared_ptr进行并发拷贝，对数据指针和控制块指针仅进行读取并复制，然后对引用计数进行递增，而引用计数增加是原子操作。因此是线程安全的。

避免从原始指针变量上创建std::shared_ptr

当从原始指针上构造出 std::shared_ptr 时会创建控制块。多个控制块意味会被释放多次，这样就会导致double free的问题。

第一，避免传递原始指针，通常使用std::make_unique。第二，如果非要传递原始指针，直接传new出来的结果，不要传指针变量。

shared_from_this

shared_from_this提供了一种方法，让一个类的成员函数能够安全的获得对象的std::shared_ptr。如果直接通过this构造std::shared_ptr，那么就会创建新的控制块，导致double free的问题【双重释放】。或者传入了this构造了std::shared_ptr，跳出作用域后，this被意外释放了【指针悬挂】。

通过shared_from_this，可以在类中创建指向对象的std::shared_ptr，但不额外创建新的控制块。他需要继承std::enable_shared_from_this

不要memcpy shared_ptr

很显然，不是通过正常途径（拷贝构造，赋值运算），引用计数是不会正确增长的。

但是这并不会导致double free，因为不会去创建新的控制块，只是指针的赋值。那么在release()函数中，只有控制块的引用计数为0的时候，才会delete，所以当sp2去析构的时候，引用计数为-1，并不会去delete释放资源。但是会破坏shared_ptr内部状态

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include<bits/stdc++.h>

using namespace std;


int main()
{
    shared_ptr<int> sp1 (new int(10));
    shared_ptr<int> sp2;
    memcpy(&sp2,&sp1,sizeof(shared_ptr<int>));
    cout << sp1.use_count() << endl; // 还是1
}

手写shared_ptr

在智能指针类中存储裸指针（raw pointer）和引用计数。 在构造函数中为裸指针和引用计数分配内存。 在拷贝构造函数和赋值操作符中正确地更新引用计数。 在析构函数中递减引用计数，并在引用计数为零时删除对象和引用计数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

#include<bits/stdc++.h>

template <typename T>
class shareptr{
private:
    T* ptr = nullptr;
    size_t* count;
    void release()
    {
        std::cout << "destruct" << std::endl;
        if(count && --(*count) == 0)
        {
            std::cout << "delete" << std::endl;
            delete ptr;
            delete count;
        }
    }
public:
    shareptr(T* _ptr = nullptr): ptr(_ptr), count(_ptr ? new size_t(1) : nullptr){
        std::cout << "construct" << std::endl;
    }
    
    ~shareptr(){
        release();
    }
    
    shareptr (const shareptr& other): ptr(other.ptr), count(other.count)
    {
        if(count)
        {
            ++(*count);
        }
    }
    
    shareptr& operator=(const shareptr &other)
    {
        if(this != &other)
        {
            release();
            ptr = other.ptr;
            count = other.count;
            if(count) ++(*count);
        }
        return *this;
    }
    
    T* operator->() const noexcept {return ptr;}
    T& operator*() const noexcept {return *ptr;}
    T* get() const noexcept {return ptr;}
    size_t use_count() const {return count ? *count : 0;}
};

int main()
{
    shareptr<int> p1 = makeshare<int>(10);
    std::cout << *p1 << std::endl;
    shareptr<int> p2 = p1;
    shareptr<int> p3;
    p3 = p1;
    std::cout << p1.use_count() << std::endl;
    return 0;
}

/*
construct
10
construct
destruct
3
destruct
destruct
destruct
delete
*/

weak_ptr

weak_ptr 是设计用来配合 shared_ptr，解决因循环引用而导致的内存泄漏问题。weak_ptr 持有对对象的引用，但不增加其引用计数。这意味着 weak_ptr 不能阻止其指向的对象被销毁。当需要访问 weak_ptr 指向的对象时，可以将其临时提升为 shared_ptr，使用lock()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include <memory>
#include <iostream>

void example() {
    std::shared_ptr<int> p1 = std::make_shared<int>(10);
    std::weak_ptr<int> wp = p1;  // 创建一个 weak_ptr，不增加引用计数

    if (auto sp = wp.lock()) {  // 提升为 shared_ptr
        std::cout << *sp << std::endl;
    } else {
        std::cout << "对象已被销毁" << std::endl;
    }
}  // p1 超出作用域，自动释放内存

// 修复内存泄露的问题
struct Son;
struct Father　{
    shared_ptr<Son> son_;
};
struct Son {
    weak_ptr<Father> father_;
};
int main() 
{
    auto father = make_shared<Father>();
    auto son = make_shared<Son>();
    father->son_ = son;
    son->father_ = father;
  
    return 0;
}
/*

同样，分析一下main函数退出时发生了什么：

main函数退出前，Son对象的引用计数是2，而Father的引用计数是1。
son指针销毁，Son对象的引用计数变成1。
father指针销毁，Father对象的引用计数变成0，导致Father对象析构，Father对象的析构会导致它包含的son_指针被销毁，这时Son对象的引用计数变成0，所以Son对象也会被析构。
*/

应用场景

• 解决循环引用无法释放的问题
• 探查内存空间是否有效，避免指针悬挂。要是对象已被析构，那么lock()返回一个空的shared_ptr。另⼀种形式是以 std::weak_ptr 为实参构造std::shared_ptr 。这种情况中，如果std::weak_ptr 过期，会抛出⼀个异常

指针悬挂（Dangling Pointer）是指指针仍然指向先前分配的内存位置，但该内存位置已经被释放或重新分配。使用悬挂指针会导致未定义行为，包括可能的程序崩溃、数据损坏和安全漏洞。

unique_ptr

unique_ptr 是一种独占所有权的智能指针。它保证同一时间内只有一个 unique_ptr 可以指向一个给定的对象。当 unique_ptr 被销毁或者它被显式移动到另一个 unique_ptr 时，它所管理的对象也会被销毁。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <memory>

void example() {
    // 直接构造函数
    std::unique_ptr<int> p0(new int(10));
    // 使用smake_unique
    std::unique_ptr<int> p1 = std::make_unique<int>(10); // 创建一个 unique_ptr
    // std::unique_ptr<int> p2 = p1;  // 错误：unique_ptr 不能复制
    std::unique_ptr<int> p2 = std::move(p1);  // 移动所有权
}  // p2 超出作用域，自动释放内存

通过将拷贝构造和复制运算符delete实现独占，这样每一个智能指针要指向一个对象的时候只能指向一个新的实例化对象，不能通过=或者拷贝去指向前面的对象

手写unique_ptr

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include<bits/stdc++.h>

template<typename T>

class uniqueptr{
private:
    T *ptr = nullptr;
public:
    explicit uniqueptr(T* _ptr = nullptr) noexcept : ptr(_ptr){
        std::cout << "construct" << std::endl;
    }
    // C++11 后析构函数默认noexcept
    ~uniqueptr(){
        std:: cout << "destruct" << std::endl;
        delete ptr;
    };

    uniqueptr (const uniqueptr &) = delete; // 拷贝构造
    uniqueptr& operator=(const uniqueptr &) = delete; // 赋值运算符

    uniqueptr (uniqueptr &&p) noexcept {
        std::cout << "move construct" << std::endl;
        p.swap(*this);
    }

    uniqueptr& operator=(uniqueptr &&p) noexcept {
        std::cout << "move = construct" << std::endl;
        // p.swap(*this);
        if(this != &p)
        {    
	        this->reset(p.release());
		}
        return *this;
    } 
	
    void swap(uniqueptr &p) noexcept
    {
        std::swap(ptr, p.ptr);
    }
    
    T& operator*() const noexcept {return *ptr;};
    T* operator->() const noexcept {return ptr;};
    explicit operator bool() const noexcept {return ptr;};
	T* get() const noexcept {return ptr;};  
    
    void reset(T *q = nullptr) noexcept
    {
        delete std::exchange(ptr, q);
    }

    T* release() noexcept // 转移所有权给调用者，返回原始指针，自身置空，那么调用者就需要负责这片内存进行管理，比如内存释放，所以release不需要释放原来的内存
    {
        return std::exchange(ptr, nullptr);
    }
};

template<typename T, typename... Ts>
uniqueptr<T> makeunique(Ts&& ...params)
{
    return uniqueptr<T>(new T(std::forward<Ts>(params)...));
}

int main()
{
    uniqueptr<int> p1(new int(10));
    uniqueptr<int> p2(new int(20));
    uniqueptr<int> p3 = makeunique<int>(30);
    std::cout << *p3 << std::endl;
    p2.reset(new int(30));
    return 0;
}

std::exchange

1
2

template< class T, class U = T >
constexpr T exchange( T& obj, U&& new_value );

• 以 new_value 替换 obj 的值，并返回 obj 的旧值。

自赋值问题

如果不判断是否是自赋值，会导致对象本该不被自赋值的动作改变，但是却发现自己持有了一个已经被删除了对象的指针

可以加一个if判断if(*this != p)，但是这在拷贝赋值运算符中并不是异常安全的，因为如果在深拷贝的过程中，出现了异常，就会导致仍然持有了一个已经被删除了对象的指针。

可以使用copy and swap技术，先通过拷贝构造拷贝一份副本temp，然后通过swap交换指针指向的内存，等到超出作用域，那么临时对象temp就会自动释放，那么原来的内存就被释放了。

C++左值和右值

左值：常指的是具有持久状态的对象。左值可以出现在赋值语句的左边，也就是说，它可以被赋值。左值通常有一个明确的地址，意味着你可以获取它的内存地址。

右值：通常指的是临时的、没有持久状态的对象。右值不可以出现在赋值语句的左边（不能被赋值），但可以出现在右边。右值通常是在表达式计算过程中产生的临时结果。

++i, --i是左值，因为返回的是对象的引用，i--,i++是右值，因为返回的是一个临时对象

左值引用

左值引用是 C++ 中传统的引用类型，通常用来引用持久对象（左值）。

• 定义和使用： 使用单个 & 符号定义，例如 int& ref = var; 其中 var 必须是一个左值。
• 语义： 左值引用可以看作是被引用对象的一个别名，它必须引用一个具有明确存储位置的对象（即左值）。它不能初始化为临时对象或非持久对象。
• 用途： 左值引用主要用于函数参数传递，使得函数可以修改调用者的数据，或者用于返回函数内部的对象引用，使调用者可以访问或修改这些对象。

右值引用

右值引用是 C++11 引入的一种引用类型，用以支持移动语义和完美转发，特别是引用那些即将被销毁的临时对象（右值）。

• 定义和使用： 使用双 && 符号定义，例如 int&& rref = std::move(var); 其中 var 可以是左值（经过 std::move 转换）或右值。
• 语义： 右值引用允许引用到临时对象。与左值引用相比，右值引用的引入主要是为了允许资源的“窃取”，而不是复制，这极大提升了资源管理（如动态内存管理）的效率。
• 用途： 右值引用最常见的用途是实现移动构造函数和移动赋值运算符，这两个操作可以从即将销毁的对象中窃取资源，减少内存分配和数据复制的开销。此外，右值引用也用于实现完美转发，保证函数模板可以转发参数至其他函数，同时保留原有的值类别（左值或右值）。

移动语义

移动语义允许资源（如动态分配的内存）从一个对象转移至另一个对象，而不需要进行资源的复制。这是通过引入右值引用 (&&) 实现的，允许开发者区分那些只能被赋值一次的临时对象（右值）。

基本原理

在传统的 C++ 编程中，对象间的赋值通常涉及深复制，即复制对象的所有内容，如动态内存。这种做法虽然简单，但在处理大量数据或复杂对象时会非常低效。移动语义通过允许资源“窃取”来优化这一过程。

移动构造函数和移动赋值运算符

一个类实现移动语义，通常要定义一个移动构造函数和一个移动赋值运算符：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class HugeData {
public:
    HugeData(std::size_t size) : data(new int[size]), size(size) {}
    ~HugeData() { delete[] data; }

    // 移动构造函数
    HugeData(HugeData&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }

    // 移动赋值运算符
    HugeData& operator=(HugeData&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }

private:
    int* data;
    std::size_t size;
};

在这个例子中，移动构造函数和移动赋值运算符“窃取”了源对象 other 的资源（这里是动态数组 data），并将源对象的指针设置为 nullptr。这样源对象在销毁时不会释放已经转移的资源。

完美转发

完美转发是模板编程中的一个技术，用于确保函数模板可以接受任何类型的实参并将其转发到另一个函数，同时保持所有实参的值类别（左值、右值性质）。这主要通过 std::forward 实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

template<typename T>
void wrapper(T&& arg) {
    // 转发 arg 到另一个函数，保持 arg 的左值或右值性质
    forward_function(std::forward<T>(arg));
}


template<typename T, typename... Ts>
uniqueptr<T> makeunique(Ts&& ...params)
{
    return uniqueptr<T>(new T(std::forward<Ts>(params)...));
}

template<typename Function, typename... Ts>
auto makefunction(Function && F, Ts&& ...params) -> decltype(F(std::forward<Ts>(params)...))
{
    return F(std::forward<Ts>(params)...);
}
/*
typename告诉编译器，接下来的名称应被视为类型名
模板参数：
template<typename Function, typename... Ts>：声明了一个模板函数，Function 模板类型参数，表示可调用对象的类型，Ts... 表示可变模板参数，可以接受任意数量的参数。
函数签名：

auto makefunction(Function && F, Ts&& ...params) -> decltype(F(std::forward<Ts>(params)...))：
auto makefunction：定义了一个名为 makefunction 的函数，返回值类型由编译器自动推断。
Function && F：接受一个可调用对象 F 作为参数，使用右值引用 && 允许完美转发。
Ts&& ...params：接受可变数量的参数，同样使用右值引用。
-> decltype(F(std::forward<Ts>(params)...))：使用 decltype 指定返回值类型，即调用 F 函数后的返回值类型。
函数体：

return F(std::forward<Ts>(params)...);：直接返回 F 函数的调用结果，将传入的参数完美转发给 F。
*/

去掉std::forward会怎么样？

如果去掉std::forward，那么参数arg将总是被视为左值，无论它最初是左值还是右值。这是因为在C++中，函数参数在传递时默认是左值引用

C++中新增了string，与C语言中的 char* 有什么区别吗？它是如何实现的？

C++中的string类和C语言中的char*在使用上有很大的区别。以下是一些主要的区别：

类型安全：string是一个类，提供了许多方法（如append，replace，substr等）来操作字符串。这使得字符串操作更加安全和方便。而char*则需要使用字符串函数（如strcpy，strcat，strlen等），这些函数在使用不当时可能会导致错误，如缓冲区溢出。

动态大小：string对象可以动态地改变大小，你可以在运行时添加或删除字符，而不需要担心内存分配。而对于char*，你需要手动管理内存，并确保有足够的空间来存储所有的字符。

易用性：使用string可以更容易地进行一些操作，如字符串连接和比较。例如，你可以使用+运算符来连接两个字符串，或者使用==运算符来比较两个字符串是否相等。而对于char*，你需要使用特定的函数（如strcat和strcmp）来进行这些操作。

至于C++中的 string 类是如何实现的，它通常是作为一个动态数组实现的，其中包含一个指向字符数组的指针、一个表示字符串长度的整数以及一个表示分配的内存大小的整数。当字符串增长并超出当前分配的内存大小时，会分配一块更大的内存区域，并将现有字符串复制到新内存中，然后释放旧内存。这种实现方式使得 string 类能够有效地处理动态大小变化的字符串。

string内部使用的是堆内存还是栈内存

string对象本身是在栈内存中，它所管理的字符串在堆内存中。但是，当字符串较短的时候，大多数实现可能会在对象内部使用一个短字符串优化（SSO），此时字符串会在栈内存

if和switch性能

switch…case会生成一个跳转表来指示实际的case分支的地址，而这个跳转表的索引号与switch变量的值是相等的。从而，switch…case不用像if…else那样遍历条件分支直到命中条件，而只需访问对应索引号的表项从而到达定位分支的目的。

当分支较多的时候，switch效率高，因为switch是随机访问的，if可能需要遍历所有可能的值。

volatile

• volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素（硬件、操作系统、其它线程等）更改。所以使用 volatile 告诉编译器不应对这样的对象进行优化，以确保每次访问时都==必须从内存中取出值==（没有被 volatile 修饰的变量，可能由于编译器的优化，从 CPU 寄存器中取值）
• volatile 不能保证线程安全：volatile 仅确保变量的可见性，但不提供原子性操作。如果需要保证线程安全，还需要使用其他同步机制，如互斥锁（mutex）或原子操作（atomic）。

三个例子

1. 硬件寄存器

硬件寄存器通常通过内存映射访问，这些寄存器的值可能随时变化。使用 volatile 关键字确保每次访问都能反映寄存器的最新状态。

2. 中断处理程序中的变量

中断处理程序（ISR）中的变量可能在主程序和中断程序之间共享，使用 volatile 关键字确保变量的值在两个程序之间保持一致。

3. 多线程中的共享变量

在多线程程序中，共享变量可能被多个线程同时访问和修改。使用 volatile 确保每个线程都能看到变量的最新值。

assert()

断言，是宏，而非函数。assert 宏的原型定义在 <assert.h>（C）、<cassert>（C++）中，其作用是如果它的条件返回错误，则终止程序执行。可以通过定义 NDEBUG 来关闭 assert，但是需要在源代码的开头，include <assert.h> 之前。

assert() 使用

sizeof()

• sizeof 对数组，得到整个数组所占空间大小。
• sizeof 对指针，得到指针本身所占空间大小。

strlen和sizeof的区别

strlen

strlen 是一个函数，用于计算以 '\0' 结尾的字符串的长度，不包括终止字符 '\0'。

特点：

1. 运行时计算：strlen 在运行时计算字符串的长度。
2. 只适用于字符串：strlen 只能用于以 '\0' 结尾的字符串。
3. 不包括终止字符：计算结果不包括终止字符 '\0'。

sizeof

sizeof 是一个运算符，用于计算一个数据类型或变量所占用的内存大小（以字节为单位）。sizeof操作符的结果是在编译期确定的。

特点：

1. 指针的大小永远是固定的，取决于处理器位数，32位就是 4 字节，64位就是 8 字节
2. 直接sizeof数组名，就是数组整个的大小。如果数组作为函数参数时会退化为指针，大小要按指针的计算
3. struct 结构体要考虑字节对齐
4. 字符串数组要算上末尾的 ‘\0’

数组退化为指针的例子

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include<bits/stdc++.h>

using namespace std;

const int N = 100;
int a[N];

void func(int a[])
{
    cout << sizeof(a) << endl;    
}

void func1(int (&a)[N])
{
    cout << sizeof(a) << endl;    
}



int main()
{
    memset(a, 0, sizeof a);
    cout << sizeof(a) << endl; // 400
    func(a); // 8
    func1(a); // 400
    return 0;
}
//其中func传入的是数组首元素的指针，那么就会退化为指针的大小为8（64位）
//func1传入的数组的引用，因此不会退化，所以大小还是400

strlen("\0")和sizeof("\0")

strlen 函数计算字符串的长度，不包括终止字符 '\0'。

• strlen("\0") 中，"\0" 是一个只包含终止字符 '\0' 的字符串。
• 因此，strlen("\0") 计算的长度为0，因为在字符串中，'\0' 表示字符串的结束，前面没有任何字符。

sizeof 运算符计算对象或类型的大小，以字节为单位。

• sizeof("\0") 中，"\0" 是一个字符串字面量。字符串字面量包含字符串中的所有字符以及一个额外的终止字符 '\0'。
• 因此，sizeof("\0") 的结果是2，因为 "\0" 包含两个字符：一个是 '\0'，另一个是表示字符串结束的 '\0'。

如何不用sizeof求int的字节占用

利用指针的地址运算转换成char*

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <stdio.h>

int main() {
    int arr[2]; // 创建一个包含两个元素的数组
    int size = (char*)(&arr[1]) - (char*)(&arr[0]); // 通过地址运算计算int类型的大小

    printf("Size of int: %d bytes\n", size);

    return 0;
}

什么是内存对齐？为什么要内存对齐？

内存对齐指的是计算机访问内存的时候，会根据一些规则来为数据指定一个起始地址。这个起始地址通常是某个固定数字的整数倍。这样做，可以提高CPU的访问效率，尤其在读写的时候

原因

1. 性能提升：对齐可以让CPU在一次内存周期内更高效的读写，减少内存访问次数
2. 硬件限制：某些架构必须要求内存对齐，否则可能引发硬件异常或需要额外的处理时间
3. 可移植性：代码在不同架构上运行，内存对齐可以减少潜在的问题

结构体对齐

成员偏移值是某个对齐数的整数倍，对齐数是该成员变量的大小

结构体大小是最大对齐数的整数倍

如果结构体有成员长度大于处理器的位数，那么就以处理器的位数作为对齐单位（比如结构体嵌套，导致成员大于处理器的最大位数）

#pragma pack(n)

设定结构体、联合以及类成员变量以 n 字节方式对齐

#pragma pack(n) 使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#pragma pack(push)  // 保存之前对齐状态，让后续修改对齐方式不会影响
#pragma pack(4)     // 设定为 4 字节对齐

struct test
{
    char m1;
    double m4;
    int m3;
};

#pragma pack(pop)   // 恢复对齐状态

如何获得结构成员相对于结构开头的字节偏移量

使用<stddef.h>头文件中的，offsetof宏。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include<bits/stdc++.h>

using namespace std;

struct A{
    char a;
    double b;
    int c;
    short d;
};
int main()
{
    cout << offsetof(A, a) << " " << offsetof(A, b) << " "
    << offsetof(A, c) << " " << offsetof(A, d) << endl;
}

位域

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>

struct BitFieldExample {
    unsigned int a : 3;  // 3 bits
    unsigned int b : 5;  // 5 bits
    unsigned int c : 1;  // 1 bit
};

int main() {
    BitFieldExample example;

    example.a = 5;  // 5 的二进制表示为 101
    example.b = 15; // 15 的二进制表示为 01111
    example.c = 1;  // 1 的二进制表示为 1

    std::cout << "a: " << example.a << std::endl;  // 输出: 5
    std::cout << "b: " << example.b << std::endl;  // 输出: 15
    std::cout << "c: " << example.c << std::endl;  // 输出: 1

    return 0;
}

位域（bit field）是一种在结构体（struct）或联合体（union）中定义的特殊字段，用于以更精细的粒度管理数据。位域允许你在结构体中定义成员变量的位宽，从而更有效地使用内存，尤其在需要存储多个标志或小范围整数值的场景下非常有用。位域通常用于嵌入式系统、协议头解析等场景。

• 关键点
  1. 位域的类型：位域的类型通常为 unsigned int 或 int，但可以是其他整型类型，如 signed int、unsigned short 等。类型决定了位域的对齐方式。
  2. 位宽：位域的宽度是一个非负整数，表示该位域占用的位数。如果定义的位宽超出类型所能表示的范围，行为未定义。
  3. 位域对齐：位域的存储方式依赖于实现，编译器通常会将位域放在一个整型的存储单元中，并根据需要跨多个存储单元进行对齐。
  4. 跨存储单元：如果一个位域不能容纳在一个存储单元中，编译器会将其分成两部分，分别存储在两个相邻的存储单元中。

extern “C”

• 被 extern 限定的函数或变量是 extern 类型的
• 被 extern "C" 修饰的变量和函数是按照 C 语言方式编译和链接的

extern "C" 的作用是让 C++ 编译器将 extern "C" 声明的代码当作 C 语言代码处理，可以避免 C++ 因==符号修饰==导致代码不能和C语言库中的符号进行链接的问题。

C 和 C++ 的编译器对符号（函数和变量）的命名规则不同。C++ 支持函数重载，因此编译器在生成符号时会对==函数名进行修饰==，称为名称修饰（name mangling）。C 语言不支持函数重载，其编译器不会对函数名进行修饰。如果不加 extern "C"，C++ 编译器会对符号名进行修饰，导致 C 代码无法找到正确的符号。

extern “C” 使用

1
2
3
4
5
6
7
8
9

#ifdef __cplusplus
extern "C" {
#endif

void *memset(void *, int, size_t);

#ifdef __cplusplus
}
#endif

extern关键字

extern是c++引入的一个关键字，它可以应用于一个全局变量，函数或模板声明，说明该符号具有外部链接*(external linkage)*属性。也就是说，这个符号在别处定义。一般而言，C++全局变量的作用范围仅限于当前的文件，但同时C++也支持分离式编译，允许将程序分割为若干个文件被独立编译。于是就需要在文件间共享数据，这里extern就发挥了作用。

头文件声明时加extern,定义时不要加：因为extern可以多次声明，但只有一个定义

文件1：global.cpp

在这个文件中，我们定义一个全局变量。

1
2
3
4
5
6
7
8

global.cpp
#include <iostream>

int globalVariable = 10;

void printGlobal() {
    std::cout << "Global Variable: " << globalVariable << std::endl;
}

文件2：main.cpp

在另一个文件中，我们使用 extern 声明这个全局变量，并使用它。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

main.cpp
#include <iostream>

// 使用 extern 声明全局变量
extern int globalVariable;

void printGlobal();

int main() {
    std::cout << "Before change: " << globalVariable << std::endl;
    globalVariable = 20;
    std::cout << "After change: " << globalVariable << std::endl;
    printGlobal(); // 调用 global.cpp 中的函数
    return 0;
}

struct和typedef struct

C语言中

1
2
3
4

// c
typedef struct Student {
    int age; 
} S;

等价于

1
2
3
4
5
6

// c
struct Student { 
    int age; 
};

typedef struct Student S;

此时 S 等价于 struct Student，但两个标识符名称空间不相同。

C++中

由于编译器定位符号的规则（搜索规则）改变，导致不同于C语言。

一、如果在类标识符空间定义了 struct Student {...};，使用 Student me; 时，编译器将搜索全局标识符表，Student 未找到，则在类标识符内搜索。

即表现为可以使用 Student 也可以使用 struct Student，如下：

1
2
3
4
5
6

// cpp
struct Student { 
    int age; 
};

void f( Student me );       // 正确，"struct" 关键字可省略

二、若定义了与 Student 同名函数之后，则 Student 只代表函数，不代表结构体，如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

typedef struct Student { 
    int age; 
} S;

void Student() {}           // 正确，定义后 "Student" 只代表此函数

//void S() {}               // 错误，符号 "S" 已经被定义为一个 "struct Student" 的别名

int main() {
    Student(); 
    struct Student me;      // 或者 "S me";
    return 0;
}

C++中，Student 名称已被同名函数覆盖，使得编译器将 Student 识别为函数而非类型。

C++struct和class

总的来说，struct 更适合看成是一个==数据结构==的实现体，class 更适合看成是一个==对象==的实现体。

区别

• 最本质的一个区别就是默认的访问控制
  1. 默认的继承访问权限。struct 是 public 的，class 是 private 的。
  2. struct 作为数据结构的实现体，它默认的数据访问控制是 public 的，而 class 作为对象的实现体，它默认的成员变量访问控制是 private 的。

union联合

在C语言和C++中，union（联合体）是一种数据结构，它允许在相同的内存位置存储不同类型的数据。union中的所有成员共享同一个内存地址，因此一个union变量的大小等于其最大的成员的大小。

1
2
3
4
5

typedef union{
	double i;
	int k[5];
	char c;
}DATE;

在32位系统中，double占8字节，char占1字节，int数组占20字节，因此占用20字节，大小为20，由于double需要8字节对其，因此总共所占空间为24

函数指针、指针函数、回调函数、函数对象

函数指针是指向函数的指针变量。

通常我们说的指针变量是指向一个整型、字符型或数组等变量，而函数指针是指向函数。

函数指针可以像一般函数一样，用于调用函数、传递参数。

函数指针类型的声明：

1

返回类型 (*指针名称)(参数类型列表);

指针函数就是返回值是指针的函数

回调函数：函数指针作为某个函数的参数

函数指针变量可以作为某个函数的参数来使用的，回调函数就是一个通过函数指针调用的函数。

简单讲：回调函数是由别人的函数执行时调用你实现的函数。

函数对象：

函数对象（仿函数）是一个类，不是一个函数

函数对象重载了()操作符使得他可以像函数一样调用，如果重载()只需要一个函数，那么就成为一元仿函数

C和C++区别

C 和 C++ 是两种不同的编程语言，尽管它们有许多相似之处，但也有显著的区别。

1. 面向对象编程（OOP）：
   • C：C 是一种面向过程的编程语言，主要关注函数和过程。
   • C++：C++ 是一种面向对象的编程语言，支持类和对象，提供封装、继承和多态等特性。
2. 标准库：
   • C：C 的标准库主要提供基本的输入输出、字符串处理、内存管理等功能。
   • C++：C++ 标准库（包括 STL，标准模板库）提供了更丰富的数据结构和算法，如向量、列表、集合、映射等容器，以及迭代器和算法。
3. 函数和操作符重载：
   • C：C 不支持函数重载和操作符重载，每个函数必须有一个唯一的名称。
   • C++：C++ 支持函数重载和操作符重载，可以根据参数类型和数量来定义同名函数或重载运算符，使代码更加简洁和直观。

用三个词概括 C 和 C++ 的区别

1. 面向对象
2. 标准库
3. 重载

C实现C++类

C 实现 C++ 的面向对象特性（封装、继承、多态）

• 封装：我们可以使用结构体和函数指针来实现封装。
• 继承：结构体嵌套
• 多态：派生类中基类的函数指针指向派生类的函数

1. 封装（Encapsulation）

封装是面向对象编程中的一个核心概念，主要是为了隐藏对象的内部细节，只暴露必要的操作接口。在 C 语言中，你可以通过使用 struct 来定义数据结构，然后通过函数来操作这些数据结构，从而达到封装的效果。

2. 继承（Inheritance）

虽然 C 语言没有原生的继承支持，但可以通过结构体嵌套的方式模拟继承。基类的结构体被嵌入到派生类中作为第一个成员，从而实现类似继承的效果。

3. 多态（Polymorphism）

使用基类的函数指针调用函数，实现多态行为。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include <stdio.h>

// 定义基类结构体
typedef struct {
    void (*speak)(void);
} Animal;

// 基类方法
void animal_speak(void) {
    printf("Animal sound!\n");
}

// 定义派生类结构体
typedef struct {
    Animal base;
} Dog;

// 派生类方法
void dog_speak(void) {
    printf("Woof!\n");
}

int main() {
    // 基类对象
    Animal animal;
    animal.speak = animal_speak;

    // 派生类对象
    Dog dog;
    dog.base.speak = dog_speak;

    // 基类指针指向派生类对象
    Animal *ptr = (Animal*)&dog;

    // 调用方法，实现多态
    ptr->speak();  // 输出 "Woof!"

    return 0;
}

explicit关键字

• explicit 主要是防止构造函数或者转换函数进行隐式类型转换，尤其是构造函数的参数只有一种的时候，强烈建议加上expilicit

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class MyClass {
public:
    explicit MyClass(int x) : value(x) {}
private:
    int value;
};

//MyClass obj = 42; //这样的代码将不再编译通过，因为编译器会认为这是一个错误的隐式转换。


explicit operator bool() const noexcept{return mPtr;}
//对转换函数防止隐式类型转换
//比如if(ptr)是可以的
//if(p1 == p2) 如果缺少了explicit那么就会导致p1和p2被隐式转换为了true，因此两者相等

编译器行为

当编译器遇到一个构造函数时，它会检查该构造函数是否标记为 explicit。如果构造函数是 explicit 的，那么编译器在进行以下操作时会进行检查并拒绝隐式转换：

1. 隐式转换：编译器会拒绝将其他类型的对象隐式转换为目标类型的对象。
2. 复制初始化：编译器会拒绝通过复制初始化的方式创建对象，例如 MyClass obj = value;。

char和int的转换

在C和C++编程中，char和int之间的转换是常见操作，因为字符数据类型(char)实际上是整数类型的一种，只不过它通常表示的是ASCII码表中的字符。以下是char和int之间的转换方法及注意事项。

char转int

将char类型转换为int类型时，实际是获取字符对应的ASCII值。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <stdio.h>

int main() {
    char c = 'A'; // 字符'A'的ASCII值为65
    int ascii_value = (int)c;

    printf("The ASCII value of %c is %d\n", c, ascii_value);

    return 0;
}

输出结果：

1

The ASCII value of A is 65

注意char溢出后的数值，char的范围是-128~127

比如500

500的二进制1 11110100 舍弃超过8bit的字符，那么就是1111 0100整形提升，1111 1111 1111 1111 1111 1111 1111 0100，然后转换成原码（取反 + 1）就是 1000 0000 0000 0000 0000 0000 0000 1100 所以就是-12

int转char

将int类型转换为char类型时，实际上是将整数解释为对应的ASCII字符。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <stdio.h>

int main() {
    int ascii_value = 65; // ASCII值65对应字符'A'
    char c = (char)ascii_value;

    printf("The character for ASCII value %d is %c\n", ascii_value, c);

    return 0;
}

输出结果：

1

The character for ASCII value 65 is A

friend友元类和友元函数

• 能访问私有成员
• 破坏封装性
• 友元关系不可传递
• 友元关系的单向性
• 友元声明的形式及数量不受限制

解决哈希冲突

拉链法 ： 哈希表的每个槽位关联一个链表。所有映射到同一个槽位的元素都将存储在这个槽位的链表中。当发生冲突时，元素简单地被添加到相应槽位的链表尾部。

开放寻址法：在开放寻址法中，所有元素都直接存储在哈希表数组中。当发生冲突时，采用某种探测技术在表中寻找另一个空槽来存储冲突的元素。开放寻址法的几种常见探测技术包括：

• 线性探测（Linear Probing）：顺序查找表中的下一个空槽。
• 平方探测（Quadratic Probing）：使用平方来计算探测的位置。
• 双重散列（Double Hashing）：使用第二个哈希函数来决定探测的步长

再哈希法（Rehashing）：再哈希法是一种解决哈希冲突的技术，也可以作为表容量扩展时重新分配所有键的方法。它使用多个哈希函数。当第一个哈希函数导致冲突时，尝试第二个哈希函数，依此类推，直到找到空槽位。

建立公共溢出区：这种方法的基本思想是：将哈希表分为基本表和溢出表两部分，凡是和基本表发生冲突的元素，一律填入溢出表。

常见的排序算法

快速排序

1. 从数列中挑出一个元素，称为 “基准”（pivot）;
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include<bits/stdc++.h>

using namespace std;

const int N = 100010;
int nums[N];
int n;

void quick_sort(int nums[], int l, int r)
{
    if(l >= r) return ;
    int i = l - 1, j = r + 1, x = nums[l + r >> 1];
    while(i < j)
    {
        do i ++; while(nums[i] < x);
        do j --; while(nums[j] > x);
        if(i < j)
        {
            swap(nums[i], nums[j]);
        }
    }
    
    quick_sort(nums, l, j), quick_sort(nums,j + 1, r);
}

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i++) scanf("%d", &nums[i]);
    
    quick_sort(nums, 0, n - 1);
    for (int i = 0; i < n; i++) printf("%d ", nums[i]);
    return 0;
}