Vafail的个人博客

只出现一次数字

Wed, 09 Sep 2026 00:00:00 GMT

题目：只出现一次的数字#

题目描述#

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

示例#

示例 1#

输入：nums = [2,2,1]
输出：1

示例 2#

输入：nums = [4,1,2,1,2]
输出：4

示例 3#

输入：nums = [1]
输出：1

提示#

1 <= nums.length <= 3 * 10^4
-3 * 10^4 <= nums[i] <= 3 * 10^4
除了某个元素只出现一次以外，其余每个元素均出现两次。

代码#

1
class Solution {
2
public:
3
    int singleNumber(vector<int>& nums) {
4
        int n=nums[0];
5
        for(int i=i=1;i<nums.size();i++){
6
            n^=nums[i];
7
        }
8
        return n;
9
    }
10
};

stream流

Mon, 01 Jun 2026 00:00:00 GMT

1. C++流的基本概念#

流（Stream） 是C++中用于处理输入和输出的抽象概念。流可以看作是数据的通道，例如从键盘到程序，或者从程序到文件。C++标准库提供了多种流类型来处理不同的数据传输需求。

常见的流类型#

标准输入流：std::cin
标准输出流：std::cout
标准错误流：std::cerr
文件输入流：std::ifstream
文件输出流：std::ofstream
文件流（读写）：std::fstream
字符串流：std::stringstream, std::istringstream, std::ostringstream

2. 输出流 `std::cout`#

std::cout 是C++中用于输出数据到标准输出（通常是终端）的流对象。

2.1 基本输出#

示例说明：使用 std::cout 输出文本和变量。

1
#include <iostream>
2

3
int main() {
4
    int age = 25;
5
    std::cout << "Hello, World!" << std::endl;
6
    std::cout << "I am " << age << " years old." << std::endl;
7
    return 0;
8
}

输出：

1
Hello, World!
2
I am 25 years old.

解释：

<< 运算符用于将数据插入到输出流中。
std::endl 用于输出一个换行符并刷新缓冲区。

2.2 格式化输出#

C++ 提供了多种方式来格式化输出，例如设置字段宽度、小数点精度等。

示例说明：使用不同的格式化操纵器。

1
#include <iostream>
2
#include <iomanip> // 引入iomanip头文件以使用操纵器
3

4
int main() {
5
    double pi = 3.141592653589793;
6
    int num = 42;
7

8
    // 设置浮点数的显示精度
9
    std::cout << "Pi with default precision: " << pi << std::endl;
10
    std::cout << "Pi with 4 decimal places: " << std::fixed << std::setprecision(4) << pi << std::endl;
11

12
    // 设置字段宽度和对齐方式
13
    std::cout << "Number with width 5: |" << std::setw(5) << num << "|" << std::endl;
14
    std::cout << "Number with width 5 (left aligned): |" << std::left << std::setw(5) << num << "|" << std::endl;
15

16
    return 0;
17
}

展开收起

输出：

1
Pi with default precision: 3.14159
2
Pi with 4 decimal places: 3.1416
3
Number with width 5: |   42|
4
Number with width 5 (left aligned): |42   |

解释：

std::fixed：以固定小数点格式显示浮点数。
std::setprecision(4)：设置小数点后4位精度。
std::setw(5)：设置输出字段宽度为5个字符。
std::left：设置左对齐。

3. 文件输出流 `std::ofstream`#

std::ofstream 用于创建和写入文件。

3.1 创建和打开文件#

在使用 std::ofstream 写入文件之前，需要创建一个 ofstream 对象并打开目标文件。

3.2 向文件写入数据#

使用 << 操作符可以向文件中写入数据，类似于 std::cout。

3.3 关闭文件#

写入完成后，应关闭文件以释放资源。

3.4 示例代码#

示例说明：创建一个文本文件并写入数据。

1
#include <iostream>
2
#include <fstream> // 引入 fstream 头文件
3

4
int main() {
5
    // 创建一个ofstream对象，并打开文件 "output.txt"
6
    std::ofstream outfile("output.txt");
7

8
    // 检查文件是否成功打开
9
    if (!outfile) {
10
        std::cerr << "无法打开文件进行写入。" << std::endl;
11
        return 1;
12
    }
13

14
    // 向文件中写入数据
15
    outfile << "这是第一行。\n";
16
    outfile << "这是第二行，数字：" << 100 << std::endl;
17
    outfile << "浮点数：" << 3.14159 << std::endl;
18

19
    // 关闭文件
20
    outfile.close();
21

22
    std::cout << "数据已成功写入 output.txt 文件。" << std::endl;
23

24
    return 0;
25
}

展开收起

运行结果：

1
数据已成功写入 output.txt 文件。

output.txt** 文件内容**：

1
这是第一行。
2
这是第二行，数字：100
3
浮点数：3.14159

解释：

创建 std::ofstream 对象时，如果文件不存在则会自动创建，若存在则默认覆盖。
使用 << 操作符写入字符串、整数和浮点数到文件。
outfile.close() 用于关闭文件。

4. 文件输入流 `std::ifstream`#

std::ifstream 用于打开和读取文件内容。

4.1 打开和读取文件#

使用 std::ifstream 对象打开目标文件，并读取其中的数据。

4.2 处理读取的数据#

可以逐行读取、逐词读取或按其他格式读取数据。

4.3 关闭文件#

读取完成后，应关闭文件。

4.4 示例代码#

示例说明：读取 output.txt 文件并输出内容到控制台。

1
#include <iostream>
2
#include <fstream>
3
#include <string> // 引入 string 头文件
4

5
int main() {
6
    // 创建一个ifstream对象，并打开文件 "output.txt"
7
    std::ifstream infile("output.txt");
8

9
    // 检查文件是否成功打开
10
    if (!infile) {
11
        std::cerr << "无法打开文件进行读取。" << std::endl;
12
        return 1;
13
    }
14

15
    std::string line;
16

17
    // 逐行读取文件内容
18
    while (std::getline(infile, line)) {
19
        std::cout << line << std::endl;
20
    }
21

22
    // 关闭文件
23
    infile.close();
24

25
    return 0;
26
}

展开收起

输出：

1
这是第一行。
2
这是第二行，数字：100
3
浮点数：3.14159

解释：

使用 std::getline 函数逐行读取文件内容。
读取到的每一行存储在 std::string 类型的 line 变量中。
通过 std::cout 将读取到的每一行输出到控制台。

5. 文件流 `std::fstream` （读写结合）#

std::fstream 允许同时进行文件的读写操作。

5.1 同时进行读写操作#

通过打开文件的不同模式，可以实现对同一文件的读取和写入。

5.2 示例代码#

示例说明：在同一个文件中读取现有内容并追加新内容。

1
#include <iostream>
2
#include <fstream>
3
#include <string>
4

5
int main() {
6
    // 创建一个 fstream 对象，并以读写模式打开文件 "data.txt"
7
    std::fstream file("data.txt", std::ios::in | std::ios::out | std::ios::app);
8

9
    // 检查文件是否成功打开
10
    if (!file) {
11
        std::cerr << "无法打开文件进行读写。" << std::endl;
12
        return 1;
13
    }
14

15
    // 向文件追加新内容
16
    file << "追加的一行内容。\n";
17

18
    // 将文件指针移动到文件开头以读取内容
19
    file.seekg(0, std::ios::beg);
20

21
    std::string line;
22

23
    std::cout << "文件内容如下：" << std::endl;
24

25
    // 读取文件内容并输出
26
    while (std::getline(file, line)) {
27
        std::cout << line << std::endl;
28
    }
29

30
    // 关闭文件
31
    file.close();
32

33
    return 0;
34
}

展开收起

解释：

std::ios::in：以读取模式打开文件。
std::ios::out：以写入模式打开文件。
std::ios::app：以追加模式写入文件（数据会被添加到文件末尾）。
使用 seekg 将读取位置移动到文件开头，以便读取整个文件内容。
先写入数据，再读取整个文件内容，实现读写结合。

注意：

如果文件不存在，使用 std::ios::in 和 std::ios::out 组合可能无法创建新文件。在这种情况下，可以添加 std::ios::trunc 或 std::ios::ate 标志，或者先创建文件。

6. 字符串流 `std::stringstream`#

std::stringstream 是 C++ 标准库提供的一个类，用于在字符串和其他数据类型之间进行格式化输入和输出。它允许我们像操作文件或控制台流一样操作字符串，非常适合于字符串解析、格式化和转换。

6.1 `std::stringstream` 的基本概念#

std::stringstream：同时具备 std::istringstream（输入流）和 std::ostringstream（输出流）的功能，既可以从字符串中读取数据，也可以向字符串中写入数据。
std::istringstream：仅用于从字符串中读取数据。
std::ostringstream：仅用于向字符串中写入数据。

6.2 字符串与其他数据类型的转换#

std::stringstream 常用于以下场景：

将其他数据类型转换为字符串。
将字符串解析为其他数据类型。
构建复杂的字符串。

6.3 示例代码#

6.3.1 将多个数据类型组合成一个字符串#

示例说明：使用 std::stringstream 将整数、浮点数和字符串组合成一个字符串。

1
#include <iostream>
2
#include <sstream>
3
#include <string>
4

5
int main() {
6
    int id = 101;
7
    std::string name = "Alice";
8
    double score = 95.5;
9

10
    std::stringstream ss;
11
    ss << "ID: " << id << ", Name: " << name << ", Score: " << score;
12

13
    std::string result = ss.str();
14
    std::cout << result << std::endl;
15

16
    return 0;
17
}

展开收起

输出：

1
ID: 101, Name: Alice, Score: 95.5

解释：

创建 std::stringstream 对象 ss。
使用 << 操作符将不同类型的数据插入到流中。
使用 ss.str() 获取累积的字符串内容。

6.3.2 从字符串中解析数据#

示例说明：使用 std::stringstream 从一个格式化的字符串中提取数据。

1
#include <iostream>
2
#include <sstream>
3
#include <string>
4

5
int main() {
6
    std::string data = "2023 JohnDoe 85.6";
7
    int year;
8
    std::string name;
9
    double grade;
10

11
    std::stringstream ss(data);
12
    ss >> year >> name >> grade;
13

14
    std::cout << "Year: " << year << std::endl;
15
    std::cout << "Name: " << name << std::endl;
16
    std::cout << "Grade: " << grade << std::endl;
17

18
    return 0;
19
}

展开收起

输出：

1
Year: 2023
2
Name: JohnDoe
3
Grade: 85.6

解释：

将字符串 data 初始化到 std::stringstream 对象 ss 中。
使用 >> 操作符从流中提取数据，按顺序赋值给变量。

6.3.3 字符串与数字的相互转换#

示例说明：将字符串转换为整数和浮点数，以及将数字转换为字符串。

1
#include <iostream>
2
#include <sstream>
3
#include <string>
4

5
int main() {
6
    // 字符串转换为整数和浮点数
7
    std::string numStr = "12345";
8
    std::string floatStr = "98.76";
9
    int number;
10
    double decimal;
11

12
    std::stringstream ss1(numStr);
13
    ss1 >> number;
14

15
    std::stringstream ss2(floatStr);
16
    ss2 >> decimal;
17

18
    std::cout << "字符串 \"" << numStr << "\" 转换为整数：" << number << std::endl;
19
    std::cout << "字符串 \"" << floatStr << "\" 转换为浮点数：" << decimal << std::endl;
20

21
    // 数字转换为字符串
22
    int num = 6789;
23
    double dec = 12.34;
24
    std::stringstream ss3;
25
    ss3 << num << " and " << dec;
26

27
    std::string combinedStr = ss3.str();
28
    std::cout << "数字转换为字符串：" << combinedStr << std::endl;
29

30
    return 0;
31
}

展开收起

输出：

Terminal window

1
字符串 "12345" 转换为整数：12345
2
字符串 "98.76" 转换为浮点数：98.76
3
数字转换为字符串：6789 and 12.34

解释：

使用 std::stringstream 将字符串解析为数字。
使用 std::stringstream 将数字格式化为字符串。

6.3.4 使用 `std::istringstream` 和 `std::ostringstream`#

std::istringstream 和 std::ostringstream 是 std::stringstream 的专门化版本，分别用于只读和只写操作。

示例说明：分别使用 std::istringstream 读取数据，和 std::ostringstream 构建字符串。

1
#include <iostream>
2
#include <sstream>
3
#include <string>
4

5
int main() {
6
    // 使用 std::istringstream 读取数据
7
    std::string input = "2023 Bob 75.5";
8
    int year;
9
    std::string name;
10
    double score;
11

12
    std::istringstream iss(input);
13
    iss >> year >> name >> score;
14

15
    std::cout << "Parsed Data:" << std::endl;
16
    std::cout << "Year: " << year << ", Name: " << name << ", Score: " << score << std::endl;
17

18
    // 使用 std::ostringstream 构建字符串
19
    std::ostringstream oss;
20
    oss << "Year: " << year << ", Name: " << name << ", Score: " << score;
21

22
    std::string output = oss.str();
23
    std::cout << "Formatted String: " << output << std::endl;
24

25
    return 0;
26
}

展开收起

输出：

1
Parsed Data:
2
Year: 2023, Name: Bob, Score: 75.5
3
Formatted String: Year: 2023, Name: Bob, Score: 75.5

解释：

std::istringstream 用于从字符串 input 中提取数据。
std::ostringstream 用于将数据格式化为字符串 output。

6.3.5 处理复杂的字符串格式#

示例说明：从包含逗号分隔值的字符串中提取数据。

1
#include <iostream>
2
#include <sstream>
3
#include <string>
4

5
int main() {
6
    std::string csvData = "John,25,80.5";
7
    std::string name;
8
    int age;
9
    double score;
10

11
    std::stringstream ss(csvData);
12
    std::getline(ss, name, ','); // 使用逗号作为分隔符
13
    ss >> age;
14
    ss.ignore(1); // 忽略逗号
15
    ss >> score;
16

17
    std::cout << "Name: " << name << std::endl;
18
    std::cout << "Age: " << age << std::endl;
19
    std::cout << "Score: " << score << std::endl;
20

21
    return 0;
22
}

展开收起

输出：

1
Name: John
2
Age: 25
3
Score: 80.5

解释：

使用 std::getline 从 stringstream 中读取以逗号分隔的字符串。
使用 ignore 忽略分隔符。

6.4 总结#

std::stringstream 是一个强大的工具，适用于字符串与其他数据类型之间的转换、格式化输出和解析复杂的字符串数据。通过熟练掌握 std::stringstream 的使用，可以大大简化数据处理任务，提高代码的可读性和维护性。

7. 其他流操作#

除了基本的读写操作，C++流还提供了许多其他功能，如错误检查、不同的读取方式、不同的打开模式等。

7.1 检查文件是否成功打开#

在进行任何读写操作前，检查文件是否成功打开是一个好习惯。

示例：

1
#include <iostream>
2
#include <fstream>
3

4
int main() {
5
    std::ofstream outfile("output.txt");
6
    if (!outfile.is_open()) {
7
        std::cerr << "文件无法打开！" << std::endl;
8
        return 1;
9
    }
10
    // 其他操作
11
    outfile.close();
12
    return 0;
13
}

7.2 逐行读取 vs 逐词读取#

逐行读取：使用 std::getline 逐行读取文件内容。
逐词读取：使用 >> 运算符逐词读取文件内容。

示例：

1
#include <iostream>
2
#include <fstream>
3
#include <string>
4

5
int main() {
6
    std::ifstream infile("output.txt");
7
    if (!infile) {
8
        std::cerr << "无法打开文件。" << std::endl;
9
        return 1;
10
    }
11

12
    std::string word;
13
    std::cout << "逐词读取文件内容：" << std::endl;
14
    while (infile >> word) {
15
        std::cout << word << std::endl;
16
    }
17

18
    infile.close();
19
    return 0;
20
}

展开收起

输出（假设 output.txt 内容如下）：

1
这是第一行。
2
这是第二行，数字：100
3
浮点数：3.14159

具体输出：

1
逐词读取文件内容：
2
这是第一行。
3
这是第二行，数字：100
4
浮点数：3.14159

解释：

infile >> word 会根据空格、换行符等分隔符逐个读取单词。

7.3 错误处理#

在文件操作中，可能会遇到各种错误情况，如文件不存在、权限不足等。通过流的状态标志可以进行相应的错误处理。

示例：

1
#include <iostream>
2
#include <fstream>
3

4
int main() {
5
    std::ifstream infile("nonexistent.txt");
6
    if (!infile) {
7
        std::cerr << "错误：无法打开文件。" << std::endl;
8
        return 1;
9
    }
10

11
    // 其他操作
12

13
    infile.close();
14
    return 0;
15
}

展开收起

解释：

如果文件 nonexistent.txt 不存在，程序会输出错误消息并退出。

7.4 追加模式#

使用 std::ios::app 可以以追加模式打开文件，数据将被添加到文件末尾，而不是覆盖原有内容。

示例：

1
#include <iostream>
2
#include <fstream>
3

4
int main() {
5
    std::ofstream outfile("log.txt", std::ios::app);
6
    if (!outfile) {
7
        std::cerr << "无法打开文件进行追加写入。" << std::endl;
8
        return 1;
9
    }
10

11
    outfile << "新的一条日志记录。\n";
12

13
    outfile.close();
14
    std::cout << "日志已追加。" << std::endl;
15

16
    return 0;
17
}

展开收起

解释：

每次运行该程序，新的日志记录都会被添加到 log.txt 的末尾，而不会删除之前的内容。

7.5 读写模式中的其他标志#

std::ios::binary：以二进制模式打开文件。
std::ios::trunc：如果文件已存在，打开时会清空文件内容。
std::ios::ate：打开文件并将文件指针移动到文件末尾，允许在文件末尾追加。

示例：

1
#include <iostream>
2
#include <fstream>
3

4
int main() {
5
    // 以二进制模式写入数据
6
    std::ofstream outfile("binary.dat", std::ios::binary);
7
    if (!outfile) {
8
        std::cerr << "无法打开二进制文件。" << std::endl;
9
        return 1;
10
    }
11

12
    int number = 12345;
13
    outfile.write(reinterpret_cast<char*>(&number), sizeof(number));
14
    outfile.close();
15

16
    // 以二进制模式读取数据
17
    std::ifstream infile("binary.dat", std::ios::binary);
18
    if (!infile) {
19
        std::cerr << "无法打开二进制文件进行读取。" << std::endl;
20
        return 1;
21
    }
22

23
    int readNumber;
24
    infile.read(reinterpret_cast<char*>(&readNumber), sizeof(readNumber));
25
    std::cout << "读取的数字是：" << readNumber << std::endl;
26

27
    infile.close();
28
    return 0;
29
}

展开收起

输出：

1
读取的数字是：12345

解释：

使用 std::ios::binary 以二进制模式打开文件。
write 和 read 方法用于写入和读取二进制数据。
reinterpret_cast<char*> 将数据类型转换为字节流。

注意：

二进制模式适用于非文本数据，可以提高读写效率，但可读性较差。
在不同操作系统之间传输二进制文件时，需要注意字节序（Endianess）的问题。

7.6 实际应用示例#

示例说明：读取一个文本文件，统计单词出现的次数，并将结果写入另一个文件。

1
#include <iostream>
2
#include <fstream>
3
#include <string>
4
#include <map>
5

6
int main() {
7
    std::ifstream infile("input.txt");
8
    if (!infile) {
9
        std::cerr << "无法打开 input.txt 进行读取。" << std::endl;
10
        return 1;
11
    }
12

13
    std::map<std::string, int> wordCount;
14
    std::string word;
15

16
    // 逐词读取并统计
17
    while (infile >> word) {
18
        // 可以添加更多的处理，如去除标点符号、转换为小写等
19
        wordCount[word]++;
20
    }
21

22
    infile.close();
23

24
    std::ofstream outfile("word_count.txt");
25
    if (!outfile) {
26
        std::cerr << "无法打开 word_count.txt 进行写入。" << std::endl;
27
        return 1;
28
    }
29

30
    // 写入统计结果
31
    for (const auto& pair : wordCount) {
32
        outfile << pair.first << ": " << pair.second << std::endl;
33
    }
34

35
    outfile.close();
36

37
    std::cout << "单词统计已完成，结果保存在 word_count.txt 中。" << std::endl;
38

39
    return 0;
40
}

展开收起

解释：

读取 input.txt 文件中的每个单词，并使用 std::map 统计每个单词出现的次数。
将统计结果写入 word_count.txt 文件中。
这是一个简单的文本分析工具，可以进一步扩展功能，如忽略大小写、去除标点符号等。

单例模式

Sun, 31 May 2026 00:00:00 GMT

单例模式概念#

单例模式（Singleton Pattern）是一种创建型设计模式，旨在确保一个类在整个应用程序生命周期中仅且只有一个实例，并提供一个全局访问点以获取该实例。设计单例模式的主要原因和作用包括以下几个方面：

1. 控制实例数量#

单例模式确保一个类只有一个实例，防止在程序中创建多个实例可能导致的资源浪费或状态不一致问题。例如，数据库连接池、配置管理类等通常使用单例模式，以确保全局只有一个连接池或配置实例。

2. 提供全局访问点#

单例模式通过提供一个全局访问点，使得在程序的任何地方都可以方便地访问该实例。这对于那些需要在多个模块或组件之间共享的资源或服务尤为重要，如日志记录器、缓存管理器等。

3. 延迟实例化#

单例模式通常采用懒加载的方式，即在第一次需要使用实例时才创建。这有助于节省系统资源，特别是在实例创建成本较高或初期并不需要该实例的情况下。

4. 避免命名冲突#

通过将单例实例作为一个类的静态成员，可以避免在全局命名空间中引入多个实例，减少命名冲突的风险。

5. 管理共享资源#

在多线程环境下，单例模式可以有效管理共享资源，确保线程安全。例如，操作系统中的线程池、任务管理器等常使用单例模式，以协调多个线程对资源的访问。

设计单例模式的考虑因素#

虽然单例模式有诸多优点，但在设计和使用时也需要注意以下几点：

线程安全：在多线程环境下，需要确保单例实例的创建和访问是线程安全的，常用的方法有双重检查锁定（Double-Checked Locking）和使用静态内部类等。
延迟初始化：根据需求选择是否采用延迟初始化，以平衡性能和资源利用。
可测试性：单例模式可能会影响代码的可测试性，特别是在单元测试中，可能需要通过依赖注入等手段来替代单例实例。
限制扩展：单例模式通过限制实例数量可能会限制类的扩展性，需谨慎使用。

适用场景#

需要确保全局只有一个实例的场景，如配置管理、日志系统、设备驱动等。
需要全局访问点来协调系统中的多个部分，如缓存、线程池等。

不适用场景#

需要多个实例以满足不同需求的场景。
对象的生命周期需要更灵活控制的场合。

总的来说，单例模式通过控制类的实例数量和提供全局访问点，为系统资源管理和状态一致性提供了有效的解决方案。然而，在实际应用中，应根据具体需求和上下文环境，谨慎决定是否使用单例模式，以避免潜在的设计问题。

局部静态变量方式#

这种方式最简单

1
//通过静态成员变量实现单例
2
//懒汉式
3
class Single2
4
{
5
private:
6
    Single2()
7
    {
8
    }
9
    Single2(const Single2 &) = delete;
10
    Single2 &operator=(const Single2 &) = delete;
11
public:
12
    static Single2 &GetInst()
13
    {
14
        static Single2 single;
15
        return single;
16
    }
17
};

展开收起

上述代码通过局部静态成员single实现单例类，原理就是函数的局部静态变量生命周期随着进程结束而结束。上述代码通过懒汉式的方式实现。
调用如下

1
void test_single2()
2
{
3
    //多线程情况下可能存在问题
4
    cout << "s1 addr is " << &Single2::GetInst() << endl;
5
    cout << "s2 addr is " << &Single2::GetInst() << endl;
6
}

程序输出如下

Terminal window

1
sp1  is  0x1304b10
2
sp2  is  0x1304b10

确实生成了唯一实例，在C++98年代，上述单例模式存在隐患，对于多线程方式生成的实例可能时多个。

随着C++ 11的来临，这种方式不再存在线程安全问题，是最为简单也是最适合新手的方式。

静态成员变量指针方式(饿汉式)#

可以定义一个类的静态成员变量，用来控制实现单例，这种方式依靠静态成员提前初始化保证生成的单例是唯一的。

1
//饿汉式
2
class Single2Hungry
3
{
4
private:
5
    Single2Hungry()
6
    {
7
    }
8
    Single2Hungry(const Single2Hungry &) = delete;
9
    Single2Hungry &operator=(const Single2Hungry &) = delete;
10
public:
11
    static Single2Hungry *GetInst()
12
    {
13
        if (single == nullptr)
14
        {
15
            single = new Single2Hungry();
16
        }
17
        return single;
18
    }
19
private:
20
    static Single2Hungry *single;
21
};

展开收起

这么做的一个好处是我们可以通过饿汉式的方式避免线程安全问题

1
//饿汉式初始化
2
Single2Hungry *Single2Hungry::single = Single2Hungry::GetInst();
3
void thread_func_s2(int i)
4
{
5
    cout << "this is thread " << i << endl;
6
    cout << "inst is " << Single2Hungry::GetInst() << endl;
7
}
8
void test_single2hungry()
9
{
10
    cout << "s1 addr is " << Single2Hungry::GetInst() << endl;
11
    cout << "s2 addr is " << Single2Hungry::GetInst() << endl;
12
    for (int i = 0; i < 3; i++)
13
    {
14
        thread tid(thread_func_s2, i);
15
        tid.join();
16
    }
17
}
18
int main(){
19
    test_single2hungry()
20
}

展开收起

程序输出如下

Terminal window

1
s1 addr is 0x1e4b00
2
s2 addr is 0x1e4b00
3
this is thread 0
4
inst is 0x1e4b00
5
this is thread 1
6
inst is 0x1e4b00
7
this is thread 2
8
inst is 0x1e4b00

可见无论单线程还是多线程模式下，通过静态成员变量的指针实现的单例类都是唯一的。

饿汉式是在程序启动时就进行单例的初始化，这种方式也可以通过懒汉式调用，无论饿汉式还是懒汉式都存在一个问题，就是什么时候释放内存？

多线程情况下，释放内存就很难了，还有二次释放内存的风险。

静态成员变量指针方式(懒汉式)#

我们定义一个单例类并用懒汉式方式调用

1
//懒汉式指针
2
//即使创建指针类型也存在问题
3
class SinglePointer
4
{
5
private:
6
    SinglePointer()
7
    {
8
    }
9
    SinglePointer(const SinglePointer &) = delete;
10
    SinglePointer &operator=(const SinglePointer &) = delete;
11
public:
12
    static SinglePointer *GetInst()
13
    {
14
        if (single != nullptr)
15
        {
16
            return single;
17
        }
18
        s_mutex.lock();
19
        if (single != nullptr)
20
        {
21
            s_mutex.unlock();
22
            return single;
23
        }
24
        single = new SinglePointer();
25
        s_mutex.unlock();
26
        return single;
27
    }
28
private:
29
    static SinglePointer *single;
30
    static mutex s_mutex;
31
};

展开收起

在cpp文件里初始化静态成员,并定义一个测试函数

1
//懒汉式
2
//在类的cpp文件定义static变量
3
SinglePointer *SinglePointer::single = nullptr;
4
std::mutex SinglePointer::s_mutex;
5
void thread_func_lazy(int i)
6
{
7
    cout << "this is lazy thread " << i << endl;
8
    cout << "inst is " << SinglePointer::GetInst() << endl;
9
}
10
void test_singlelazy()
11
{
12
    for (int i = 0; i < 3; i++)
13
    {
14
        thread tid(thread_func_lazy, i);
15
        tid.join();
16
    }
17
    //何时释放new的对象？造成内存泄漏
18
}
19
int main(){
20
    test_singlelazy();
21
}

展开收起

函数输出如下

Terminal window

1
this is lazy thread 0
2
inst is 0xbc1700
3
this is lazy thread 1
4
inst is 0xbc1700
5
this is lazy thread 2
6
inst is 0xbc1700

此时生成的单例对象的内存空间还没回收，这是个问题，另外如果多线程情况下多次delete也会造成崩溃。

C++11改进

我们可以利用C++11 提供的once_flag实现安全的创建

1
#ifndef DAY34_SINGLETON_SINGLETON_H
2
#define DAY34_SINGLETON_SINGLETON_H
3

4
#include <mutex>
5
#include <iostream>
6

7
class SingletonOnceFlag{
8
public:
9
    static SingletonOnceFlag* getInstance(){
10
        static std::once_flag flag;
11
        std::call_once(flag, []{
12
            _instance = new SingletonOnceFlag();
13
        });
14
        return _instance;
15
    }
16

17
    void PrintAddress() {
18
        std::cout << _instance << std::endl;
19
    }
20
    ~SingletonOnceFlag() {
21
        std::cout << "this is singleton destruct" << std::endl;
22
    }
23
private:
24
    SingletonOnceFlag() = default;
25
    SingletonOnceFlag(const SingletonOnceFlag&) = delete;
26
    SingletonOnceFlag& operator=(const SingletonOnceFlag& st) = delete;
27
    static SingletonOnceFlag* _instance;
28

29
};
30

31

32
#endif //DAY34_SINGLETON_SINGLETON_H

展开收起

static成员要在cpp中初始化

1
SingletonOnceFlag *SingletonOnceFlag::_instance = nullptr;

测试

1
#include "Singleton.h"
2
#include <thread>
3
#include <mutex>
4
int main() {
5
    system("chcp 65001 > nul");
6
    std::mutex mtx;
7
    std::thread t1([&](){
8
        SingletonOnceFlag::getInstance();
9
        std::lock_guard<std::mutex> lock(mtx);
10
        SingletonOnceFlag::getInstance()->PrintAddress();
11
    });
12

13
    std::thread t2([&](){
14
        SingletonOnceFlag::getInstance();
15
        std::lock_guard<std::mutex> lock(mtx);
16
        SingletonOnceFlag::getInstance()->PrintAddress();
17
    });
18

19
    t1.join();
20
    t2.join();
21

22
    return 0;
23
}

展开收起

测试结果

1
0x19a74de7420
2
0x19a74de7420

智能指针方式(懒汉式)#

可以利用智能指针自动回收内存的机制设计单例类

1
#ifndef DAY34_SINGLETON_SINGLETON_H
2
#define DAY34_SINGLETON_SINGLETON_H
3

4
#include <mutex>
5
#include <iostream>
6
#include <memory>
7

8
class SingletonOnceFlag{
9
public:
10
    static std::shared_ptr<SingletonOnceFlag> getInstance(){
11
        static std::once_flag flag;
12
        std::call_once(flag, []{
13
            _instance = std::shared_ptr<SingletonOnceFlag>(new SingletonOnceFlag());
14
        });
15
        return _instance;
16
    }
17

18
    void PrintAddress() {
19
        std::cout << _instance << std::endl;
20
    }
21
    ~SingletonOnceFlag() {
22
        std::cout << "this is singleton destruct" << std::endl;
23
    }
24
private:
25
    SingletonOnceFlag() = default;
26
    SingletonOnceFlag(const SingletonOnceFlag&) = delete;
27
    SingletonOnceFlag& operator=(const SingletonOnceFlag& st) = delete;
28
    static std::shared_ptr<SingletonOnceFlag> _instance;
29

30
};
31

32

33
#endif //DAY34_SINGLETON_SINGLETON_H

展开收起

同样在SingletonOnceFlag.cpp中进行单例成员的初始化

1
#include "Singleton.h"
2

3
std::shared_ptr<SingletonOnceFlag> SingletonOnceFlag::_instance = nullptr;

再次测试

1
#include <iostream>
2
#include "Singleton.h"
3
#include <thread>
4
#include <mutex>
5
int main() {
6
    system("chcp 65001 > nul");
7
    std::mutex mtx;
8
    std::thread t1([&](){
9
        SingletonOnceFlag::getInstance();
10
        std::lock_guard<std::mutex> lock(mtx);
11
        SingletonOnceFlag::getInstance()->PrintAddress();
12
    });
13

14
    std::thread t2([&](){
15
        SingletonOnceFlag::getInstance();
16
        std::lock_guard<std::mutex> lock(mtx);
17
        SingletonOnceFlag::getInstance()->PrintAddress();
18
    });
19

20
    t1.join();
21
    t2.join();
22

23
    return 0;
24
}

展开收起

这次输出析构信息

Terminal window

1
0x1d620a47420
2
0x1d620a47420
3
this is singleton destruct

辅助类智能指针单例模式#

智能指针在构造的时候可以指定删除器，所以可以传递一个辅助类或者辅助函数帮助智能指针回收内存时调用我们指定的析构函数。

1
//
2
// Created by secon on 2025/3/1.
3
//
4

5
#ifndef DAY34_SINGLETON_SINGLETON_H
6
#define DAY34_SINGLETON_SINGLETON_H
7

8
#include <mutex>
9
#include <iostream>
10
#include <memory>
11

12
class SingleAutoSafe;
13
class SafeDeletor
14
{
15
public:
16
    void operator()(SingleAutoSafe *sf)
17
    {
18
        std::cout << "this is safe deleter operator()" << std::endl;
19
        delete sf;
20
    }
21
};
22

23
class SingleAutoSafe{
24
public:
25
    static std::shared_ptr<SingleAutoSafe> getInstance(){
26
        static std::once_flag flag;
27
        std::call_once(flag, []{
28
            _instance = std::shared_ptr<SingleAutoSafe>(new SingleAutoSafe(), SafeDeletor());
29
        });
30
        return _instance;
31
    }
32

33
    void PrintAddress() {
34
        std::cout << _instance << std::endl;
35
    }
36
    //定义友元类，通过友元类调用该类析构函数
37
    friend class SafeDeletor;
38
private:
39
    SingleAutoSafe() = default;
40
    SingleAutoSafe(const SingleAutoSafe&) = delete;
41
    SingleAutoSafe& operator=(const SingleAutoSafe& st) = delete;
42
    ~SingleAutoSafe() {
43
        std::cout << "this is singleton destruct" << std::endl;
44
    }
45
    static std::shared_ptr<SingleAutoSafe> _instance;
46

47
};
48

49

50
#endif //DAY34_SINGLETON_SINGLETON_H

展开收起

在cpp文件中实现静态成员的定义

1
#include "Singleton.h"
2

3
std::shared_ptr<SingleAutoSafe> SingleAutoSafe::_instance = nullptr;

SafeDeletor要写在SingleAutoSafe上边，并且SafeDeletor要声明为SingleAutoSafe类的友元类，这样就可以访问SingleAutoSafe的析构函数了。

我们在构造single时制定了SafeDeletor(),single在回收时，会调用SingleAutoSafe的仿函数，从而完成内存的销毁。

并且SingleAutoSafe的析构函数为私有的无法被外界手动调用了。

测试

1
#include <iostream>
2
#include "Singleton.h"
3
#include <thread>
4
#include <mutex>
5
int main() {
6
    system("chcp 65001 > nul");
7
    std::mutex mtx;
8
    std::thread t1([&](){
9
        SingleAutoSafe::getInstance();
10
        std::lock_guard<std::mutex> lock(mtx);
11
        SingleAutoSafe::getInstance()->PrintAddress();
12
    });
13

14
    std::thread t2([&](){
15
        SingleAutoSafe::getInstance();
16
        std::lock_guard<std::mutex> lock(mtx);
17
        SingleAutoSafe::getInstance()->PrintAddress();
18
    });
19

20
    t1.join();
21
    t2.join();
22

23
    return 0;
24
}

展开收起

程序输出

Terminal window

1
0x1b379b07420
2
0x1b379b07420
3
this is safe deleter operator()

通用的单例模板类(CRTP)#

我们可以通过声明单例的模板类，然后继承这个单例模板类的所有类就是单例类了。达到泛型编程提高效率的目的。

CRTP的概念

CRTP是一种将派生类作为模板参数传递给基类的技术，即一个类继承自一个以自身为模板参数的基类。这种模式常用于实现静态多态、接口的默认实现、编译时策略选择等。

比如

1
template <typename T>
2
class TempClass {
3
  //...
4
};
5
//CRTP
6
class RealClass: public TempClass<RealClass>{
7
  //...
8
};

单例基类实现

1
#include <memory>
2
#include <mutex>
3
#include <iostream>
4
using namespace std;
5
template <typename T>
6
class Singleton {
7
protected:
8
    Singleton() = default;
9
    Singleton(const Singleton<T>&) = delete;
10
    Singleton& operator=(const Singleton<T>& st) = delete;
11

12
    static std::shared_ptr<T> _instance;
13
public:
14
    static std::shared_ptr<T> GetInstance() {
15
        static std::once_flag s_flag;
16
        std::call_once(s_flag, [&]() {
17
            _instance = shared_ptr<T>(new T);
18
        });
19

20
        return _instance;
21
    }
22
    void PrintAddress() {
23
        std::cout << _instance.get() << endl;
24
    }
25
    ~Singleton() {
26
        std::cout << "this is singleton destruct" << std::endl;
27
    }
28
};
29

30
template <typename T>
31
std::shared_ptr<T> Singleton<T>::_instance = nullptr;

展开收起

我们定义一个网络的单例类，继承上述模板类即可，并将构造和析构设置为私有，同时设置友元保证自己的析构和构造可以被友元类调用.

1
//通过继承方式实现网络模块单例
2
class SingleNet : public Singleton<SingleNet>
3
{
4
    friend class Singleton<SingleNet>;
5
private:
6
    SingleNet() = default;
7
public:
8
    ~SingleNet() {
9
        std::cout << "SingleNet destruct " << std::endl;
10
    }
11
};

测试案例

1
#include <iostream>
2
#include "Singleton.h"
3
#include <thread>
4
#include <mutex>
5
int main() {
6
    system("chcp 65001 > nul");
7
    std::mutex mtx;
8
    std::thread t1([&](){
9
        SingleNet::GetInstance();
10
        std::lock_guard<std::mutex> lock(mtx);
11
        SingleNet::GetInstance()->PrintAddress();
12
    });
13

14
    std::thread t2([&](){
15
        SingleNet::GetInstance();
16
        std::lock_guard<std::mutex> lock(mtx);
17
        SingleNet::GetInstance()->PrintAddress();
18
    });
19

20
    t1.join();
21
    t2.join();
22

23
    return 0;
24
}

展开收起

程序输出

1
0x212248b7420
2
0x212248b7420
3
SingleNet destruct
4
this is singleton destruct

万能引用和原样转发

Sat, 30 May 2026 00:00:00 GMT

1. 左值与右值#

1.1 定义与分类#

**左值（lvalue）和右值（rvalue）**是C++中用于描述表达式值类别的重要概念。

左值（lvalue）：
- 表示具有持久存储的对象。
- 可以出现在赋值语句的左侧。
- 可以被取地址（即，可以使用&运算符）。
- 示例：变量名、引用等。
右值（rvalue）：
- 表示临时对象或没有持久存储的值。
- 通常出现在赋值语句的右侧。
- 不能被取地址。
- 示例：字面量、临时对象、表达式结果等。

C++11进一步细化了右值的分类：

纯右值（prvalues）：表示临时对象或字面量，如42、3.14。
将亡值（xvalues，expiring values）：表示即将被移动的对象，如std::move的结果。

1.2 示例代码#

1
#include <iostream>
2
#include <string>
3
#include <utility>
4

5
int main() {
6
    int a = 10;           // a是一个左值
7
    int& b = a;           // b是a的左值引用
8
    int&& c = 20;         // c是一个右值引用，绑定到临时右值20
9
    int d = a + 5;        // (a + 5)是一个纯右值
10

11
    std::string s1 = "Hello";                   // s1是一个左值
12
    std::string s2 = std::string("World");      // std::string("World")是一个纯右值
13

14
    std::cout << "a: " << a << ", d: " << d << std::endl;
15
    std::cout << "s1: " << s1 << ", s2: " << s2 << std::endl;
16

17
    // 检查类型
18
    std::cout << std::boolalpha;
19
    // 使用 decltype((a)) 获取 a 的类型，包括引用
20
    // `(a)` 是一个左值表达式，所以 decltype((a)) 是 `int&`
21
    std::cout << "a 是左值: " << std::is_lvalue_reference<decltype((a))>::value << std::endl;
22
    std::cout << "c 是右值引用: " << std::is_rvalue_reference<decltype(c)>::value << std::endl;
23

24
    return 0;
25
}

展开收起

输出：

1
a: 10, d: 15
2
s1: Hello, s2: World
3
a 是左值: true
4
c 是右值引用: true

1.3 类型判断工具#

C++标准库提供了几个类型特性（type traits）用于判断表达式的值类别：

std::is_lvalue_reference<T>：判断类型T是否为左值引用。
std::is_rvalue_reference<T>：判断类型T是否为右值引用。
std::is_lvalue<T>（C++20起）：判断表达式是否为左值。
std::is_rvalue<T>（C++20起）：判断表达式是否为右值。

示例：

1
#include <iostream>
2
#include <type_traits>
3

4
void func(int& x) {
5
    std::cout << "func(int&)" << std::endl;
6
}
7

8
void func(int&& x) {
9
    std::cout << "func(int&&)" << std::endl;
10
}
11

12
int main() {
13
    int a = 5;
14
    const int& ref = a;
15

16
    // 判断类型
17
    std::cout << std::boolalpha;
18
    // 使用 decltype((a)) 获取 a 的类型，包括引用
19
    // `(a)` 是一个左值表达式，所以 decltype((a)) 是 `int&`
20
    std::cout << "a 是左值: " << std::is_lvalue_reference<decltype((a))>::value << std::endl;
21
    std::cout << "ref 是左值引用: " << std::is_lvalue_reference<decltype(ref)>::value << std::endl;
22

23
    // 调用函数
24
    func(a);          // 调用func(int&)
25
    func(10);         // 调用func(int&&)
26

27
    return 0;
28
}

展开收起

输出：

1
a 是左值: true
2
ref 是左值引用: true
3
func(int&)
4
func(int&&)

1.4 应用场景#

理解左值与右值的区别是实现移动语义、完美转发以及高效内存管理的基础。在编写高性能C++代码时，合理利用右值引用和移动语义可以显著提升程序的效率。

2. 模板万能引用（转发引用）#

2.1 定义与特性#

模板万能引用（也称为转发引用，英文为forwarding references）是C++11引入的一种引用类型，具有以下特点：

表现形式为T&&，其中T是模板参数。
在特定条件下，编译器会将其解析为左值引用或右值引用。
能够统一处理左值和右值，适用于泛型编程中的参数传递。

重要特性：

当模板参数T被推导为普通类型时，T&&是右值引用。
当模板参数T被推导为引用类型时，T&&会根据引用折叠规则解析为左值引用。

2.2 引用折叠规则#

引用折叠是C++中的一项规则，用于处理引用类型的嵌套。主要规则如下：

& &、& &&、&& & 都折叠为 &（左值引用）。
&& && 折叠为 &&（右值引用）。

示例：

1
#include <type_traits>
2
#include <iostream>
3

4
template<typename T>
5
void check_referenc(T&& x){
6
    std::cout << std::boolalpha;
7
    std::cout << "T is lvalue reference: " << std::is_lvalue_reference<T>::value << std::endl;
8
    std::cout << "T is rvalue reference: " << std::is_rvalue_reference<T>::value << std::endl;
9
    std::cout << "T is rvalue : " << std::is_rvalue_reference<T&&> ::value << std::endl;
10
    std::cout << "x is lvalue reference: " << std::is_lvalue_reference<decltype(x)>::value << std::endl;
11
    std::cout << "x is rvalue reference: " << std::is_rvalue_reference<decltype(x)>::value << std::endl;
12
}
13

14
int main() {
15
    int a = 10;
16
    check_reference(a);          // T被推导为 int&， 因此 T&& -> int& && -> int&
17
    check_reference(20);         // T被推导为 int，  T&& -> int&&
18

19
    return 0;
20
}

展开收起

输出：

1
T is lvalue reference: true
2
T is rvalue reference: false
3
T is rvalue : false
4
x is lvalue reference: true
5
x is rvalue reference: false
6
T is lvalue reference: false
7
T is rvalue reference: false
8
T is rvalue : true
9
x is lvalue reference: false
10
x is rvalue reference: true

但是要注意，如果如果我这样调用

1
int &&c = 100;
2
check_referenc(c);

输出的却是

Terminal window

1
T is lvalue reference: true
2
T is rvalue reference: false
3
T is rvalue : false
4
x is lvalue reference: true
5
x is rvalue reference: false

然而，实际中 T 被推导为 int&，这是因为 命名的右值引用变量在表达式中被视为左值。

关键点：#

变量的值类别（Value Category）：
- 左值（lvalue）：有名称，可以出现在赋值的左侧。
- 右值（rvalue）：临时的、没有名称的值，一般不能出现在赋值的左侧。
命名的右值引用变量是左值：
- 虽然 c 的类型是 int&&，但作为一个变量名，它本身是一个左值。
- 这意味着在表达式中使用 c 时，c 被视为左值，而不是右值。
类型推导规则：
- 当模板参数使用T&&（被称为转发引用或万能引用）时，类型推导遵循特定规则：
  - 如果传入的是左值，T 被推导为 T&。
  - 如果传入的是右值，T 被推导为 T（非引用类型）。

传入左值（c）：
- c 是一个命名的右值引用变量，但作为表达式它是左值。
- 因此，T 被推导为 int&。
- T&& 则根据引用折叠规则（int& && => int&）。

为了让 T 被推导为右值引用，我们需要传递一个 真正的右值。这可以通过使用 std::move 来实现：

1
// std::move(c) 是右值，T 被推导为 int
2
check_reference(std::move(c));

输出

Terminal window

1
T is lvalue reference: false
2
T is rvalue reference: false
3
T is rvalue : true
4
x is lvalue reference: false
5
x is rvalue reference: true

**传递右值 **std::move(c)：
- std::move(c) 将 c 转换为 int&&（右值）。
- T 被推导为 int（非引用类型）。
- std::is_lvalue_reference<T>::value 为 false。
- std::is_rvalue_reference<T>::value 为 false。
- std::is_rvalue_reference<T&&>::value 相当于 std::is_rvalue_reference<int&&>::value，为 true。
- decltype(x) 相当于 int&&，所以 x 被识别为右值引用。
为什么T被实例化为int而不是int&&

在模板参数中，当一个类型参数 T 以 T&& 的形式出现，并且 T 是模板参数时，T&& 被称为 转发引用（有时称为万能引用）。转发引用具有特殊的类型推导规则：

如果传递的是左值，T 被推导为 T&。
如果传递的是右值，T 被推导为 T（不带引用）。

模板类型推导的具体规则

根据 C++ 标准（C++17 标准草案）：

如果 P 是 T&&，并且 A（实参类型）是一个非引用类型的表达式，则 T 被推导为 A 的类型。
如果 P 是 T&&，并且 A 是一个引用类型的表达式，则去除引用后的类型用于推导。

具体到我们的例子：

传递 c（一个左值，类型 int&&）：
- 表达式 c 是一个左值。
- 当传递左值给 T&& 时，T 被推导为 int&（即 int 加上引用）。
- 因此，参数类型 T&& 实际上是 int& &&，根据引用折叠规则，int& && 合并为 int&。
传递 std::move(c)（一个右值，类型 int&&）：
- 表达式 std::move(c) 是一个右值。
- 当传递右值给 T&& 时，T 被推导为 int（不带引用）。
- 因此，参数类型 T&& 是 int&&。

也可以采用原样转发，达到和move相同的效果

1
check_referenc(std::forward<int&&>(c));

输出

Terminal window

1
T is lvalue reference: false
2
T is rvalue reference: false
3
T is rvalue : true
4
x is lvalue reference: false
5
x is rvalue reference: true

2.3 示例代码#

以下示例展示了如何使用模板万能引用编写能够接受任意类型参数的函数，并通过转发保持参数的原有值类别。

1
#include <iostream>
2
#include <string>
3
#include <utility>
4

5
// 目标函数，分别有左值和右值的重载
6
void process(int&x){
7
    std::cout << "process(int&)" << std::endl;
8
}
9

10
void process(int&& x){
11
    std::cout << "process(int&&)" << std::endl;
12
}
13

14
// 通用的包装函数，使用转发引用
15
template<typename T>
16
void wrapper(T&& arg) {
17
    process(std::forward<T>(arg)); // 原样转发
18
}
19

20
int main() {
21
    int a = 10;
22
    wrapper(a);          // 传递左值，调用process(int&)
23
    wrapper(20);         // 传递右值，调用process(int&&)
24
    return 0;
25
}

展开收起

输出：

1
process(int&)
2
process(int&&)

在上述代码中，wrapper函数使用模板万能引用T&&接收参数，通过std::forward<T>(arg)实现原样转发，确保传递给process函数的参数保持其原有的值类别。

如果我们把wrapper改为

1
// 通用的包装函数，使用转发引用
2
template<typename T>
3
void wrapper(T&& arg) {
4
    process(arg); // 原样转发
5
}

调用

1
int main() {
2
    int a = 10;
3
    wrapper(a);          // 传递左值，调用process(int&)
4
    wrapper(20);         // 传递右值，调用process(int&&)
5
    return 0;
6
}

则输出

Terminal window

1
process(int&)
2
process(int&)

因为虽然wrapper(20)调用时会将T实例化为int类型, arg变为int && 类型，但是arg本身是一个左值, 所以调用process会选择左值引用版本

1
// 目标函数
2
void process(int&x){
3
    std::cout << "process(int&)" << std::endl;
4
}

3. 类型推导（Type Deduction）#

3.1 类型推导规则#

在C++模板编程中，类型推导是指编译器根据传入的实参自动推导模板参数的类型。类型推导遵循以下基本规则：

模板参数的推导：
- 当模板参数与函数参数进行匹配时，编译器会根据实参类型推导出模板参数类型T。
引用的处理：
- 如果函数参数采用右值引用（如T&&），且传递的是左值，则T会被推导为左值引用类型。
- 如果传递的是右值，则T会被推导为非引用类型。
cv限定符的去除：
- 类型推导会去除顶层的const和volatile修饰。

3.2 与引用的关系#

在模板参数中使用引用类型时，类型推导会涉及引用折叠规则。例如，当一个模板函数参数为T&或T&&时，传入参数的值类别会影响T的推导结果。

示例：

1
#include <iostream>
2
#include <type_traits>
3

4
template<typename T>
5
void deduce_type(T&&) {
6
    std::cout << std::boolalpha;
7
    std::cout << "Is T an lvalue reference? " << std::is_lvalue_reference<T>::value << std::endl;
8
    std::cout << "Is T an rvalue reference? " << std::is_rvalue_reference<T>::value << std::endl;
9
}
10

11
int main() {
12
    int a = 5;
13
    const int& ref = a;
14

15
    deduce_type(a);            // T被推导为 int&
16
    deduce_type(10);           // T被推导为 int
17
    deduce_type(ref);          // T被推导为 const int&
18
    deduce_type(std::move(a)); // T被推导为 int
19

20
    return 0;
21
}

展开收起

输出：

1
Is T an lvalue reference? true
2
Is T an rvalue reference? false
3
Is T an lvalue reference? false
4
Is T an rvalue reference? true
5
Is T an lvalue reference? true
6
Is T an rvalue reference? false
7
Is T an lvalue reference? false
8
Is T an rvalue reference? true

3.3 示例代码#

以下示例展示了不同情况下模板参数T的推导结果，以及如何利用类型推导编写通用函数。

1
#include <iostream>
2
#include <type_traits>
3

4
template<typename T>
5
void display_type(T&& param) {
6
    std::cout << "Type of T: "
7
              << (std::is_lvalue_reference<T>::value ? "lvalue reference" : "rvalue reference")
8
              << ", "
9
              << (std::is_integral<typename std::remove_reference<T>::type>::value ? "Integral" : "Non-Integral")
10
              << std::endl;
11
}
12

13
int main() {
14
    int x = 10;
15
    const int& y = x;
16
    display_type(x);            // T被推导为 int&
17
    display_type(20);           // T被推导为 int&&
18
    display_type(y);            // T被推导为 const int&
19
    display_type(std::move(x)); // T被推导为 int&&
20

21
    return 0;
22
}

展开收起

输出：

1
Type of T: lvalue reference, Integral
2
Type of T: rvalue reference, Integral
3
Type of T: lvalue reference, Integral
4
Type of T: rvalue reference, Integral

在此示例中，通过模板函数display_type，我们可以观察到不同参数传递方式下，模板参数T的推导结果。

4. 原样转发（Perfect Forwarding）#

4.1 定义与作用#

原样转发（Perfect Forwarding）是指在模板函数中，将接收到的参数以其原有的值类别（左值或右值）传递给另一个函数。这项技术确保了泛型代码能够像手写特定代码那样高效和正确地处理参数。

作用：

保持参数的值类别，确保正确调用函数重载。
利用移动语义，避免不必要的拷贝，提升性能。
编写通用、复用性强的代码。

4.2 实现原理#

原样转发通常结合模板万能引用（转发引用）和std::forward来实现。具体流程如下：

使用模板万能引用（T&&）接收参数。
使用

1
std::forward<T>(arg)

将参数转发给目标函数。

1
- `std::forward`根据`T`的类型，将参数转换为左值或右值。
2
- 如果参数原本是左值，`std::forward`返回左值引用。
3
- 如果参数原本是右值，`std::forward`返回右值引用。

4.3 为什么需要原样转发#

在泛型编程中，函数模板可能需要将接收到的参数传递给其他函数。若不使用原样转发，参数会失去原有的值类别信息，可能导致以下问题：

右值参数被当作左值处理，无法利用移动语义，导致性能下降。
无法正确调用目标函数的重载版本。
增加不必要的拷贝开销，影响程序性能。

通过原样转发，可以确保参数在传递过程中保持其原有的左值或右值特性，提升代码的效率和灵活性。

4.4 示例代码#

以下示例展示了如何实现一个通用的wrapper函数，通过原样转发将参数传递给目标函数，同时保留参数的值类别。

1
#include <iostream>
2
#include <string>
3
#include <utility>
4

5
// 目标函数，分别有左值和右值的重载
6
void process(const std::string& s) {
7
    std::cout << "Processing lvalue: " << s << std::endl;
8
}
9

10
void process(std::string&& s) {
11
    std::cout << "Processing rvalue: " << s << std::endl;
12
}
13

14
// 通用的包装函数，实现原样转发
15
template<typename T>
16
void wrapper(T&& arg) {
17
    process(std::forward<T>(arg));
18
}
19

20
int main() {
21
    std::string name = "Alice";
22
    wrapper(name);                     // 传递左值，调用process(const std::string&)
23
    wrapper("Bob");                    // 传递右值，调用process(std::string&&)
24
    wrapper(std::move(name));          // 传递右值，调用process(std::string&&)
25

26
    return 0;
27
}

展开收起

输出：

1
Processing lvalue: Alice
2
Processing rvalue: Bob
3
Processing rvalue: Alice

在上述代码中：

wrapper(name)传递的是左值，T被推导为std::string&，std::forward保持其为左值引用，调用process(const std::string&)。
wrapper("Bob")传递的是右值，T被推导为const char*，在process函数重载的选择上，这里简单化处理为调用接收右值的版本（视具体实现而定）。
wrapper(std::move(name))传递的是右值，T被推导为std::string，std::forward将其转换为右值引用，调用process(std::string&&)。

4.5 泛型工厂函数示例#

以下示例展示了如何使用原样转发实现一个泛型工厂函数，完美转发构造函数的参数，以高效创建对象。

1
#include <iostream>
2
#include <string>
3
#include <utility>
4

5
// 类的定义
6
class Person {
7
public:
8
    std::string name;
9
    int age;
10

11
    // 左值引用构造函数
12
    Person(const std::string& n, int a) : name(n), age(a) {
13
        std::cout << "Constructed Person(const std::string&, int)" << std::endl;
14
    }
15

16
    // 右值引用构造函数
17
    Person(std::string&& n, int a) : name(std::move(n)), age(a) {
18
        std::cout << "Constructed Person(std::string&&, int)" << std::endl;
19
    }
20
};
21

22
// 工厂函数，使用原样转发构造函数参数
23
template<typename T, typename... Args>
24
T create(Args&&... args) {
25
    return T(std::forward<Args>(args)...);
26
}
27

28
int main() {
29
    std::string name = "Alice";
30

31
    // 传递左值
32
    Person p1 = create<Person>(name, 30);
33
    // 传递右值
34
    Person p2 = create<Person>(std::string("Bob"), 25);
35

36
    return 0;
37
}

展开收起

输出：

1
Constructed Person(const std::string&, int)
2
Constructed Person(std::string&&, int)

在此示例中：

create<Person>(name, 30)传递的是左值，调用Person(const std::string&, int)构造函数。
create<Person>(std::string("Bob"), 25)传递的是右值，调用Person(std::string&&, int)构造函数。

通过原样转发，create函数能够根据传入参数的值类别，调用相应的构造函数，实现高效的对象创建。

4.6 避免不必要的拷贝#

以下示例展示了如果不使用原样转发，可能导致的多次拷贝问题。

1
#include <iostream>
2
#include <string>
3

4
// 类的定义
5
class BigObject {
6
public:
7
    std::string data;
8

9
    BigObject(const std::string& d) : data(d) {
10
        std::cout << "BigObject constructed with lvalue" << std::endl;
11
    }
12

13
    BigObject(std::string&& d) : data(std::move(d)) {
14
        std::cout << "BigObject constructed with rvalue" << std::endl;
15
    }
16
};
17

18
// 处理函数，左值和右值的重载
19
void process(const BigObject& obj) {
20
    std::cout << "Processing lvalue BigObject" << std::endl;
21
}
22

23
void process(BigObject&& obj) {
24
    std::cout << "Processing rvalue BigObject" << std::endl;
25
}
26

27
// 包装函数，不使用原样转发
28
template<typename T>
29
void bad_wrapper(T&& obj) {
30
    process(obj); // 始终以左值形式传递
31
}
32

33
// 包装函数，使用原样转发
34
template<typename T>
35
void good_wrapper(T&& obj) {
36
    process(std::forward<T>(obj)); // 原样转发
37
}
38

39
int main() {
40
    std::string s = "Sample data";
41

42
    // 使用bad_wrapper
43
    BigObject bo1 = BigObject(s);              // 使用lvalue构造
44
    BigObject bo2 = BigObject(std::move(s));   // 使用rvalue构造
45

46
    bad_wrapper(bo1); // 始终作为左值处理
47
    bad_wrapper(BigObject("Temp")); // 作为左值处理，浪费移动语义
48

49
    // 使用good_wrapper
50
    good_wrapper(bo1); // 作为左值处理
51
    good_wrapper(BigObject("Temp")); // 作为右值处理，利用移动语义
52

53
    return 0;
54
}

展开收起

输出：

1
BigObject constructed with lvalue
2
BigObject constructed with rvalue
3
Processing lvalue BigObject
4
Processing lvalue BigObject
5
BigObject constructed with rvalue
6
Processing rvalue BigObject

在此示例中：

bad_wrapper函数不使用std::forward，导致即使传递的是右值，process函数也以左值形式接收，无法利用移动语义。
good_wrapper函数使用std::forward，正确保持参数的值类别，允许process函数调用右值重载，从而利用移动语义，提高性能。

5. forward源码剖析#

std::forward之所以能进行原样转发，我们来看一下源码，std::forward实现了两个版本

返回左值引用版本

1
template<typename _Tp>
2
    _GLIBCXX_NODISCARD
3
    constexpr _Tp&&
4
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
5
    { return static_cast<_Tp&&>(__t); }

重点解释#

1. **_GLIBCXX_NODISCARD**

**_GLIBCXX_NODISCARD** 是一个宏，通常定义在 libstdc++（GNU的C++标准库实现）中，用于指示编译器不要忽略函数的返回值。具体来说，它通常被定义为 C++17 引入的 [[nodiscard]] 属性，或者对应的编译器特定属性。

**[[nodiscard]]** 属性：这是C++17引入的一个属性，用于标记函数的返回值不应该被忽略。如果调用该函数的返回值被忽略，编译器会发出警告。例如：

1
[[nodiscard]] int compute() { return 42; }
2

3
void example() {
4
    compute(); // 编译器会发出警告，因为返回值被忽略
5
}

在**_GLIBCXX_NODISCARD**中的作用：通过使用这个宏，forward函数的设计者告诉编译器和使用者：调用 forward 时，返回值不应该被忽略，因为它在转发参数时起到了关键作用。如果返回值被忽略，可能会导致意想不到的行为或性能问题。

总结：_GLIBCXX_NODISCARD 确保使用 forward 时，返回的转发结果不会被无意中忽略，增强代码的安全性和正确性。

2. **constexpr**

**constexpr** 是C++11引入的一个关键字，用于指示一个函数或变量可以在编译时求值。

在函数中的作用：
- 编译时计算：constexpr 函数可以在编译时被求值，如果传入的参数也都是编译时常量。
- 优化性能：通过在编译时进行计算，可以减少运行时的开销，提高程序的性能。
在 **forward** 函数中的作用：
- 高效实现：forward 是一个轻量级的操作，通常涉及简单的静态类型转换（如 static_cast）。将其定义为 constexpr 允许编译器在可能的情况下在编译时完成这些转换，从而避免不必要的运行时开销。
- 支持常量表达式：如果在编译时上下文中使用 forward，例如在 constexpr 函数中，它能够在编译时正确地转发参数。

总结：constexpr 使得 forward 函数能够在编译时进行优化，同时确保在运行时不引入额外的开销。

3. **remove_reference**作用

源码分析

1
template<typename _Tp>
2
    struct remove_reference
3
    { using type = _Tp; };
4

5
  template<typename _Tp>
6
    struct remove_reference<_Tp&>
7
    { using type = _Tp; };
8

9
  template<typename _Tp>
10
    struct remove_reference<_Tp&&>
11
    { using type = _Tp; };

根据模板就近匹配规则，会按照最相似的方式进行匹配，优先匹配特例化版本，比如

remove_reference<int> 会调用第一个版本

remove_reference<int&>会调用第二个版本(特例化)

remove_reference<int&&>会调用第三个版本

所以我们对比这三个版本

1
remove_reference<int>::type;
2
remove_reference<int&>::type;
3
remove_reference<int&&>::type;

这三个版本的type都为int，这样达到了去引用的效果。

所以带入

typename std::remove_reference<_Tp>::type& __t

我们可以指导__t一定是个左值引用类型。

原样转发内幕

此时我们考虑对一个左值引用类型(int& )参数执行forward函数

1
template<typename _Tp>
2
    _GLIBCXX_NODISCARD
3
    constexpr _Tp&&
4
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
5
    { return static_cast<_Tp&&>(__t); }

函数各部分解释：

模板参数 **typename _Tp**：定义了一个模板类型参数 _Tp，表示要转发的类型。
**typename std::remove_reference<_Tp>::type& __t**：使用 std::remove_reference 去除 _Tp 的引用性质，然后以左值引用的形式接受参数。
**static_cast<_Tp&&>(__t)**：通过 static_cast 将参数转换为 _Tp 类型的右值引用。这是实现完美转发的关键步骤，使得被转发的参数保留其原有的值类别。
**noexcept**：指明函数不会抛出异常，有助于编译器进行优化，并提高代码的异常安全性。

__t为int&类型，TP被实例化为int&, 通过引用折叠

int& std::forward<int&>(arg)

达到了原样转发的目的。

模板参数 **typename _Tp**：定义了一个模板类型参数 _Tp，表示要转发的类型。

同样我们分析右值引用类型原样转发原理

返回右值引用版本

1
template<typename _Tp>
2
    _GLIBCXX_NODISCARD
3
    constexpr _Tp&&
4
    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
5
    {
6
      static_assert(!std::is_lvalue_reference<_Tp>::value,
7
      "std::forward must not be used to convert an rvalue to an lvalue");
8
      return static_cast<_Tp&&>(__t);
9
    }

这里限制了不能将右值引用转化为左值引用。

__t是右值引用类型，当我们执行如下

int&& forward<int&&>(args)

_Tp被实例化为int&&, 返回类型通过折叠变为int&& , 参数__t变为int&&类型

6. move源码解析#

std::move源码

1
template<typename _Tp>
2
    _GLIBCXX_NODISCARD
3
    constexpr typename std::remove_reference<_Tp>::type&&
4
    move(_Tp&& __t) noexcept
5
    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }

可以看到move的实现很简单，无论__t是左值引用还是右值引用，都会通过

static_cast<typename std::remove_reference<_Tp>::type&&>(__t)

强制转换为去除引用的type, 再加上&&的类型，也就是具体的右值引用类型。

7. 总结#

左值与右值：理解值类别是掌握C++移动语义、资源管理和高效编程的基础。左值代表具有持久存储的对象，而右值通常是临时对象。
模板万能引用（转发引用）：通过T&&形式的模板参数，可以统一处理左值和右值，适用于泛型编程中的参数传递。引用折叠规则决定了T&&在不同上下文中的解析方式。
类型推导：编译器根据实参自动推导模板参数类型，涉及引用类型时需要理解引用折叠规则和类型推导的细节。
原样转发（Perfect Forwarding）：结合模板万能引用和std::forward，确保在泛型函数中将参数以其原有值类别传递给目标函数，避免不必要的拷贝，提升代码效率和灵活性。

模板详解

Fri, 29 May 2026 00:00:00 GMT

模板基础#

C++ 模板（Templates）是现代 C++ 中强大而灵活的特性，支持泛型编程，使得代码更具复用性和类型安全性。模板不仅包括基本的函数模板和类模板，还涵盖了模板特化（全特化与偏特化）、模板参数种类、变参模板（Variadic Templates）、模板元编程（Template Metaprogramming）、SFINAE（Substitution Failure Is Not An Error）等高级内容。

函数模板#

函数模板允许编写通用的函数，通过类型参数化，使其能够处理不同的数据类型。它通过模板参数定义与类型无关的函数。

语法：

1
template <typename T>
2
T functionName(T param) {
3
    // 函数体
4
}

示例：最大值函数

1
#include <iostream>
2

3
template <typename T>
4
T maxValue(T a, T b) {
5
    return (a > b) ? a : b;
6
}
7

8
int main() {
9
    std::cout << maxValue(3, 7) << std::endl;         // int 类型
10
    std::cout << maxValue(3.14, 2.72) << std::endl;  // double 类型
11
    std::cout << maxValue('a', 'z') << std::endl;    // char 类型
12
    return 0;
13
}

输出：

Terminal window

要点：

模板参数列表以 template <typename T> 或 template <class T> 开头，两者等价。
类型推导：编译器根据函数参数自动推导模板参数类型。

类模板#

类模板允许定义通用的类，通过类型参数化，实现不同类型的对象。

语法：

1
template <typename T>
2
class ClassName {
3
public:
4
T memberVariable;
5
// 构造函数、成员函数等
6
};

示例：简单的 Pair 类

1
#include <iostream>
2
#include <string>
3

4
template <typename T, typename U>
5
class Pair {
6
public:
7
T first;
8
U second;
9

10
Pair(T a, U b) : first(a), second(b) {}
11

12
void print() const {
13
    std::cout << "Pair: " << first << ", " << second << std::endl;
14
}
15
};
16

17
int main() {
18
    Pair<int, double> p1(1, 2.5);
19
    p1.print(); // 输出：Pair: 1, 2.5
20

21
    Pair<std::string, std::string> p2("Hello", "World");
22
    p2.print(); // 输出：Pair: Hello, World
23

24
    Pair<std::string, int> p3("Age", 30);
25
    p3.print(); // 输出：Pair: Age, 30
26

27
    return 0;
28
}

展开收起

输出：

Terminal window

1
Pair: 1, 2.5
2
Pair: Hello, World
3
Pair: Age, 30

要点：

类模板可以有多个类型参数。
模板参数可以被用于成员变量和成员函数中。
类模板实例化时指定具体类型，如 Pair<int, double>。

模板参数#

模板参数决定了模板的泛用性与灵活性。C++ 模板参数种类主要包括类型参数、非类型参数和模板模板参数。

类型参数（Type Parameters）#

类型参数用于表示任意类型，在模板实例化时被具体的类型替代。

示例：

1
template <typename T>
2
class MyClass {
3
public:
4
T data;
5
};

非类型参数（Non-Type Parameters）#

非类型参数允许模板接受非类型的值，如整数、指针或引用。C++17 支持更多非类型参数类型，如 auto。

语法：

1
template <typename T, int N>
2
class FixedArray {
3
public:
4
T data[N];
5
};

示例：固定大小的数组类

1
#include <iostream>
2

3
template <typename T, std::size_t N>
4
class FixedArray {
5
public:
6
T data[N];
7

8
T& operator[](std::size_t index) {
9
    return data[index];
10
}
11

12
void print() const {
13
    for(std::size_t i = 0; i < N; ++i)
14
        std::cout << data[i] << " ";
15
    std::cout << std::endl;
16
}
17
};
18

19
int main() {
20
    FixedArray<int, 5> arr;
21
    for(int i = 0; i < 5; ++i)
22
        arr[i] = i * 10;
23
    arr.print(); // 输出：0 10 20 30 40
24
    return 0;
25
}

展开收起

输出：

0 10 20 30 40

注意事项：

非类型参数必须是编译期常量。
允许的类型包括整型、枚举、指针、引用等，但不包括浮点数和类类型。

模板模板参数（Template Template Parameters）#

模板模板参数允许模板接受另一个模板作为参数。这对于抽象容器和策略模式等场景非常有用。

语法：

1
template <template <typename, typename> class Container>
2
class MyClass { /* ... */ };

示例：容器适配器

1
#include <iostream>
2
#include <vector>
3
#include <list>
4

5
template <template <typename, typename> class Container, typename T>
6
class ContainerPrinter {
7
public:
8
void print(const Container<T, std::allocator<T>>& container) {
9
    for(const auto& elem : container)
10
        std::cout << elem << " ";
11
    std::cout << std::endl;
12
}
13
};
14

15
int main() {
16
    std::vector<int> vec = {1, 2, 3, 4, 5};
17
    std::list<int> lst = {10, 20, 30};
18

19
    ContainerPrinter<std::vector, int> vecPrinter;
20
    vecPrinter.print(vec); // 输出：1 2 3 4 5
21

22
    ContainerPrinter<std::list, int> listPrinter;
23
    listPrinter.print(lst); // 输出：10 20 30
24

25
    return 0;
26
}

展开收起

输出：

要点：

模板模板参数需要完全匹配被接受模板的参数列表。
可通过默认模板参数增强灵活性。

模板特化（Template Specialization）#

模板特化允许开发者为特定类型或类型组合提供专门的实现。当通用模板无法满足特定需求时，特化模板可以调整行为以处理特定的情况。C++ 支持全特化（Full Specialization）*_和__*_偏特化（Partial Specialization），但需要注意的是，函数模板不支持偏特化**，只能进行全特化。

全特化（Full Specialization）#

全特化是针对模板参数的完全特定类型组合。它提供了模板的一个特定版本，当模板参数完全匹配特化类型时，编译器将优先使用该特化版本。

语法#

1
// 通用模板
2
template <typename T>
3
class MyClass {
4
// 通用实现
5
};
6

7
// 全特化
8
template <>
9
class MyClass<SpecificType> {
10
// 针对 SpecificType 的实现
11
};

示例：类模板全特化#

1
#include <iostream>
2
#include <string>
3

4
// 通用类模板
5
template <typename T>
6
class Printer {
7
public:
8
void print(const T& value) {
9
    std::cout << "General Printer: " << value << std::endl;
10
}
11
};
12

13
// 类模板全特化
14
template <>
15
class Printer<std::string> {
16
public:
17
void print(const std::string& value) {
18
    std::cout << "String Printer: " << value << std::endl;
19
}
20
};
21

22
int main() {
23
    Printer<int> intPrinter;
24
    intPrinter.print(100); // 输出：General Printer: 100
25

26
    Printer<std::string> stringPrinter;
27
    stringPrinter.print("Hello, World!"); // 输出：String Printer: Hello, World!
28

29
    return 0;
30
}

展开收起

输出：

1
General Printer: 100
2
String Printer: Hello, World!

解析#

通用模板适用于所有类型，在print函数中以通用方式输出值。
全特化模板针对std::string类型进行了专门化，实现了不同的print函数。
当实例化Printer<std::string>时，编译器选择全特化版本而非通用模板。

偏特化（Partial Specialization）#

偏特化允许模板对部分参数进行特定类型的处理，同时保持其他参数的通用性。对于类模板而言，可以针对模板参数的某些特性进行偏特化；对于函数模板，则仅支持全特化，不支持偏特化。

语法#

1
// 通用模板
2
template <typename T, typename U>
3
class MyClass {
4
// 通用实现
5
};
6

7
// 偏特化：当 U 是指针类型时
8
template <typename T, typename U>
9
class MyClass<T, U*> {
10
// 针对 U* 的实现
11
};

示例：类模板偏特化#

1
#include <iostream>
2
#include <string>
3

4
// 通用 Pair 类模板
5
template <typename T, typename U>
6
class Pair {
7
public:
8
T first;
9
U second;
10

11
Pair(T a, U b) : first(a), second(b) {}
12

13
void print() const {
14
    std::cout << "Pair: " << first << ", " << second << std::endl;
15
}
16
};
17

18
// 类模板偏特化：当第二个类型是指针时
19
template <typename T, typename U>
20
class Pair<T, U*> {
21
public:
22
T first;
23
U* second;
24

25
Pair(T a, U* b) : first(a), second(b) {}
26

27
void print() const {
28
    std::cout << "Pair with pointer: " << first << ", " << *second << std::endl;
29
}
30
};
31

32
int main() {
33
    Pair<int, double> p1(1, 2.5);
34
    p1.print(); // 输出：Pair: 1, 2.5
35

36
    double value = 3.14;
37
    Pair<std::string, double*> p2("Pi", &value);
38
    p2.print(); // 输出：Pair with pointer: Pi, 3.14
39

40
    return 0;
41
}

展开收起

输出：

1
Pair: 1, 2.5
2
Pair with pointer: Pi, 3.14

解析#

通用模板处理非指针类型对。
偏特化模板处理第二个类型为指针的情况，打印指针指向的值。
使用偏特化提升了模板的灵活性，使其能够根据部分参数类型进行不同处理。

函数模板的特化#

与类模板不同，函数模板不支持偏特化，只能进行全特化。当对函数模板进行全特化时，需要显式指定类型。

示例：函数模板全特化#

1
#include <iostream>
2
#include <string>
3

4
// 通用函数模板
5
template <typename T>
6
void printValue(const T& value) {
7
    std::cout << "General print: " << value << std::endl;
8
}
9

10
// 函数模板全特化
11
template <>
12
void printValue<std::string>(const std::string& value) {
13
    std::cout << "Specialized print for std::string: " << value << std::endl;
14
}
15

16
int main() {
17
    printValue(42); // 调用通用模板，输出：General print: 42
18
    printValue(3.14); // 调用通用模板，输出：General print: 3.14
19
    printValue(std::string("Hello")); // 调用全特化模板，输出：Specialized print for std::string: Hello
20
    return 0;
21
}

展开收起

输出：

1
General print: 42
2
General print: 3.14
3
Specialized print for std::string: Hello

解析#

通用函数模板适用于所有类型，提供通用的printValue实现。
全特化函数模板专门处理std::string类型，提供不同的输出格式。
调用printValue时，编译器根据实参类型选择适当的模板版本。

注意事项#

优先级：全特化版本的优先级高于通用模板，因此当特化条件满足时，总是选择特化版本。
显式指定类型：函数模板特化需要在调用时显式指定类型，或者确保类型推导可以正确匹配特化版本。
不支持偏特化：无法通过偏特化对函数模板进行部分特化，需要通过其他方法（如重载）实现类似功能。

总结#

全特化适用于为具体类型或类型组合提供专门实现，适用于类模板和函数模板。
偏特化仅适用于类模板，允许针对部分参数进行特定处理，同时保持其他参数的通用性。
函数模板仅支持全特化，不支持偏特化；类模板支持全特化和偏特化。
特化模板提升了模板的灵活性和适应性，使其能够根据不同类型需求调整行为。

变参模板（Variadic Templates）#

变参模板允许模板接受可变数量的参数，提供极高的灵活性，是实现诸如 std::tuple、std::variant 等模板库组件的基础。

定义与语法#

变参模板使用 参数包（Parameter Pack），通过 ... 语法来表示。

语法：

1
template <typename... Args>
2
class MyClass { /* ... */ };
3

4
template <typename T, typename... Args>
5
void myFunction(T first, Args... args) { /* ... */ }

递归与展开（Recursion and Expansion）#

变参模板通常与递归相结合，通过递归地处理参数包，或者使用 折叠表达式（Fold Expressions） 来展开发参数包。

递归示例：打印所有参数

1
#include <iostream>
2

3
// 基础情况：无参数
4
void printAll() {
5
    std::cout << std::endl;
6
}
7

8
// 递归情况：至少一个参数
9
template <typename T, typename... Args>
10
void printAll(const T& first, const Args&... args) {
11
    std::cout << first << " ";
12
    printAll(args...); // 递归调用
13
}
14

15
int main() {
16
    printAll(1, 2.5, "Hello", 'A'); // 输出：1 2.5 Hello A
17
    return 0;
18
}

展开收起

输出：

1 2.5 Hello A

折叠表达式版本

1
#include <iostream>
2

3
// 使用折叠表达式的printAll
4
template <typename... Args>
5
void printAll(const Args&... args) {
6
    // 使用左折叠展开参数包，并在每个参数之后输出一个空格
7
    ((std::cout << args << " "), ...);
8
    std::cout << std::endl;
9
}
10

11
int main() {
12
    printAll(1, 2.5, "Hello", 'A'); // 输出：1 2.5 Hello A
13
    return 0;
14
}

折叠表达式示例：计算总和

C++17 引入了折叠表达式，简化了参数包的处理。

1
#include <iostream>
2

3
template <typename... Args>
4
auto sum(Args... args) -> decltype((args + ...)) {
5
    return (args + ...); // 左折叠
6
}
7

8
int main() {
9
    std::cout << sum(1, 2, 3, 4) << std::endl; // 输出：10
10
    std::cout << sum(1.5, 2.5, 3.0) << std::endl; // 输出：7
11
    return 0;
12
}

输出：

应用示例#

示例：日志记录器

1
#include <iostream>
2
#include <string>
3

4
// 基础情况：无参数
5
void log(const std::string& msg) {
6
    std::cout << msg << std::endl;
7
}
8

9
// 递归情况：至少一个参数
10
template <typename T, typename... Args>
11
void log(const std::string& msg, const T& first, const Args&... args) {
12
    std::cout << msg << ": " << first << " ";
13
    log("", args...); // 递归调用，省略消息前缀
14
}
15

16
int main() {
17
    log("Error", 404, "Not Found");
18
    // 输出：Error: 404 Not Found
19

20
    log("Sum", 10, 20, 30);
21
    // 输出：Sum: 10 20 30
22
    return 0;
23
}

展开收起

输出：

1
Error: 404 Not Found
2
Sum: 10 20 30

要点：

变参模板极大地提升了模板的灵活性。
使用递归或折叠表达式处理参数包。
常用于实现通用函数、容器类和元编程工具。

模板折叠（Fold Expressions）#

1. 折叠表达式的概念与背景#

在C++中，可变参数模板允许函数或类模板接受任意数量的模板参数。这在编写灵活且通用的代码时非常有用。然而，处理参数包中的每个参数往往需要递归模板技巧，这样的代码通常复杂且难以维护。

折叠表达式的引入显著简化了这一过程。它们允许开发者直接对参数包应用操作符，而无需手动展开或递归处理参数。这不仅使代码更加简洁，还提高了可读性和可维护性。

折叠表达式可分为：

一元折叠表达式（Unary Fold）：对参数包中的每个参数应用一个一元操作符。
二元折叠表达式（Binary Fold）：对参数包中的每个参数应用一个二元操作符。

此外，二元折叠表达式可进一步细分为左折叠（Left Fold）*_和__*_右折叠（Right Fold）**，取决于操作符的结合方向。

2. 一元折叠表达式（Unary Fold）#

一元折叠表达式用于在参数包的每个参数前或后应用一元操作符。语法形式如下：

前置一元折叠（Unary Prefix Fold）

(op … pack)

后置一元折叠（Unary Postfix Fold）

(pack … op)

其中，op 是一元操作符，如!（逻辑非）、~（按位取反）等。

示例1：逻辑非操作

1
#include <iostream>
2

3
//对每个参数非操作，然后再将这些操作&&
4
//(!args && ...) 相当于 !a && !b && ...
5
template<typename... Args>
6
bool allNot(const Args&... args){
7
    return (!args && ...);
8
}

3. 二元折叠表达式（Binary Fold）#

二元折叠表达式用于在参数包的每个参数之间应用一个二元操作符。它们可以分为二元左折叠（Binary Left Fold）*_和__*_二元右折叠（Binary Right Fold）**，取决于操作符的结合方向。

二元折叠表达式语法

二元左折叠（Left Fold）：

(init op … op pack)

或者简化为：

(pack1 op … op packN)

二元右折叠（Right Fold）：

(pack1 op … op init op …)

或者简化为：

(pack1 op … op packN)

其中，op 是二元操作符，如+、*、&&、||、<< 等。

左折叠与右折叠的区别

二元左折叠（Binary Left Fold）：操作符从左至右结合，等价于 (((a op b) op c) op d)。
二元右折叠（Binary Right Fold）：操作符从右至左结合，等价于 (a op (b op (c op d)))。

示例1：求和（Binary Left Fold）

1
#include <iostream>
2

3
// 二元左折叠：((arg1 + arg2) + arg3) + ... + argN
4
template<typename... Args>
5
auto sumLeftFold(const Args&... args) {
6
    return (args + ...); // 左折叠
7
}
8

9
int main() {
10
    std::cout << sumLeftFold(1, 2, 3, 4) << std::endl; // 输出：10
11
    return 0;
12
}

解释：

**(args + ...)** 是一个二元左折叠表达式。
它将+操作符逐个应用于参数，按照左折叠顺序。
即，((1 + 2) + 3) + 4 = 10。

示例2：乘积（Binary Right Fold）

1
#include <iostream>
2

3
// 二元右折叠：arg1 * (arg2 * (arg3 * ... * argN))
4
template<typename... Args>
5
auto productRightFold(const Args&... args) {
6
    return (... * args); // 右折叠
7
}
8

9
int main() {
10
    std::cout << productRightFold(2, 3, 4) << std::endl; // 输出：24
11
    return 0;
12
}

解释：

**(... \* args)** 是一个二元右折叠表达式。
它将*操作符逐个应用于参数，按照右折叠顺序。
即，2 * (3 * 4) = 2 * 12 = 24。

示例3：逻辑与（Binary Left Fold）

1
#include <iostream>
2

3
template<typename... Args>
4
bool allTrue(const Args&... args) {
5
    return (args && ...); // 左折叠
6
}
7

8
int main() {
9
    std::cout << std::boolalpha;
10
    std::cout << allTrue(true, true, false) << std::endl; // 输出：false
11
    std::cout << allTrue(true, true, true) << std::endl;  // 输出：true
12
    return 0;
13
}

解释：

**(args && ...)** 是一个二元左折叠表达式。
用于检查所有参数是否为true。
类似于链式的逻辑与运算。

4. 左折叠与右折叠（Left and Right Folds）#

了解左折叠和右折叠的区别，对于正确选择折叠表达式的形式至关重要。

二元左折叠（Binary Left Fold）

语法：

(args op …)

展开方式：

((arg1 op arg2) op arg3) op … op argN
适用场景：
- 当操作符是结合性的且从左侧开始累积操作时（如+、*）。
- 需要严格的顺序执行时，确保从左到右依次处理参数。

示例：

(args + …) // 左折叠求和

二元右折叠（Binary Right Fold）

语法：

(… op args)

展开方式：

arg1 op (arg2 op (arg3 op … op argN))
适用场景：
- 当操作符是右结合的，或当需要从右侧开始累积操作时。
- 某些特定的逻辑和数据结构可能需要右侧先处理。

示例：

(… + args) // 右折叠求和

嵌套折叠表达式

在某些复杂场景下，可能需要嵌套使用左折叠和右折叠，以达到特定的操作顺序。例如，结合多个不同的操作符。

1
#include <iostream>
2

3
template<typename... Args>
4
auto complexFold(const Args&... args) {
5
    // 先左折叠求和，然后右折叠求乘积
6
    return (args + ...) * (... + args);
7
}
8

9
int main() {
10
    std::cout << complexFold(1, 2, 3) << std::endl; // (1+2+3) * (1+2+3) = 6 * 6 = 36
11
    return 0;
12
}

解释：

在此示例中，我们首先对参数进行左折叠求和，然后对参数进行右折叠求和，最后将两者相乘。
这种嵌套用途展示了折叠表达式的灵活性。

5. `op` 在折叠表达式中的作用#

在折叠表达式中，op 代表二元操作符，用于定义如何将参数包中的各个参数相互结合。op 可以是任何合法的二元操作符，包括但不限于：

算术操作符：+、-、*、/、% 等。
逻辑操作符：&&、|| 等。
按位操作符：&、|、^、<<、>> 等。
比较操作符：==、!=、<、>、<=、>= 等。
自定义操作符：如果定义了自定义类型并重载了特定的操作符，也可以使用这些操作符。

**op** 的选择直接影响折叠表达式的行为和结果。选择适当的操作符是实现特定功能的关键。

示例1：使用加法操作符

1
#include <iostream>
2

3
template<typename... Args>
4
auto addAll(const Args&... args) {
5
    return (args + ...); // 使用 '+' 进行左折叠
6
}
7

8
int main() {
9
    std::cout << addAll(1, 2, 3, 4) << std::endl; // 输出：10
10
    return 0;
11
}

示例2：使用逻辑与操作符

1
#include <iostream>
2

3
template<typename... Args>
4
bool allTrue(const Args&... args) {
5
    return (args && ...); // 使用 '&&' 进行左折叠
6
}
7

8
int main() {
9
    std::cout << std::boolalpha;
10
    std::cout << allTrue(true, true, false) << std::endl; // 输出：false
11
    std::cout << allTrue(true, true, true) << std::endl;  // 输出：true
12
    return 0;
13
}

示例3：使用左移操作符（流插入）

1
#include <iostream>
2

3
template<typename... Args>
4
void printAll(const Args&... args) {
5
    (std::cout << ... << args) << std::endl; // 使用 '<<' 进行左折叠
6
}
7

8
int main() {
9
    printAll("Hello, ", "world", "!", 123); // 输出：Hello, world!123
10
    return 0;
11
}

解释：

在上述示例中，op 分别为 +、&&、<<。
每个操作符定义了如何将参数包中的元素相互结合。

示例4：使用自定义操作符

假设有一个自定义类型Point，并重载了+操作符以支持点的相加。

1
#include <iostream>
2

3
struct Point {
4
int x, y;
5

6
// 重载 '+' 操作符
7
Point operator+(const Point& other) const {
8
    return Point{ x + other.x, y + other.y };
9
}
10
};
11

12
// 二元左折叠：((p1 + p2) + p3) + ... + pN
13
template<typename... Args>
14
Point sumPoints(const Args&... args) {
15
    return (args + ...); // 使用 '+' 进行左折叠
16
}
17

18
int main() {
19
    Point p1{1, 2}, p2{3, 4}, p3{5, 6};
20
    Point result = sumPoints(p1, p2, p3);
21
    std::cout << "Sum of Points: (" << result.x << ", " << result.y << ")\n"; // 输出：(9, 12)
22
    return 0;
23
}

展开收起

解释：

通过重载+操作符，sumPoints函数能够将多个Point对象相加，得到累积的结果。

6. 示例代码与应用#

为了全面理解折叠表达式的应用，以下提供多个具体示例，涵盖不同类型的折叠表达式。

示例1：字符串拼接

1
#include <iostream>
2
#include <string>
3

4
template<typename... Args>
5
std::string concatenate(const Args&... args) {
6
    return (std::string{} + ... + args); // 左折叠
7
}
8

9
int main() {
10
    std::string result = concatenate("Hello, ", "world", "!", " Have a nice day.");
11
    std::cout << result << std::endl; // 输出：Hello, world! Have a nice day.
12
    return 0;
13
}

示例2：计算逻辑与

1
#include <iostream>
2

3
template<typename... Args>
4
bool areAllTrue(const Args&... args) {
5
    return (args && ...); // 左折叠
6
}
7

8
int main() {
9
    std::cout << std::boolalpha;
10
    std::cout << areAllTrue(true, true, true) << std::endl;   // 输出：true
11
    std::cout << areAllTrue(true, false, true) << std::endl;  // 输出：false
12
    return 0;
13
}

示例3：计算最大值

1
#include <iostream>
2
#include <algorithm>
3

4
template<typename T, typename... Args>
5
T maxAll(T first, Args... args) {
6
    return (std::max)(first, ... , args); // 左折叠
7
}
8

9
int main() {
10
    std::cout << maxAll(1, 5, 3, 9, 2) << std::endl; // 输出：9
11
    return 0;
12
}

注意：上述示例中的(std::max)(first, ... , args)是一个非标准用法，需要根据具体情况调整。通常，std::max不支持直接的折叠表达式，因此此例更适合作为概念性说明。在实际应用中，可以使用std::initializer_list或其他方法实现多参数的最大值计算。

示例4：筛选逻辑

假设需要检查多个条件是否满足，且每个条件之间使用逻辑或操作：

1
#include <iostream>
2

3
template<typename... Args>
4
bool anyTrue(const Args&... args) {
5
    return (args || ...); // 左折叠
6
}
7

8
int main() {
9
    std::cout << std::boolalpha;
10
    std::cout << anyTrue(false, false, true) << std::endl; // 输出：true
11
    std::cout << anyTrue(false, false, false) << std::endl; // 输出：false
12
    return 0;
13
}

7. 注意事项与最佳实践#

1. 操作符的选择

选择合适的操作符（op）对于实现正确的折叠行为至关重要。确保所选的操作符符合所需的逻辑和计算需求。

2. 操作符的结合性

不同的操作符具有不同的结合性（左结合、右结合）。了解操作符的结合性有助于选择正确的折叠方向（左折叠或右折叠）。

3. 参数包的初始化

在二元折叠表达式中，有时需要一个初始值（init）。这主要用于确保折叠的正确性，尤其在参数包可能为空的情况下。

示例：

1
#include <iostream>
2
#include <numeric>
3

4
template<typename... Args>
5
auto sumWithInit(int init, Args... args) {
6
    return (init + ... + args); // 左折叠
7
}
8

9
int main() {
10
    std::cout << sumWithInit(10, 1, 2, 3) << std::endl; // 输出：16 (10 + 1 + 2 + 3)
11
    return 0;
12
}

4. 参数包为空的情况

如果参数包为空，折叠表达式的结果取决于折叠的类型和初始值。合理设置初始值可以避免潜在的错误。

示例：

1
#include <iostream>
2

3
// 求和函数，如果参数包为空返回0
4
template<typename... Args>
5
auto sum(Args... args) {
6
    return (0 + ... + args); // 左折叠，初始值为0
7
}
8

9
int main() {
10
    std::cout << sum(1, 2, 3) << std::endl; // 输出：6
11
    std::cout << sum() << std::endl;        // 输出：0
12
    return 0;
13
}

5. 与递归模板的比较

折叠表达式在处理可变参数模板时，比传统的递归模板方法更简洁、易读且易于维护。然而，理解折叠表达式的基本原理和语法对于充分利用其优势至关重要。

6. 编译器支持

确保所使用的编译器支持C++17或更高标准，因为折叠表达式是在C++17中引入的。常见的支持C++17的编译器包括：

GCC：从版本7开始支持C++17，其中完整支持在后续版本中得到增强。
Clang：从版本5开始支持C++17。
MSVC（Visual Studio）：从Visual Studio 2017版本15.7开始提供较全面的C++17支持。

7. 性能考虑

折叠表达式本身并不引入额外的性能开销。它们是在编译时展开的，生成的代码与手动展开参数包时的代码几乎相同。然而，编写高效的折叠表达式仍然需要理解所应用操作符的性能特性。

SFINAE（Substitution Failure Is Not An Error）#

一、什么是SFINAE？#

SFINAE 是 “Substitution Failure Is Not An Error”（替换失败不是错误）的缩写，是C++模板编程中的一个重要概念。它允许编译器在模板实例化过程中，如果在替换模板参数时失败（即不满足某些条件），不会将其视为编译错误，而是继续寻找其他可能的模板或重载。这一机制为条件编译、类型特性检测、函数重载等提供了强大的支持。

二、SFINAE的工作原理#

在模板实例化过程中，编译器会尝试将模板参数替换为具体类型。如果在替换过程中出现不合法的表达式或类型，编译器不会报错，而是将该模板视为不可行的，继续尝试其他模板或重载。这一特性允许开发者根据类型特性选择不同的模板实现。

三、SFINAE的应用场景#

函数重载选择：根据参数类型的不同选择不同的函数实现。
类型特性检测：检测类型是否具有某些成员或特性，从而决定是否启用某些功能。
条件编译：根据模板参数的特性决定是否编译某些代码段。

四、SFINAE的基本用法#

SFINAE通常与std::enable_if、模板特化、以及类型萃取等技术结合使用。以下通过几个例子来说明SFINAE的应用。

示例一：通过**std::enable_if**实现函数重载

1
#include <type_traits>
2
#include <iostream>
3

4
// 适用于整数类型
5
template <typename T>
6
typename std::enable_if<std::is_integral<T>::value, void>::type
7
print_type(T value) {
8
    std::cout << "Integral type: " << value << std::endl;
9
}
10

11
// 适用于浮点类型
12
template <typename T>
13
typename std::enable_if<std::is_floating_point<T>::value, void>::type
14
print_type(T value) {
15
    std::cout << "Floating point type: " << value << std::endl;
16
}
17

18
int main() {
19
    print_type(10);      // 输出: Integral type: 10
20
    print_type(3.14);    // 输出: Floating point type: 3.14
21
    // print_type("Hello"); // 编译错误，没有匹配的函数
22
    return 0;
23
}

展开收起

解释：

std::enable_if 根据条件 std::is_integral<T>::value 或 std::is_floating_point<T>::value 决定是否启用对应的函数模板。
当条件不满足时，该模板实例化失败，但由于SFINAE规则，编译器不会报错，而是忽略该模板，从而实现函数重载选择。

示例二：检测类型是否具有特定成员

假设我们需要实现一个函数，仅当类型 T 具有成员函数 foo 时才启用该函数。

1
#include <type_traits>
2
#include <iostream>
3

4
// 辅助类型，检测是否存在成员函数 foo
5
template <typename T>
6
class has_foo {
7
private:
8
typedef char yes[1];
9
typedef char no[2];
10

11
template <typename U, void (U::*)()>
12
struct SFINAE {};
13

14
template <typename U>
15
static yes& test(SFINAE<U, &U::foo>*);
16

17
template <typename U>
18
static no& test(...);
19

20
public:
21
static constexpr bool value = sizeof(test<T>(0)) == sizeof(yes);
22
};
23

24
// 函数仅在 T 有 foo() 成员时启用
25
template <typename T>
26
typename std::enable_if<has_foo<T>::value, void>::type
27
call_foo(T& obj) {
28
    obj.foo();
29
    std::cout << "foo() called." << std::endl;
30
}
31

32
class WithFoo {
33
public:
34
void foo() { std::cout << "WithFoo::foo()" << std::endl; }
35
};
36

37
class WithoutFoo {};
38

39
int main() {
40
    WithFoo wf;
41
    call_foo(wf); // 输出: WithFoo::foo() \n foo() called.
42

43
    // WithoutFoo wf2;
44
    // call_foo(wf2); // 编译错误，没有匹配的函数
45
    return 0;
46
}

展开收起

解释：

has_foo 是一个类型萃取类，用于检测类型 T 是否具有成员函数 foo。
call_foo 函数模板仅在 T 具有 foo 成员时启用。
对于不具有 foo 成员的类型，编译器会忽略 call_foo，从而避免编译错误。

示例三：通过模板特化实现不同的行为

以下是完整的、正确实现 TypePrinter 的代码示例：

1
#include <type_traits>
2
#include <iostream>
3

4
// 1. 定义一个 Trait 用于检测 T 是否有非 void 的 `value_type`
5
template <typename T, typename = void>
6
struct has_non_void_value_type : std::false_type {};
7

8
// 仅当 T 有 `value_type` 且 `value_type` 不是 void 时，特化为 std::true_type
9
template <typename T>
10
struct has_non_void_value_type<T, std::enable_if_t<!std::is_void_v<typename T::value_type>>> : std::true_type {};
11

12
// 2. 定义 TypePrinter 主模板，使用一个布尔参数控制特化
13
template <typename T, bool HasValueType = has_non_void_value_type<T>::value>
14
struct TypePrinter;
15

16
// 3. 特化：当 HasValueType 为 true 时，表示 T 有非 void 的 `value_type`
17
template <typename T>
18
struct TypePrinter<T, true> {
19
    static void print(){
20
        std::cout << "T has a member type 'value_type'." << std::endl;
21
    }
22
};
23

24
// 特化：当 HasValueType 为 false 时，表示 T 没有 `value_type` 或 `value_type` 是 void
25
template <typename T>
26
struct TypePrinter<T, false> {
27
    static void print(){
28
        std::cout << "hello world! T does not have a member type 'value_type'." << std::endl;
29
    }
30
};
31

32
// 测试结构体
33
struct WithValueType{
34
    using value_type = int;
35
};
36

37
struct WithoutValueType{};
38

39
struct WithVoidValueType{
40
    using value_type = void;
41
};
42

43
int main() {
44
    TypePrinter<WithValueType>::print();        // 输出: T has a member type 'value_type'.
45
    TypePrinter<WithoutValueType>::print();     // 输出: hello world! T does not have a member type 'value_type'.
46
    TypePrinter<WithVoidValueType>::print();    // 输出: hello world! T does not have a member type 'value_type'.
47
    return 0;
48
}

展开收起

代码解释

Trait **has_non_void_value_type**:
- 主模板：默认情况下，has_non_void_value_type<T> 继承自 std::false_type，表示 T 没有 value_type 或 value_type 是 void。
- 特化模板：仅当 T 有 value_type 且 value_type 不是 void 时，has_non_void_value_type<T> 继承自 std::true_type。
**TypePrinter** 模板:
- 主模板：接受一个类型 T 和一个布尔模板参数 HasValueType，默认为 has_non_void_value_type<T>::value。
- 特化版本**** **TypePrinter<T, true>**：当 HasValueType 为 true 时，表示 T 有非 void 的 value_type，提供相应的 print 实现。
- 特化版本**** **TypePrinter<T, false>**：当 HasValueType 为 false 时，表示 T 没有 value_type 或 value_type 是 void，提供默认的 print 实现。
测试结构体：
- WithValueType：有一个非 void 的 value_type。
- WithoutValueType：没有 value_type。
- WithVoidValueType：有一个 value_type，但它是 void。
**main** 函数：
- 分别测试了三种情况，验证 TypePrinter 的行为是否符合预期。

五、SFINAE的优缺点#

优点：

灵活性高：能够根据类型特性选择不同的实现，提升代码的泛化能力。
类型安全：通过编译期检测，避免了运行时错误。
无需额外的运行时开销：所有的类型筛选都在编译期完成。

缺点：

复杂性高：SFINAE相关的代码往往较为复杂，阅读和维护难度较大。
编译器错误信息难以理解：SFINAE失败时，编译器可能给出晦涩的错误信息，调试困难。
模板实例化深度限制：过度使用SFINAE可能导致编译时间增加和模板实例化深度限制问题。

六、现代C++中的替代方案#

随着C++11及后续标准的发展，引入了诸如decltype、constexpr、if constexpr、概念（C++20）等新的特性，部分情况下可以替代传统的SFINAE，提高代码的可读性和可维护性。例如，C++20引入的概念（Concepts）提供了更为简洁和直观的方式来约束模板参数，减少了SFINAE的复杂性。

示例：使用概念替代SFINAE

1
#include <concepts>
2
#include <iostream>
3

4
// 定义一个概念，要求类型 T 是整数类型
5
template <typename T>
6
concept Integral = std::is_integral_v<T>;
7

8
// 仅当 T 满足 Integral 概念时启用
9
template <Integral T>
10
void print_type(T value) {
11
    std::cout << "Integral type: " << value << std::endl;
12
}
13

14
int main() {
15
    print_type(42);        // 输出: Integral type: 42
16
    // print_type(3.14);   // 编译错误，不满足 Integral 概念
17
    return 0;
18
}

展开收起

解释：

使用概念Integral代替std::enable_if，语法更简洁，代码更易读。
当类型不满足概念时，编译器会给出明确的错误信息，便于调试。

虽然上述方法经典且有效，但在C++11及以后版本，存在更简洁和易读的方式来实现相同的功能。例如，使用std::void_t和更现代的检测技巧，或者直接使用C++20的概念（Concepts），使代码更加清晰。

示例：使用**std::void_t**简化**has_foo**

1
#include <type_traits>
2
#include <iostream>
3

4
// 使用 std::void_t 简化 has_foo
5
template <typename, typename = std::void_t<>>
6
struct has_foo : std::false_type {};
7

8
template <typename T>
9
struct has_foo<T, std::void_t<decltype(std::declval<T>().foo())>> : std::true_type {};
10

11
// 函数仅在 T 有 foo() 成员时启用
12
template <typename T>
13
std::enable_if_t<has_foo<T>::value, void>
14
call_foo(T& obj) {
15
    obj.foo();
16
    std::cout << "foo() called." << std::endl;
17
}
18

19
class WithFoo {
20
public:
21
    void foo() { std::cout << "WithFoo::foo()" << std::endl; }
22
};
23

24
class WithoutFoo {};
25

26
int main() {
27
    WithFoo wf;
28
    call_foo(wf); // 输出: WithFoo::foo()
29
                   //      foo() called.
30

31
    // WithoutFoo wf2;
32
    // call_foo(wf2); // 编译错误，没有匹配的函数
33
    return 0;
34
}

展开收起

解释：

利用std::void_t，has_foo结构更为简洁。
decltype(std::declval<T>().foo())尝试在不实例化T对象的情况下检测foo()成员函数。
如果foo()存在，has_foo<T>继承自std::true_type，否则继承自std::false_type。

使用C++20概念

如果你使用的是支持C++20的编译器，可以利用概念（Concepts）进一步简化和增强可读性。

1
#include <concepts>
2
#include <type_traits>
3
#include <iostream>
4

5
// 定义一个概念，要求类型 T 具有 void foo()
6
template <typename T>
7
concept HasFoo = requires(T t) {
8
    { t.foo() } -> std::same_as<void>;
9
};
10

11
// 仅当 T 满足 HasFoo 概念时启用
12
template <HasFoo T>
13
void call_foo(T& obj) {
14
    obj.foo();
15
    std::cout << "foo() called." << std::endl;
16
}
17

18
class WithFoo {
19
public:
20
    void foo() { std::cout << "WithFoo::foo()" << std::endl; }
21
};
22

23
class WithoutFoo {};
24

25
int main() {
26
    WithFoo wf;
27
    call_foo(wf); // 输出: WithFoo::foo()
28
                   //      foo() called.
29

30
    // WithoutFoo wf2;
31
    // call_foo(wf2); // 编译错误，不满足 HasFoo 概念
32
    return 0;
33
}

展开收起

解释：

**HasFoo**概念：使用requires表达式检测类型T是否具有void foo()成员函数。
**call_foo**函数模板：仅当T满足HasFoo概念时，模板被启用。
这种方式更直观，易于理解和维护。

七、总结#

SFINAE作为C++模板编程中的一项强大功能，通过在模板实例化过程中允许替换失败而不报错，实现了基于类型特性的编程。然而，SFINAE的语法复杂且难以维护，现代C++引入的新特性如概念等在某些情况下已经能够更简洁地实现类似的功能。尽管如此，理解SFINAE的工作机制依然对于掌握高级模板技术和阅读老旧代码具有重要意义。

综合案例：结合模板特化与折叠表达式#

为了进一步巩固对模板特化和折叠表达式的理解，本节将通过一个综合案例展示如何将两者结合使用。

案例描述#

实现一个通用的日志记录器Logger，能够处理任意数量和类型的参数，并根据不同的类型组合调整输出格式。具体需求包括：

对于普通类型，使用通用的打印格式。
对于指针类型，打印指针地址或指向的值。
对于std::string类型，使用专门的格式。
支持可变数量的参数，通过折叠表达式实现参数的逐一打印。

实现步骤#

定义通用类模板**Logger**，使用模板特化和偏特化处理不同类型。
实现**log**函数，使用模板折叠表达式逐一打印参数。

代码实现#

1
#include <iostream>
2
#include <string>
3
#include <type_traits>
4

5
// 通用类模板
6
template <typename T, typename Enable = void>
7
class Logger {
8
public:
9
static void log(const T& value) {
10
    std::cout << "General Logger: " << value << std::endl;
11
}
12
};
13

14
// 类模板偏特化：当 T 是指针类型
15
template <typename T>
16
class Logger<T, typename std::enable_if<std::is_pointer<T>::value>::type> {
17
public:
18
static void log(T value) {
19
    if (value) {
20
        std::cout << "Pointer Logger: " << *value << std::endl;
21
    } else {
22
        std::cout << "Pointer Logger: nullptr" << std::endl;
23
    }
24
}
25
};
26

27
// 类模板全特化：当 T 是 std::string
28
template <>
29
class Logger<std::string> {
30
public:
31
static void log(const std::string& value) {
32
    std::cout << "String Logger: \"" << value << "\"" << std::endl;
33
}
34
};
35

36
// 函数模板，用于递归调用 Logger::log
37
template <typename T>
38
void logOne(const T& value) {
39
    Logger<T>::log(value);
40
}
41

42
// 使用模板折叠表达式实现多参数日志记录
43
template <typename... Args>
44
void logAll(const Args&... args) {
45
    (logOne(args), ...); // 左折叠，调用 logOne 对每个参数进行日志记录
46
}
47

48
int main() {
49
    int a = 10;
50
    double b = 3.14;
51
    std::string s = "Hello, World!";
52
    int* ptr = &a;
53
    double* pNull = nullptr;
54

55
    // 使用 Logger 类模板进行特化打印
56
    Logger<int>::log(a);          // 输出：General Logger: 10
57
    Logger<double*>::log(pNull);  // 输出：Pointer Logger: nullptr
58
    Logger<std::string>::log(s);  // 输出：String Logger: "Hello, World!"
59

60
    std::cout << "\nLogging multiple parameters:" << std::endl;
61
    logAll(a, b, s, ptr, pNull);
62
    /*
63
    输出：
64
    General Logger: 10
65
    General Logger: 3.14
66
    String Logger: "Hello, World!"
67
    Pointer Logger: 10
68
    Pointer Logger: nullptr
69
    */
70

71
    return 0;
72
}

展开收起

输出：

1
General Logger: 10
2
Pointer Logger: nullptr
3
String Logger: "Hello, World!"
4

5
Logging multiple parameters:
6
General Logger: 10
7
General Logger: 3.14
8
String Logger: "Hello, World!"
9
Pointer Logger: 10
10
Pointer Logger: nullptr

解析#

通用模板**Logger<T, Enable>**：
- 使用第二个模板参数Enable与SFINAE（Substitution Failure Is Not An Error）结合，控制模板特化。
- 对于非指针类型和非std::string类型，使用通用实现，打印"General Logger: value"。
类模板偏特化**Logger<T, Enable>**：
- 使用std::enable_if和std::is_pointer，当T是指针类型时，特化模板。
- 实现指针类型的特殊日志处理，打印指针指向的值或nullptr。
类模板全特化**Logger<std::string>**：
- 为std::string类型提供全特化版本，使用不同的输出格式。
**logOne**函数模板：
- 简化调用过程，调用相应的Logger<T>::log方法。
**logAll**函数模板：
- 使用模板折叠表达式(logOne(args), ...)，实现对所有参数的逐一日志记录。
- 通过左折叠的逗号表达式，确保每个logOne调用依次执行。
**main**函数：
- 测试不同类型的日志记录，包括普通类型、指针类型和std::string类型。
- 调用logAll函数，实现多参数的综合日志记录。

函数重载选择：根据类型特性选择不同的函数实现。
类型特性检测：检测类型是否具有某些成员或特性。
条件化成员函数：根据模板参数条件选择是否启用某些成员函数。

示例：检测类型是否具有 `size()` 成员函数#

1
#include <iostream>
2
#include <type_traits>
3
#include <vector>
4
#include <string>
5

6
// 辅助类型，用于 SFINAE
7
template <typename T>
8
class has_size {
9
private:
10
template <typename U>
11
static auto test(int) -> decltype(std::declval<U>().size(), std::true_type());
12

13
template <typename>
14
static std::false_type test(...);
15
public:
16
static constexpr bool value = decltype(test<T>(0))::value;
17
};
18

19
// 函数模板，根据是否具有 size() 成员进行重载
20
template <typename T>
21
typename std::enable_if<has_size<T>::value, void>::type
22
printSize(const T& container) {
23
    std::cout << "Size: " << container.size() << std::endl;
24
}
25

26
template <typename T>
27
typename std::enable_if<!has_size<T>::value, void>::type
28
printSize(const T& value) {
29
    std::cout << "No size available." << std::endl;
30
}
31

32
int main() {
33
    std::vector<int> vec = {1, 2, 3};
34
    std::string str = "Hello";
35
    int num = 42;
36

37
    printSize(vec); // 输出：Size: 3
38
    printSize(str); // 输出：Size: 5
39
    printSize(num); // 输出：No size available.
40

41
    return 0;
42
}

展开收起

输出：

1
Size: 3
2
Size: 5
3
No size available.

要点：

使用 std::enable_if 条件化选择函数模板。
检测类型特性，如是否拥有某成员函数。
SFINAE 使得不满足条件的模板自动被忽略，选择其他重载。

模板元编程（Template Metaprogramming）#

什么是模板元编程：模板元编程（Template Metaprogramming）是一种在编译期通过模板机制进行代码生成和计算的编程技术。它利用编译器的模板实例化机制，在编译期间执行代码逻辑，以提高程序的性能和灵活性。
模板元编程的优势：
- 提高代码的可重用性和泛化能力。
- 在编译期进行复杂计算，减少运行时开销。
- 实现类型安全的高级抽象。

模板元编程基础#

模板特化（Template Specialization）：
- 全特化（Full Specialization）：为特定类型提供特定实现。
- 偏特化（Partial Specialization）：为部分模板参数特定的情况提供实现。
递归模板（Recursive Templates）：利用模板的递归实例化机制，实现编译期计算。

编译期计算#

模板元编程允许在编译时执行计算，如计算阶乘、斐波那契数列等。

示例：编译期阶乘

1
#include <iostream>
2

3
// 基础情况
4
template <int N>
5
struct Factorial {
6
static const int value = N * Factorial<N - 1>::value;
7
};
8

9
// 递归终止
10
template <>
11
struct Factorial<0> {
12
static const int value = 1;
13
};
14

15
int main() {
16
    std::cout << "5! = " << Factorial<5>::value << std::endl; // 输出：5! = 120
17
    std::cout << "0! = " << Factorial<0>::value << std::endl; // 输出：0! = 1
18
    return 0;
19
}

展开收起

输出：

1
5! = 120
2
0! = 1

讲解：

基本模板Factorial定义了一个静态常量value，其值为N * Factorial<N - 1>::value，实现递归计算。
特化模板Factorial<0>定义递归终止条件，当N=0时，value为1。
在main函数中，通过Factorial<5>::value获取5的阶乘结果，编译期即生成其值。

静态成员变量的基本规则

在 C++ 中，静态成员变量的声明与定义有以下基本规则：

声明（Declaration）：在类内部声明静态成员变量，告诉编译器该类包含这个静态成员。
定义（Definition）：在类外部对静态成员变量进行定义，分配存储空间。

通常，对于非 constexpr 或非 inline 的静态成员变量，必须在类外进行定义，否则会导致链接器错误（undefined reference）。

特殊情况：**static const** 整数成员

对于 static const整数类型 的静态成员变量，C++ 标准做了一些特殊的处理：

类内初始化：你可以在类内部初始化 static const 整数成员变量，例如 static const int value = 42;。
使用场景

：

1
- **<font style="color:rgb(51, 51, 51);">不需要类外定义</font>**<font style="color:rgb(51, 51, 51);">：在某些情况下，编译器在编译阶段可以直接使用类内的初始化值，无需类外定义。</font>
2
- **<font style="color:rgb(51, 51, 51);">需要类外定义</font>**<font style="color:rgb(51, 51, 51);">：如果你在程序中对该静态成员变量进行取址（例如，</font>`<font style="color:rgb(51, 51, 51);background-color:rgb(243, 244, 244);">&Factorial<5>::value</font>`<font style="color:rgb(51, 51, 51);">），或者在其他需要该变量的存储位置时，就需要在类外进行定义。</font>

C++11 及之前的标准

在 C++11 及更早的标准中，对于 static const 整数成员变量：

不需要类外定义的情况

：

1
- <font style="color:rgb(51, 51, 51);">仅在作为编译期常量使用时，不需要类外定义。例如，用于数组大小、模板参数等。</font>

需要类外定义的情况

：

1
- <font style="color:rgb(51, 51, 51);">当你需要对变量进行取址，或者在需要其存储位置时，必须在类外定义。例如：</font>

1
template<int N>
2
struct Factorial{
3
static const int value = N * Factorial<N-1>::value;
4
};
5

6
// 类外定义
7
template<int N>
8
const int Factorial<N>::value;

C++17 及更新标准

从 C++17 开始，引入了 内联变量（inline variables），使得在类内定义静态成员变量变得更加灵活：

内联静态成员变量

：

1
- <font style="color:rgb(51, 51, 51);">使用 </font>`<font style="color:rgb(51, 51, 51);background-color:rgb(243, 244, 244);">inline</font>`<font style="color:rgb(51, 51, 51);"> 关键字，可以在类内对静态成员变量进行定义，无需在类外进行单独定义。</font>
2
- <font style="color:rgb(51, 51, 51);">这适用于 C++17 及更高版本。</font>

例如，你可以这样编写：

1
template<int N>
2
struct Factorial{
3
inline static const int value = N * Factorial<N-1>::value;
4
};
5

6
template<>
7
struct Factorial<0>{
8
inline static const int value = 1;
9
};

在这种情况下，无需在类外进行定义，因为 inline 确保了该变量在每个翻译单元中都只有一个实例。

在 C++11 及之前的标准

代码：

1
template<int N>
2
struct Factorial{
3
static const int value = N * Factorial<N-1>::value;
4
};
5

6
template<>
7
struct Factorial<0>{
8
static const int value = 1;
9
};

作为编译期常量使用

：

1
- <font style="color:rgb(51, 51, 51);">例如，用于其他模板参数或编译期常量计算时，不需要类外定义。</font>

取址或需要存储位置时

：

1
- <font style="color:rgb(51, 51, 51);">需要在类外进行定义。例如：</font>

1
template<int N>
2
const int Factorial<N>::value;
3

4
template<>
5
const int Factorial<0>::value;

在 C++17 及更高标准

如果你使用 C++17 及更高版本，可以使用 inline 关键字：

1
template<int N>
2
struct Factorial{
3
inline static const int value = N * Factorial<N-1>::value;
4
};
5

6
template<>
7
struct Factorial<0>{
8
inline static const int value = 1;
9
};

无需类外定义

：

1
- `<font style="color:rgb(51, 51, 51);background-color:rgb(243, 244, 244);">inline</font>`<font style="color:rgb(51, 51, 51);"> 使得在类内的定义成为唯一的定义，即使在多个翻译单元中使用，也不会导致重复定义错误。</font>

实际示例与测试

示例 1：仅作为编译期常量使用

1
#include <iostream>
2

3
// 你的 Factorial 模板
4
template<int N>
5
struct Factorial{
6
static const int value = N * Factorial<N-1>::value;
7
};
8

9
template<>
10
struct Factorial<0>{
11
static const int value = 1;
12
};
13

14
int main() {
15
    std::cout << "Factorial<5>::value = " << Factorial<5>::value << std::endl;
16
    return 0;
17
}

展开收起

C++11 及之前：无需类外定义。
C++17 及更新：同样无需类外定义，且可以使用 inline 进一步优化。

示例 2：取址

1
#include <iostream>
2

3
// 你的 Factorial 模板
4
template<int N>
5
struct Factorial{
6
static const int value = N * Factorial<N-1>::value;
7
};
8

9
template<>
10
struct Factorial<0>{
11
static const int value = 1;
12
};
13

14
// 类外定义（在 C++11 及之前需要）
15
template<int N>
16
const int Factorial<N>::value;
17

18
template<>
19
const int Factorial<0>::value;
20

21
int main() {
22
    std::cout << "Factorial<5>::value = " << Factorial<5>::value << std::endl;
23
    std::cout << "&Factorial<5>::value = " << &Factorial<5>::value << std::endl;
24
    return 0;
25
}

展开收起

C++11 及之前：必须提供类外定义，否则会在链接时出现错误。
C++17 及更新：若未使用 inline，仍需提供类外定义；使用 inline 则无需。

示例 3：使用 **inline**（C++17 及更高）

1
#include <iostream>
2

3
// 你的 Factorial 模板（使用 inline）
4
template<int N>
5
struct Factorial{
6
inline static const int value = N * Factorial<N-1>::value;
7
};
8

9
template<>
10
struct Factorial<0>{
11
inline static const int value = 1;
12
};
13

14
int main() {
15
    std::cout << "Factorial<5>::value = " << Factorial<5>::value << std::endl;
16
    std::cout << "&Factorial<5>::value = " << &Factorial<5>::value << std::endl;
17
    return 0;
18
}

展开收起

C++17 及以上：
- 无需类外定义。
- inline 保证了多重定义的合法性。

详细解析

为什么有这样的特殊处理？

优化与性能

：

1
- <font style="color:rgb(51, 51, 51);">在编译期常量的情况下，不需要在运行时分配存储空间，编译器可以优化掉相关代码。</font>

兼容性

：

1
- <font style="color:rgb(51, 51, 51);">早期 C++ 标准遵循这种规则，允许在类内初始化静态常量成员变量，便于模板元编程和常量表达式的使用。</font>

inline 变量

：

1
- <font style="color:rgb(51, 51, 51);">C++17 引入 </font>`<font style="color:rgb(51, 51, 51);background-color:rgb(243, 244, 244);">inline</font>`<font style="color:rgb(51, 51, 51);"> 关键字用于变量，解决了静态成员变量在多个翻译单元中的定义问题，使得代码更简洁。</font>

是否总是需要定义？

并非总是需要。关键在于 如何使用 这个静态成员变量：

仅作为编译期常量使用：无需类外定义。
需要存储位置或取址：需要类外定义，除非使用 inline（C++17 及以上）。

编译器与链接器的行为

编译阶段

：

1
- <font style="color:rgb(51, 51, 51);">类内的初始化用于编译期常量计算，不涉及存储分配。</font>

链接阶段

：

1
- <font style="color:rgb(51, 51, 51);">如果没有类外定义，且静态成员被 odr-used（可能需要存储位置），链接器会报错，提示找不到符号定义。</font>
2
- <font style="color:rgb(51, 51, 51);">使用 </font>`<font style="color:rgb(51, 51, 51);background-color:rgb(243, 244, 244);">inline</font>`<font style="color:rgb(51, 51, 51);"> 关键字后，编译器处理为内联变量，避免了多重定义问题。</font>

示例：编译期斐波那契数列

1
#include <iostream>
2

3
// 基础情况
4
template <int N>
5
struct Fibonacci {
6
static const long long value = Fibonacci<N - 1>::value + Fibonacci<N - 2>::value;
7
};
8

9
// 递归终止
10
template <>
11
struct Fibonacci<0> {
12
static const long long value = 0;
13
};
14

15
template <>
16
struct Fibonacci<1> {
17
static const long long value = 1;
18
};
19

20
int main() {
21
    std::cout << "Fibonacci<10> = " << Fibonacci<10>::value << std::endl; // 输出：Fibonacci<10> = 55
22
    std::cout << "Fibonacci<20> = " << Fibonacci<20>::value << std::endl; // 输出：Fibonacci<20> = 6765
23
    return 0;
24
}

展开收起

输出：

1
Fibonacci<10> = 55
2
Fibonacci<20> = 6765

要点：

模板元编程利用编译期计算提升程序性能。
需要理解模板递归与终止条件。
常与类型特性和模板特化结合使用。

类型计算与SFINAE#

类型计算：在编译期进行类型的推导和转换。
SFINAE（Substitution Failure Is Not An Error）：模板实例化过程中，如果某个替换失败，编译器不会报错，而是忽略该模板，并尝试其他匹配。

示例：检测类型是否可加

1
#include <type_traits>
2

3
// 检测是否可以对T类型进行加法操作
4
template <typename T, typename = void>
5
struct is_addable : std::false_type {};
6

7
template <typename T>
8
struct is_addable<T, decltype(void(std::declval<T>() + std::declval<T>()))> : std::true_type {};
9

10
// 使用
11
static_assert(is_addable<int>::value, "int should be addable");
12
static_assert(!is_addable<void*>::value, "void* should not be addable");

讲解：

1. **struct is_addable<...> : std::true_type {}**

目的：定义一个名为 is_addable 的结构体模板，它继承自 std::true_type。
作用：当特定的模板参数满足条件时，这个特化版本将被选中，表示 T 类型是可加的，即支持 + 操作符。

2. 模板参数解释：**<T, decltype(void(std::declval<T>() + std::declval<T>()))>**

**T**：这是要检查的类型。
**std::declval<T>()**：
- 用途：std::declval<T>() 是一个用于在不实际创建 T 类型对象的情况下，生成一个 T 类型的右值引用。
- 作用：它允许我们在编译时模拟 T 类型的对象，以便用于表达式的检测。
**std::declval<T>() + std::declval<T>()**：
- 表达式：尝试对两个 T 类型的右值引用进行加法运算。
- 目的：检查 T 类型是否支持 + 操作符。
**void(...)**：
- 将加法表达式的结果转换为 void 类型。这是为了在 decltype 中仅关心表达式是否有效，而不关心其具体类型。
**decltype(void(std::declval<T>() + std::declval<T>()))**：
- 作用：如果 T 类型支持加法运算，则该 decltype 表达式的类型为 void，否则会导致替换失败

高级模板元编程技巧#

变参模板（Variadic Templates）：支持模板参数包，实现更加灵活的模板定义。

示例：求和模板

1
// 基本递归模板
2
template <int... Ns>
3
struct Sum;
4

5
// 递归终止
6
template <>
7
struct Sum<> {
8
static const int value = 0;
9
};
10

11
// 递归定义
12
template <int N, int... Ns>
13
struct Sum<N, Ns...> {
14
static const int value = N + Sum<Ns...>::value;
15
};
16

17
// 使用
18
int main() {
19
    int result = Sum<1, 2, 3, 4, 5>::value; // 15
20
    return 0;
21
}

展开收起

讲解：

基本模板Sum接受一个整数参数包Ns...。
特化模板Sum<>定义递归终止条件，value为0。
递归定义Sum<N, Ns...>将第一个参数N与剩余参数的和相加。
在main函数中，通过Sum<1, 2, 3, 4, 5>::value计算1+2+3+4+5=15。

类型列表（Type Lists）：通过模板参数包管理类型的集合。

示例：类型列表和元素访问

1
// 定义类型列表
2
template <typename... Ts>
3
struct TypeList {};
4

5
// 获取类型列表中第N个类型
6
template <typename List, std::size_t N>
7
struct TypeAt;
8

9
template <typename Head, typename... Tail>
10
struct TypeAt<TypeList<Head, Tail...>, 0> {
11
using type = Head;
12
};
13

14
template <typename Head, typename... Tail, std::size_t N>
15
struct TypeAt<TypeList<Head, Tail...>, N> {
16
using type = typename TypeAt<TypeList<Tail...>, N - 1>::type;
17
};
18

19
// 使用
20
using list = TypeList<int, double, char>;
21
using third_type = TypeAt<list, 2>::type; // char

展开收起

讲解：

**TypeList**：定义一个包含多个类型的类型列表。
TypeAt：通过递归模板，从TypeList中获取第N个类型。
- 当N为0时，类型为Head。
- 否则，递归获取Tail...中第N-1个类型。
使用：定义list为TypeList<int, double, char>，third_type为第2个类型，即char。

实际应用案例#

案例1：静态断言与类型检查

1
#include <type_traits>
2

3
template <typename T>
4
struct is_integral_type {
5
static const bool value = std::is_integral<T>::value;
6
};
7

8
// 使用
9
static_assert(is_integral_type<int>::value, "int is integral");
10
static_assert(!is_integral_type<float>::value, "float is not integral");

案例2：编译期字符串

1
#include <utility>
2

3
// 编译期字符串
4
template <char... Cs>
5
struct String {
6
static constexpr char value[sizeof...(Cs) + 1] = { Cs..., '\0' };
7
};
8

9
template <char... Cs>
10
constexpr char String<Cs...>::value[sizeof...(Cs) + 1];
11

12
// 使用
13
using hello = String<'H','e','l','l','o'>;

为什么需要外部定义 **value**

在 C++ 中，静态成员变量与类的实例无关，它们存在于全局命名空间中。然而，静态成员变量的声明和定义是不同的：

声明：告诉编译器类中存在这个变量。
定义：为这个变量分配存储空间。

对于非 inline 的静态成员变量，即使是 constexpr，都需要在类外部进行定义。否则，链接器在处理多个翻译单元时会因为找不到变量的定义而报错。

具体原因

模板类的静态成员变量：
- 每当模板实例化时，都会产生一个新的类类型，每个类类型都有自己的一组静态成员变量。
- 因此，编译器需要知道这些静态成员变量在所有翻译单元中都唯一对应一个定义。
**constexpr** 静态成员变量：
- 从 C++17 开始，inline 关键字引入，使得 constexpr 静态成员变量可以在类内定义，并且隐式地具有 inline 属性。这意味着不需要在类外定义它们，因为 inline 确保了在多个翻译单元中有同一份定义。
- 但在 C++17 之前或不使用 inline 的情况下，即使是 constexpr，仍需在类外定义。

类内声明：static constexpr char value[...] 声明了 value 并给予了初始值。
类外定义：constexpr char String<Cs...>::value[...] 为 value 分配了存储空间。

如果省略类外定义，编译器会在链接阶段找不到 value 的定义，导致链接错误。这尤其适用于 C++14 及更早版本，以及 C++17 中未使用 inline 的情形。

如何避免外部定义

如果你使用的是 C++17 或更高版本，可以通过 inline 关键字将静态成员变量声明为 inline，从而在类内完成定义，无需再在外部定义。例如：

1
#include <utility>
2

3
// 编译期字符串
4
template <char... Cs>
5
struct String {
6
inline static constexpr char value[sizeof...(Cs) + 1] = { Cs..., '\0' };
7
};
8

9
// 使用
10
using hello = String<'H','e','l','l','o'>;

在这个版本中，inline 关键字告诉编译器这是一个内联变量，允许在多个翻译单元中存在同一份定义，而不会导致重复定义错误。因此，无需在类外再次定义 value。

完整示例对比

不使用 **inline**（需要类外定义）

1
#include <utility>
2

3
// 编译期字符串
4
template <char... Cs>
5
struct String {
6
static constexpr char value[sizeof...(Cs) + 1] = { Cs..., '\0' };
7
};
8

9
// 外部定义
10
template <char... Cs>
11
constexpr char String<Cs...>::value[sizeof...(Cs) + 1];
12

13
// 使用
14
using hello = String<'H','e','l','l','o'>;
15

16
int main() {
17
    // 访问 value
18
    // std::cout << hello::value;
19
}

展开收起

使用 **inline**（无需类外定义，C++17 起）

1
#include <utility>
2

3
// 编译期字符串
4
template <char... Cs>
5
struct String {
6
inline static constexpr char value[sizeof...(Cs) + 1] = { Cs..., '\0' };
7
};
8

9
// 使用
10
using hello = String<'H','e','l','l','o'>;
11

12
int main() {
13
    // 访问 value
14
    // std::cout << hello::value;
15
}

展开收起

C++20 Concepts#

C++20 引入了 Concepts，它们为模板参数提供了更强的约束和表达能力，使模板的使用更简洁、错误信息更友好。

定义与使用#

定义一个 Concept

Concepts 使用 concept 关键字定义，并作为函数或类模板的约束。

1
#include <concepts>
2
#include <iostream>
3

4
// 定义一个 Concept：要求类型必须是可输出到 std::ostream
5
template <typename T>
6
concept Printable = requires(T a) {
7
{ std::cout << a } -> std::same_as<std::ostream&>;
8
};

使用 Concept 约束模板

1
// 使用 Concepts 约束函数模板
2
template <Printable T>
3
void print(const T& value) {
4
    std::cout << value << std::endl;
5
}
6

7
int main() {
8
    print(42);          // 正常调用
9
    print("Hello");     // 正常调用
10
    // print(std::vector<int>{1, 2, 3}); // 编译错误，std::vector<int> 不满足 Printable
11
    return 0;
12
}

限制与约束#

Concepts 允许为模板参数定义复杂的约束，使得模板更具表达性，同时提升编译器错误信息的可理解性。

示例：排序函数中的 Concepts

1
#include <concepts>
2
#include <vector>
3
#include <iostream>
4
#include <algorithm>
5

6
// 定义一个可比较的概念
7
template <typename T>
8
concept Comparable = requires(T a, T b) {
9
{ a < b } -> std::convertible_to<bool>;
10
};
11

12
// 排序函数，约束类型必须可比较
13
template <Comparable T>
14
void sortVector(std::vector<T>& vec) {
15
    std::sort(vec.begin(), vec.end());
16
}
17

18
int main() {
19
    std::vector<int> nums = {4, 2, 3, 1};
20
    sortVector(nums);
21
    for(auto num : nums)
22
        std::cout << num << " "; // 输出：1 2 3 4
23
    std::cout << std::endl;
24

25
    // std::vector<std::vector<int>> vecs;
26
    // sortVector(vecs); // 编译错误，std::vector<int> 不满足 Comparable
27
    return 0;
28
}

展开收起

输出：

1 2 3 4

要点：

Concepts 提供了模板参数的语义约束。
使用 Concepts 提高模板的可读性和可维护性。
生成更友好的编译错误信息，易于调试。

模板实例化与编译器行为#

理解模板实例化的过程有助于进行有效的模板设计与优化，尤其是在涉及链接和编译时间时。

显式实例化（Explicit Instantiation）#

显式实例化告诉编译器生成特定类型下的模板代码，主要用于分离模板的声明与定义，减少编译时间。

语法：

1
// 声明模板（通常在头文件中）
2
template <typename T>
3
class MyClass;
4

5
// 定义模板（通常在源文件中）
6
template <typename T>
7
class MyClass { /* ... */ };
8

9
// 显式实例化
10
template class MyClass<int>;

示例：分离类模板的声明与定义

MyClass.h

1
#ifndef MYCLASS_H
2
#define MYCLASS_H
3

4
template <typename T>
5
class MyClass {
6
public:
7
void doSomething();
8
};
9

10
#endif // MYCLASS_H

MyClass.cpp

1
#include "MyClass.h"
2
#include <iostream>
3

4
template <typename T>
5
void MyClass<T>::doSomething() {
6
    std::cout << "Doing something with " << typeid(T).name() << std::endl;
7
}
8

9
// 显式实例化
10
template class MyClass<int>;
11
template class MyClass<double>;

main.cpp

1
#include "MyClass.h"
2

3
int main() {
4
    MyClass<int> obj1;
5
    obj1.doSomething(); // 输出：Doing something with i
6

7
    MyClass<double> obj2;
8
    obj2.doSomething(); // 输出：Doing something with d
9

10
    // MyClass<char> obj3; // 链接错误，因为 MyClass<char> 未实例化
11

12
    return 0;
13
}

输出：

1
Doing something with i
2
Doing something with d

注意事项：

显式实例化需要在模板定义后进行。
只有显式实例化的类型在未实例化时可用于模板分离。
未显式实例化的类型可能导致链接错误。

隐式实例化（Implicit Instantiation）#

隐式实例化是编译器在模板被实际使用时自动生成对应实例代码的过程。通常，模板定义与使用都在头文件中完成。

示例：

MyClass.h

1
#ifndef MYCLASS_H
2
#define MYCLASS_H
3

4
#include <iostream>
5
#include <typeinfo>
6

7
template <typename T>
8
class MyClass {
9
public:
10
void doSomething() {
11
    std::cout << "Doing something with " << typeid(T).name() << std::endl;
12
}
13
};
14

15
#endif // MYCLASS_H

展开收起

main.cpp

1
#include "MyClass.h"
2

3
int main() {
4
    MyClass<int> obj1;
5
    obj1.doSomething(); // 输出：Doing something with i
6

7
    MyClass<double> obj2;
8
    obj2.doSomething(); // 输出：Doing something with d
9

10
    MyClass<char> obj3;
11
    obj3.doSomething(); // 输出：Doing something with c
12

13
    return 0;
14
}

输出：

1
Doing something with i
2
Doing something with d
3
Doing something with c

要点：

隐式实例化不需要显式声明或定义。
模板定义必须在使用前可见，通常通过头文件实现。
容易导致编译时间增加，尤其是大型模板库。

链接时问题与解决方案#

由于模板是在使用时被实例化，跨源文件使用模板可能导致链接时问题，如重复定义或未定义引用。

解决方案：

内联实现：将模板的定义与声明一起放在头文件中，避免链接时重复定义。
显式实例化：将常用的模板实例化放在源文件中，其他源文件通过 extern 或头文件引用已有实例。
使用 **extern template**：告知编译器某些模板实例已在其他源文件中显式实例化。

示例：使用 **extern template**

MyClass.h

1
#ifndef MYCLASS_H
2
#define MYCLASS_H
3

4
template <typename T>
5
class MyClass {
6
public:
7
void doSomething();
8
};
9

10
// 声明模板实例，但不定义
11
extern template class MyClass<int>;
12
extern template class MyClass<double>;
13

14
#endif // MYCLASS_H

MyClass.cpp

1
#include "MyClass.h"
2
#include <iostream>
3
#include <typeinfo>
4

5
template <typename T>
6
void MyClass<T>::doSomething() {
7
    std::cout << "Doing something with " << typeid(T).name() << std::endl;
8
}
9

10
// 显式实例化
11
template class MyClass<int>;
12
template class MyClass<double>;

main.cpp

1
#include "MyClass.h"
2

3
int main() {
4
    MyClass<int> obj1;
5
    obj1.doSomething(); // 使用已显式实例化的模板
6

7
    MyClass<double> obj2;
8
    obj2.doSomething(); // 使用已显式实例化的模板
9

10
    // MyClass<char> obj3; // 链接错误，未实例化
11
    return 0;
12
}

要点：

使用 extern template 声明已在其他源文件中实例化的模板。
减少编译时间和链接大小，防止重复定义。

最佳实践与注意事项#

掌握模板的最佳实践有助于编写高效、可维护的代码，同时避免常见的陷阱和问题。

模板定义与实现分离#

对于类模板，通常将模板的声明和定义放在同一头文件中，以确保编译器在实例化模板时能够看到完整的定义。尽管可以尝试将模板定义分离到源文件，但需要结合显式实例化，这会增加复杂性，且不适用于广泛使用的模板。

推荐做法：

类模板：将声明和实现统一在头文件中。
函数模板：同样将声明和实现统一在头文件中，或使用显式实例化。

避免过度模板化#

虽然模板提供了极大的灵活性，但过度复杂的模板会导致代码难以理解、维护和编译时间增加。

建议：

只在必要时使用模板。
保持模板的简单性和可读性，避免过度嵌套和复杂的特化。
合理使用类型特性和 Concepts 进行约束。

提高编译速度的方法#

模板的广泛使用可能导致编译时间显著增加。以下方法有助于优化编译速度：

预编译头文件（Precompiled Headers）：将频繁使用的模板库放入预编译头中，加速编译。
显式实例化：通过显式实例化减少模板的重复编译。
模块化编程（C++20 Modules）：利用模块化将模板库进行编译和链接，减少编译时间。
合理分割头文件：避免头文件中的模板定义过大，分割成较小的模块。

代码复用与库设计#

模板是实现高度复用库组件的有效手段，如标准库（std::vector、std::map 等）广泛使用模板。设计模板库时，需考虑以下因素：

接口的一致性：保持模板库的接口简洁、一致，便于使用者理解和使用。
文档与示例：提供详细的文档和示例代码，帮助使用者理解模板库的用法。
错误信息友好：通过 Concepts、SFINAE 等机制提供清晰的错误信息，降低使用门槛。
性能优化：利用模板的编译期计算和内联等特性，提高库组件的性能。

避免模板错误的困惑#

模板错误通常复杂且难以理解，以下方法有助于减少模板错误的困惑：

逐步调试：从简单的模板开始，逐步增加复杂性，便于定位错误。
使用编译器警告与工具：开启编译器的警告选项，使用静态分析工具检测模板代码中的问题。
代码注释与文档：详细注释复杂的模板代码，提供文档说明其设计和用途。

总结#

C++ 模板机制是实现泛型编程的核心工具，通过类型参数化和编译期计算，极大地提升了代码的复用性、灵活性和性能。从基础的函数模板和类模板，到高级的模板特化、变参模板、模板元编程、SFINAE 和 Concepts，掌握模板的各个方面能够帮助开发者编写更高效、更加通用的 C++ 代码。

在实际应用中，合理运用模板不仅可以简化代码结构，还可以提高代码的可维护性和可扩展性。然而，模板的复杂性也要求开发者具备扎实的 C++ 基础和良好的编程习惯，以避免过度复杂化和难以调试的问题。

通过本教案的系统学习，相信您已经具备了全面理解和运用 C++ 模板的能力，能够在实际项目中高效地利用模板特性，编写出更为优秀的代码。

运算符重载

Thu, 28 May 2026 00:00:00 GMT

运算符重载概述#

**运算符重载（Operator Overloading）**允许开发者为自定义类型定义或重新定义运算符的行为，使得自定义类型的对象能够使用与内置类型相同的运算符进行操作。这不仅提高了代码的可读性，还增强了代码的表达能力。

为什么需要运算符重载#

在面向对象编程中，我们经常需要定义自己的类来表示某些实体（如复数、向量、矩形等）。为了使这些类的对象能够与内置类型一样方便地进行操作，运算符重载显得尤为重要。例如：

对于复数类，使用 + 运算符进行加法运算。
对于字符串类，使用 << 运算符进行输出。
对于矩阵类，使用 * 运算符进行矩阵乘法。

通过运算符重载，可以使代码更简洁、直观，类似于数学表达式。

运算符重载的规则与限制#

不能改变运算符的优先级和结合性：运算符的优先级和结合性在编译阶段就确定，不能通过重载来改变。
不能创建新的运算符：仅能重载C++中已有的运算符，不能定义新的运算符。
至少有一个操作数必须是用户定义的类型：不能对两个内置类型进行运算符重载。
某些运算符不能重载：包括 .（成员选择运算符）、.*、::、?:（条件运算符）等。
重载运算符的优先级和结合性不可改变。

运算符重载的方法#

在C++中，运算符可以通过成员函数或非成员函数（通常是友元函数）来重载。

成员函数方式#

运算符作为类的成员函数进行重载时，左操作数是当前对象（this）。因此，对于需要修改左操作数的运算符，成员函数方式通常更直观。

语法示例：

1
class ClassName {
2
public:
3
    ClassName operator+(const ClassName& other);
4
};

非成员函数方式（友元函数）#

当需要对两个不同类型的对象进行运算，或者左操作数不是当前类的对象时，通常使用非成员函数方式。为了访问类的私有成员，非成员函数通常被声明为类的友元函数。

语法示例：

1
class ClassName {
2
    friend ClassName operator+(const ClassName& lhs, const ClassName& rhs);
3
};

1. 算术运算符#

1.1 `+` 运算符#

作用：实现两个对象的加法操作。

示例类：Complex（复数类）

1
#include <iostream>
2

3
class Complex {
4
private:
5
    double real;
6
    double imag;
7

8
public:
9
    // 构造函数
10
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
11

12
    // 重载 + 运算符（成员函数）
13
    Complex operator+(const Complex& other) const {
14
        return Complex(this->real + other.real, this->imag + other.imag);
15
    }
16

17
    // 重载 << 运算符用于输出
18
    friend std::ostream& operator<<(std::ostream& os, const Complex& c);
19
};
20

21
// 实现 << 运算符
22
std::ostream& operator<<(std::ostream& os, const Complex& c) {
23
    os << "(" << c.real;
24
    if (c.imag >= 0)
25
        os << " + " << c.imag << "i)";
26
    else
27
        os << " - " << -c.imag << "i)";
28
    return os;
29
}
30

31
// 示例
32
int main() {
33
    Complex c1(3.0, 4.0);
34
    Complex c2(1.5, -2.5);
35
    Complex c3 = c1 + c2;
36
    std::cout << "c1 + c2 = " << c3 << std::endl;
37
    return 0;
38
}

展开收起

输出：

1
c1 + c2 = (4.5 + 1.5i)

1.2 `-` 运算符#

作用：实现两个对象的减法操作。

示例类：Complex（复数类）

1
// ...（与上面类似）
2

3
// 重载 - 运算符（成员函数）
4
Complex operator-(const Complex& other) const {
5
    return Complex(this->real - other.real, this->imag - other.imag);
6
}
7

8
// 示例
9
int main() {
10
    Complex c1(5.0, 6.0);
11
    Complex c2(2.5, -1.5);
12
    Complex c4 = c1 - c2;
13
    std::cout << "c1 - c2 = " << c4 << std::endl;
14
    return 0;
15
}

展开收起

输出：

1
c1 - c2 = (2.5 + 7.5i)

1.3 `*` 运算符#

作用：实现对象的乘法操作。

示例类：Complex（复数类）

1
// ...（与上面类似）
2

3
// 重载 * 运算符（成员函数）
4
Complex operator*(const Complex& other) const {
5
    double r = this->real * other.real - this->imag * other.imag;
6
    double i = this->real * other.imag + this->imag * other.real;
7
    return Complex(r, i);
8
}
9

10
// 示例
11
int main() {
12
    Complex c1(3.0, 4.0);
13
    Complex c2(1.5, -2.5);
14
    Complex c5 = c1 * c2;
15
    std::cout << "c1 * c2 = " << c5 << std::endl;
16
    return 0;
17
}

展开收起

输出：

1
c1 * c2 = (13.5 + 1i)

1.4 `/` 运算符#

作用：实现对象的除法操作。

示例类：Complex（复数类）

1
#include <stdexcept>
2

3
// ...（与上面类似）
4

5
// 重载 / 运算符（成员函数）
6
Complex operator/(const Complex& other) const {
7
    double denominator = other.real * other.real + other.imag * other.imag;
8
    if (denominator == 0) {
9
        throw std::invalid_argument("除数为零！");
10
    }
11
    double r = (this->real * other.real + this->imag * other.imag) / denominator;
12
    double i = (this->imag * other.real - this->real * other.imag) / denominator;
13
    return Complex(r, i);
14
}
15

16
// 示例
17
int main() {
18
    Complex c1(3.0, 4.0);
19
    Complex c2(1.5, -2.5);
20
    try {
21
        Complex c6 = c1 / c2;
22
        std::cout << "c1 / c2 = " << c6 << std::endl;
23
    } catch (const std::invalid_argument& e) {
24
        std::cerr << "错误: " << e.what() << std::endl;
25
    }
26
    return 0;
27
}

展开收起

输出：

1
c1 / c2 = (-0.823529 + 1.64706i)

2. 赋值运算符#

2.1 `=` 运算符#

作用：实现对象的赋值操作。

示例类：Complex（复数类）

C++编译器会自动生成默认的拷贝赋值运算符，但当类中包含动态分配内存或需要自定义行为时，需要自行重载。

1
#include <iostream>
2

3
class Complex {
4
private:
5
    double real;
6
    double imag;
7

8
public:
9
    // 构造函数
10
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
11

12
    // 拷贝赋值运算符（成员函数）
13
    Complex& operator=(const Complex& other) {
14
        if (this == &other)
15
            return *this; // 防止自赋值
16
        this->real = other.real;
17
        this->imag = other.imag;
18
        return *this;
19
    }
20

21
    // 重载 << 运算符用于输出
22
    friend std::ostream& operator<<(std::ostream& os, const Complex& c);
23
};
24

25
// 实现 << 运算符
26
std::ostream& operator<<(std::ostream& os, const Complex& c) {
27
    os << "(" << c.real;
28
    if (c.imag >= 0)
29
        os << " + " << c.imag << "i)";
30
    else
31
        os << " - " << -c.imag << "i)";
32
    return os;
33
}
34

35
// 示例
36
int main() {
37
    Complex c1(3.0, 4.0);
38
    Complex c2;
39
    c2 = c1; // 使用拷贝赋值运算符
40
    std::cout << "c2 = " << c2 << std::endl;
41
    return 0;
42
}

展开收起

输出：

1
c2 = (3 + 4i)

2.2 复合赋值运算符（`+=`, `-=`, `*=`, `/=`）#

作用：实现复合赋值操作，如 +=，-= 等。

示例类：Complex（复数类）

1
// ...（与上面类似）
2

3
// 重载 += 运算符（成员函数）
4
Complex& operator+=(const Complex& other) {
5
    this->real += other.real;
6
    this->imag += other.imag;
7
    return *this;
8
}
9

10
// 重载 -= 运算符（成员函数）
11
Complex& operator-=(const Complex& other) {
12
    this->real -= other.real;
13
    this->imag -= other.imag;
14
    return *this;
15
}
16

17
// 重载 *= 运算符（成员函数）
18
Complex& operator*=(const Complex& other) {
19
    double r = this->real * other.real - this->imag * other.imag;
20
    double i = this->real * other.imag + this->imag * other.real;
21
    this->real = r;
22
    this->imag = i;
23
    return *this;
24
}
25

26
// 重载 /= 运算符（成员函数）
27
Complex& operator/=(const Complex& other) {
28
    double denominator = other.real * other.real + other.imag * other.imag;
29
    if (denominator == 0) {
30
        throw std::invalid_argument("除数为零！");
31
    }
32
    double r = (this->real * other.real + this->imag * other.imag) / denominator;
33
    double i = (this->imag * other.real - this->real * other.imag) / denominator;
34
    this->real = r;
35
    this->imag = i;
36
    return *this;
37
}
38

39
// 示例
40
int main() {
41
    Complex c1(3.0, 4.0);
42
    Complex c2(1.0, 2.0);
43

44
    c1 += c2;
45
    std::cout << "c1 += c2: " << c1 << std::endl;
46

47
    c1 -= c2;
48
    std::cout << "c1 -= c2: " << c1 << std::endl;
49

50
    c1 *= c2;
51
    std::cout << "c1 *= c2: " << c1 << std::endl;
52

53
    try {
54
        c1 /= c2;
55
        std::cout << "c1 /= c2: " << c1 << std::endl;
56
    } catch (const std::invalid_argument& e) {
57
        std::cerr << "错误: " << e.what() << std::endl;
58
    }
59

60
    return 0;
61
}

展开收起

输出：

1
c1 += c2: (4 + 6i)
2
c1 -= c2: (3 + 4i)
3
c1 *= c2: (-5 + 10i)
4
c1 /= c2: (2 + 0i)

3. 比较运算符#

3.1 `==` 运算符#

作用：判断两个对象是否相等。

示例类：Complex（复数类）

1
// ...（与上面类似）
2

3
// 重载 == 运算符（友元函数）
4
friend bool operator==(const Complex& lhs, const Complex& rhs);
5

6
// 实现 == 运算符
7
bool operator==(const Complex& lhs, const Complex& rhs) {
8
    return (lhs.real == rhs.real) && (lhs.imag == rhs.imag);
9
}
10

11
// 示例
12
int main() {
13
    Complex c1(3.0, 4.0);
14
    Complex c2(3.0, 4.0);
15
    Complex c3(1.5, -2.5);
16

17
    if (c1 == c2)
18
        std::cout << "c1 和 c2 相等" << std::endl;
19
    else
20
        std::cout << "c1 和 c2 不相等" << std::endl;
21

22
    if (c1 == c3)
23
        std::cout << "c1 和 c3 相等" << std::endl;
24
    else
25
        std::cout << "c1 和 c3 不相等" << std::endl;
26

27
    return 0;
28
}

展开收起

输出：

1
c1 和 c2 相等
2
c1 和 c3 不相等

3.2 `!=` 运算符#

作用：判断两个对象是否不相等。

示例类：Complex（复数类）

1
// ...（与上面类似）
2

3
// 重载 != 运算符（友元函数）
4
friend bool operator!=(const Complex& lhs, const Complex& rhs);
5

6
// 实现 != 运算符
7
bool operator!=(const Complex& lhs, const Complex& rhs) {
8
    return !(lhs == rhs);
9
}
10

11
// 示例
12
int main() {
13
    Complex c1(3.0, 4.0);
14
    Complex c2(3.0, 4.0);
15
    Complex c3(1.5, -2.5);
16

17
    if (c1 != c2)
18
        std::cout << "c1 和 c2 不相等" << std::endl;
19
    else
20
        std::cout << "c1 和 c2 相等" << std::endl;
21

22
    if (c1 != c3)
23
        std::cout << "c1 和 c3 不相等" << std::endl;
24
    else
25
        std::cout << "c1 和 c3 相等" << std::endl;
26

27
    return 0;
28
}

展开收起

输出：

1
c1 和 c2 相等
2
c1 和 c3 不相等

3.3 `<`, `>`, `<=`, `>=` 运算符#

作用：实现对象之间的大小比较。对于复数来说，通常没有自然的大小顺序，但为了示例，可以定义复数的模长进行比较。

示例类：Complex（复数类）

1
#include <cmath>
2

3
// ...（与上面类似）
4

5
// 重载 < 运算符（友元函数）
6
friend bool operator<(const Complex& lhs, const Complex& rhs);
7

8
// 重载 > 运算符（友元函数）
9
friend bool operator>(const Complex& lhs, const Complex& rhs);
10

11
// 重载 <= 运算符（友元函数）
12
friend bool operator<=(const Complex& lhs, const Complex& rhs);
13

14
// 重载 >= 运算符（友元函数）
15
friend bool operator>=(const Complex& lhs, const Complex& rhs);
16

17
// 实现 < 运算符
18
bool operator<(const Complex& lhs, const Complex& rhs) {
19
    double lhs_mod = std::sqrt(lhs.real * lhs.real + lhs.imag * lhs.imag);
20
    double rhs_mod = std::sqrt(rhs.real * rhs.real + rhs.imag * rhs.imag);
21
    return lhs_mod < rhs_mod;
22
}
23

24
// 实现 > 运算符
25
bool operator>(const Complex& lhs, const Complex& rhs) {
26
    return rhs < lhs;
27
}
28

29
// 实现 <= 运算符
30
bool operator<=(const Complex& lhs, const Complex& rhs) {
31
    return !(rhs < lhs);
32
}
33

34
// 实现 >= 运算符
35
bool operator>=(const Complex& lhs, const Complex& rhs) {
36
    return !(lhs < rhs);
37
}
38

39
// 示例
40
int main() {
41
    Complex c1(3.0, 4.0); // 模长 5
42
    Complex c2(1.0, 2.0); // 模长 sqrt(5) ≈ 2.236
43
    Complex c3(3.0, 4.0); // 模长 5
44

45
    if (c1 < c2)
46
        std::cout << "c1 的模长小于 c2 的模长" << std::endl;
47
    else
48
        std::cout << "c1 的模长不小于 c2 的模长" << std::endl;
49

50
    if (c1 > c2)
51
        std::cout << "c1 的模长大于 c2 的模长" << std::endl;
52
    else
53
        std::cout << "c1 的模长不大于 c2 的模长" << std::endl;
54

55
    if (c1 <= c3)
56
        std::cout << "c1 的模长小于或等于 c3 的模长" << std::endl;
57
    else
58
        std::cout << "c1 的模长大于 c3 的模长" << std::endl;
59

60
    if (c1 >= c3)
61
        std::cout << "c1 的模长大于或等于 c3 的模长" << std::endl;
62
    else
63
        std::cout << "c1 的模长小于 c3 的模长" << std::endl;
64

65
    return 0;
66
}

展开收起

输出：

1
c1 的模长不小于 c2 的模长
2
c1 的模长大于 c2 的模长
3
c1 的模长小于或等于 c3 的模长
4
c1 的模长大于或等于 c3 的模长

4. 逻辑运算符#

4.1 `&&`, `||`, `!` 运算符#

作用：实现逻辑操作。需要注意，C++ 中的 && 和 || 运算符无法短路地重载，而且通常不建议重载它们，因为会改变其原有的逻辑语义。通常，建议使用类型转换或其他方法来实现逻辑判断。

示例类：Boolean 类（用于示例）

1
#include <iostream>
2

3
class Boolean {
4
private:
5
    bool value;
6

7
public:
8
    // 构造函数
9
    Boolean(bool val = false) : value(val) {}
10

11
    // 重载逻辑非运算符（!）（成员函数）
12
    bool operator!() const {
13
        return !value;
14
    }
15

16
    // 重载逻辑与运算符（&）（非短路）（成员函数）
17
    Boolean operator&(const Boolean& other) const {
18
        return Boolean(this->value & other.value);
19
    }
20

21
    // 重载逻辑或运算符（|）（非短路）（成员函数）
22
    Boolean operator|(const Boolean& other) const {
23
        return Boolean(this->value | other.value);
24
    }
25

26
    // 重载输出运算符
27
    friend std::ostream& operator<<(std::ostream& os, const Boolean& b);
28
};
29

30
// 实现 << 运算符
31
std::ostream& operator<<(std::ostream& os, const Boolean& b) {
32
    os << (b.value ? "true" : "false");
33
    return os;
34
}
35

36
// 示例
37
int main() {
38
    Boolean b1(true);
39
    Boolean b2(false);
40

41
    Boolean b3 = b1 & b2;
42
    Boolean b4 = b1 | b2;
43
    Boolean b5 = !b1;
44
    Boolean b6 = !b2;
45

46
    std::cout << "b1 & b2 = " << b3 << std::endl;
47
    std::cout << "b1 | b2 = " << b4 << std::endl;
48
    std::cout << "!b1 = " << b5 << std::endl;
49
    std::cout << "!b2 = " << b6 << std::endl;
50

51
    return 0;
52
}

展开收起

输出：

1
b1 & b2 = false
2
b1 | b2 = true
3
!b1 = false
4
!b2 = true

说明：

注意：在重载 && 和 || 运算符时，要明白它们不会具有短路行为。因此，通常不建议重载这两个运算符。
本例中，使用 & 和 | 运算符来模拟逻辑与、或操作。

5. 位运算符#

5.1 `&`, `|`, `^`, `~` 运算符#

作用：实现位级操作，如按位与、按位或、按位异或、按位取反。

示例类：Bitmask 类

1
#include <iostream>
2

3
class Bitmask {
4
private:
5
    unsigned int bits;
6

7
public:
8
    // 构造函数
9
    Bitmask(unsigned int b = 0) : bits(b) {}
10

11
    // 重载 & 运算符（成员函数）
12
    Bitmask operator&(const Bitmask& other) const {
13
        return Bitmask(this->bits & other.bits);
14
    }
15

16
    // 重载 | 运算符（成员函数）
17
    Bitmask operator|(const Bitmask& other) const {
18
        return Bitmask(this->bits | other.bits);
19
    }
20

21
    // 重载 ^ 运算符（成员函数）
22
    Bitmask operator^(const Bitmask& other) const {
23
        return Bitmask(this->bits ^ other.bits);
24
    }
25

26
    // 重载 ~ 运算符（成员函数）
27
    Bitmask operator~() const {
28
        return Bitmask(~this->bits);
29
    }
30

31
    // 重载 << 运算符用于输出
32
    friend std::ostream& operator<<(std::ostream& os, const Bitmask& b);
33
};
34

35
// 实现 << 运算符
36
std::ostream& operator<<(std::ostream& os, const Bitmask& b) {
37
    os << "0x" << std::hex << b.bits << std::dec;
38
    return os;
39
}
40

41
// 示例
42
int main() {
43
    Bitmask bm1(0b10101010); // 0xAA
44
    Bitmask bm2(0b11001100); // 0xCC
45

46
    Bitmask bm3 = bm1 & bm2;
47
    Bitmask bm4 = bm1 | bm2;
48
    Bitmask bm5 = bm1 ^ bm2;
49
    Bitmask bm6 = ~bm1;
50

51
    std::cout << "bm1 & bm2 = " << bm3 << std::endl;
52
    std::cout << "bm1 | bm2 = " << bm4 << std::endl;
53
    std::cout << "bm1 ^ bm2 = " << bm5 << std::endl;
54
    std::cout << "~bm1 = " << bm6 << std::endl;
55

56
    return 0;
57
}

展开收起

输出：

1
bm1 & bm2 = 0x88
2
bm1 | bm2 = 0xee
3
bm1 ^ bm2 = 0x66
4
~bm1 = 0xffffff55

5.2 `<<`, `>>` 位移运算符#

作用：实现位移操作，如左移、右移。

示例类：Bitmask 类

1
// ...（与上面类似）
2

3
// 重载 << 运算符（左移，成员函数）
4
Bitmask operator<<(int shift) const {
5
    return Bitmask(this->bits << shift);
6
}
7

8
// 重载 >> 运算符（右移，成员函数）
9
Bitmask operator>>(int shift) const {
10
    return Bitmask(this->bits >> shift);
11
}
12

13
// 示例
14
int main() {
15
    Bitmask bm1(0b0001); // 0x1
16

17
    Bitmask bm2 = bm1 << 3;
18
    Bitmask bm3 = bm1 >> 1;
19

20
    std::cout << "bm1 << 3 = " << bm2 << std::endl;
21
    std::cout << "bm1 >> 1 = " << bm3 << std::endl;
22

23
    return 0;
24
}

展开收起

输出：

Terminal window

1
bm1 << 3 = 0x8
2
bm1 >> 1 = 0x0

说明：

重载位移运算符时，通常接受一个整型参数，表示位移的位数。

6. 自增自减运算符#

6.1 前置 `++` 和 `--` 运算符#

作用：实现对象的自增和自减操作。

示例类：Counter 类

1
#include <iostream>
2

3
class Counter {
4
private:
5
    int count;
6

7
public:
8
    // 构造函数
9
    Counter(int c = 0) : count(c) {}
10

11
    // 前置 ++ 运算符（成员函数）
12
    Counter& operator++() {
13
        ++count;
14
        return *this;
15
    }
16

17
    // 前置 -- 运算符（成员函数）
18
    Counter& operator--() {
19
        --count;
20
        return *this;
21
    }
22

23
    // 重载 << 运算符用于输出
24
    friend std::ostream& operator<<(std::ostream& os, const Counter& c);
25
};
26

27
// 实现 << 运算符
28
std::ostream& operator<<(std::ostream& os, const Counter& c) {
29
    os << c.count;
30
    return os;
31
}
32

33
// 示例
34
int main() {
35
    Counter c(10);
36
    std::cout << "初始值: " << c << std::endl;
37
    std::cout << "++c = " << ++c << std::endl;
38
    std::cout << "--c = " << --c << std::endl;
39
    return 0;
40
}

展开收起

输出：

1
初始值: 10
2
++c = 11
3
--c = 10

6.2 后置 `++` 和 `--` 运算符#

作用：实现对象的后置自增和自减操作。

示例类：Counter 类

1
// ...（与上面类似）
2

3
// 后置 ++ 运算符（成员函数）
4
Counter operator++(int) {
5
    Counter temp = *this;
6
    ++count;
7
    return temp;
8
}
9

10
// 后置 -- 运算符（成员函数）
11
Counter operator--(int) {
12
    Counter temp = *this;
13
    --count;
14
    return temp;
15
}
16

17
// 示例
18
int main() {
19
    Counter c(10);
20
    std::cout << "初始值: " << c << std::endl;
21
    std::cout << "c++ = " << c++ << std::endl;
22
    std::cout << "c-- = " << c-- << std::endl;
23
    std::cout << "当前值: " << c << std::endl;
24
    return 0;
25
}

展开收起

输出：

1
初始值: 10
2
c++ = 10
3
c-- = 11
4
当前值: 10

说明：

前置运算符：先修改对象，再返回引用。
后置运算符：先保存原值，修改对象，再返回原值。

7. 下标运算符 `[]`#

作用：实现对象的下标访问，如数组访问。

示例类：Vector 类

1
#include <iostream>
2
#include <vector>
3
#include <stdexcept>
4

5
class Vector {
6
private:
7
    std::vector<double> components;
8

9
public:
10
    // 构造函数
11
    Vector(const std::vector<double>& comps) : components(comps) {}
12

13
    // 重载 [] 运算符（非 const）
14
    double& operator[](size_t index) {
15
        if (index >= components.size()) {
16
            throw std::out_of_range("下标越界！");
17
        }
18
        return components[index];
19
    }
20

21
    // 重载 [] 运算符（const）
22
    const double& operator[](size_t index) const {
23
        if (index >= components.size()) {
24
            throw std::out_of_range("下标越界！");
25
        }
26
        return components[index];
27
    }
28

29
    // 重载 << 运算符用于输出
30
    friend std::ostream& operator<<(std::ostream& os, const Vector& v);
31
};
32

33
// 实现 << 运算符
34
std::ostream& operator<<(std::ostream& os, const Vector& v) {
35
    os << "(";
36
    for (size_t i = 0; i < v.components.size(); ++i) {
37
        os << v.components[i];
38
        if (i != v.components.size() - 1)
39
            os << ", ";
40
    }
41
    os << ")";
42
    return os;
43
}
44

45
// 示例
46
int main() {
47
    Vector v({1.0, 2.0, 3.0});
48
    std::cout << "初始向量: " << v << std::endl;
49

50
    // 访问元素
51
    try {
52
        std::cout << "v[1] = " << v[1] << std::endl;
53
        v[1] = 5.0;
54
        std::cout << "修改后向量: " << v << std::endl;
55
    } catch (const std::out_of_range& e) {
56
        std::cerr << "错误: " << e.what() << std::endl;
57
    }
58

59
    // 访问越界
60
    try {
61
        std::cout << "v[3] = " << v[3] << std::endl; // 越界
62
    } catch (const std::out_of_range& e) {
63
        std::cerr << "错误: " << e.what() << std::endl;
64
    }
65

66
    return 0;
67
}

展开收起

输出：

1
初始向量: (1, 2, 3)
2
v[1] = 2
3
修改后向量: (1, 5, 3)
4
错误: 下标越界！

说明：

提供了 const 和非 const 两种重载，以支持不同上下文中的访问。
在访问时进行了边界检查，确保安全性。

8. 函数调用运算符 `()`#

作用：使对象能够像函数一样被调用，常用于函数对象（functors）或仿函数。

示例类：Multiplier 类

1
#include <iostream>
2

3
class Multiplier {
4
private:
5
    double factor;
6

7
public:
8
    // 构造函数
9
    Multiplier(double f = 1.0) : factor(f) {}
10

11
    // 重载 () 运算符（成员函数）
12
    double operator()(double x) const {
13
        return x * factor;
14
    }
15
};
16

17
// 示例
18
int main() {
19
    Multiplier double_it(2.0);
20
    Multiplier triple_it(3.0);
21

22
    std::cout << "double_it(5) = " << double_it(5) << std::endl;
23
    std::cout << "triple_it(5) = " << triple_it(5) << std::endl;
24

25
    return 0;
26
}

展开收起

输出：

1
double_it(5) = 10
2
triple_it(5) = 15

说明：

通过重载 () 运算符，Multiplier 对象可以像函数一样接受参数并进行操作。
常用于需要定制函数行为的场景，如排序时的比较函数。

9. 输入输出运算符 `<<`, `>>`#

作用：实现对象与输入输出流之间的交互。

示例类：Complex（复数类）

1
#include <iostream>
2
#include <stdexcept>
3

4
class Complex {
5
private:
6
    double real;
7
    double imag;
8

9
public:
10
    // 构造函数
11
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
12

13
    // 重载 << 运算符（友元函数）
14
    friend std::ostream& operator<<(std::ostream& os, const Complex& c);
15

16
    // 重载 >> 运算符（友元函数）
17
    friend std::istream& operator>>(std::istream& is, Complex& c);
18
};
19

20
// 实现 << 运算符
21
std::ostream& operator<<(std::ostream& os, const Complex& c) {
22
    os << "(" << c.real;
23
    if (c.imag >= 0)
24
        os << " + " << c.imag << "i)";
25
    else
26
        os << " - " << -c.imag << "i)";
27
    return os;
28
}
29

30
// 实现 >> 运算符
31
std::istream& operator>>(std::istream& is, Complex& c) {
32
    // 假设输入格式为：real imag
33
    is >> c.real >> c.imag;
34
    return is;
35
}
36

37
// 示例
38
int main() {
39
    Complex c1;
40
    std::cout << "请输入复数的实部和虚部，以空格分隔: ";
41
    std::cin >> c1;
42
    std::cout << "您输入的复数是: " << c1 << std::endl;
43
    return 0;
44
}

展开收起

示例输入：

1
请输入复数的实部和虚部，以空格分隔: 3.5 -2.1

输出：

1
您输入的复数是: (3.5 - 2.1i)

说明：

<< 运算符用于输出对象到流中。
>> 运算符用于从流中输入对象的数据。
一般将这些运算符重载为友元函数，以便访问类的私有成员。

10. 其他运算符#

10.1 成员访问运算符 `->`, `->*`#

说明：

运算符 -> 和 ->* 通常用于代理模式或智能指针的实现，较为复杂。
其重载需要返回一个指针类型，以便进一步访问成员。
通常不建议普通类进行重载，除非有特定需求。

示例类：Proxy 类（代理模式）

1
#include <iostream>
2

3
class RealObject {
4
public:
5
    void display() const {
6
        std::cout << "RealObject::display()" << std::endl;
7
    }
8
};
9

10
class Proxy {
11
private:
12
    RealObject* ptr;
13

14
public:
15
    // 构造函数
16
    Proxy(RealObject* p = nullptr) : ptr(p) {}
17

18
    // 重载 -> 运算符（成员函数）
19
    RealObject* operator->() const {
20
        return ptr;
21
    }
22
};
23

24
// 示例
25
int main() {
26
    RealObject real;
27
    Proxy proxy(&real);
28

29
    proxy->display(); // 使用重载的 -> 运算符
30
    return 0;
31
}

展开收起

输出：

1
RealObject::display()

说明：

Proxy 类通过重载 -> 运算符，将对 Proxy 对象的成员访问转发给其内部的 RealObject 对象。
这是实现代理模式或智能指针的常见方式。

综合案例：复数（Complex）类中的所有运算符重载#

为了将上述所有运算符的重载整合在一个类中，以下是一个全面的 Complex 类示例，涵盖了大部分可重载的运算符。

1
#include <iostream>
2
#include <cmath>
3
#include <stdexcept>
4

5
class Complex {
6
private:
7
    double real;
8
    double imag;
9

10
public:
11
    // 构造函数
12
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
13

14
    // 拷贝赋值运算符
15
    Complex& operator=(const Complex& other) {
16
        if (this == &other)
17
            return *this;
18
        this->real = other.real;
19
        this->imag = other.imag;
20
        return *this;
21
    }
22

23
    // 重载 + 运算符（成员函数）
24
    Complex operator+(const Complex& other) const {
25
        return Complex(this->real + other.real, this->imag + other.imag);
26
    }
27

28
    // 重载 - 运算符（成员函数）
29
    Complex operator-(const Complex& other) const {
30
        return Complex(this->real - other.real, this->imag - other.imag);
31
    }
32

33
    // 重载 * 运算符（成员函数）
34
    Complex operator*(const Complex& other) const {
35
        double r = this->real * other.real - this->imag * other.imag;
36
        double i = this->real * other.imag + this->imag * other.real;
37
        return Complex(r, i);
38
    }
39

40
    // 重载 / 运算符（成员函数）
41
    Complex operator/(const Complex& other) const {
42
        double denominator = other.real * other.real + other.imag * other.imag;
43
        if (denominator == 0) {
44
            throw std::invalid_argument("除数为零！");
45
        }
46
        double r = (this->real * other.real + this->imag * other.imag) / denominator;
47
        double i = (this->imag * other.real - this->real * other.imag) / denominator;
48
        return Complex(r, i);
49
    }
50

51
    // 重载 += 运算符
52
    Complex& operator+=(const Complex& other) {
53
        this->real += other.real;
54
        this->imag += other.imag;
55
        return *this;
56
    }
57

58
    // 重载 -= 运算符
59
    Complex& operator-=(const Complex& other) {
60
        this->real -= other.real;
61
        this->imag -= other.imag;
62
        return *this;
63
    }
64

65
    // 重载 *= 运算符
66
    Complex& operator*=(const Complex& other) {
67
        double r = this->real * other.real - this->imag * other.imag;
68
        double i = this->real * other.imag + this->imag * other.real;
69
        this->real = r;
70
        this->imag = i;
71
        return *this;
72
    }
73

74
    // 重载 /= 运算符
75
    Complex& operator/=(const Complex& other) {
76
        double denominator = other.real * other.real + other.imag * other.imag;
77
        if (denominator == 0) {
78
            throw std::invalid_argument("除数为零！");
79
        }
80
        double r = (this->real * other.real + this->imag * other.imag) / denominator;
81
        double i = (this->imag * other.real - this->real * other.imag) / denominator;
82
        this->real = r;
83
        this->imag = i;
84
        return *this;
85
    }
86

87
    // 重载 == 运算符
88
    friend bool operator==(const Complex& lhs, const Complex& rhs) {
89
        return (lhs.real == rhs.real) && (lhs.imag == rhs.imag);
90
    }
91

92
    // 重载 != 运算符
93
    friend bool operator!=(const Complex& lhs, const Complex& rhs) {
94
        return !(lhs == rhs);
95
    }
96

97
    // 重载 < 运算符（基于模长）
98
    friend bool operator<(const Complex& lhs, const Complex& rhs) {
99
        double lhs_mod = std::sqrt(lhs.real * lhs.real + lhs.imag * lhs.imag);
100
        double rhs_mod = std::sqrt(rhs.real * rhs.real + rhs.imag * rhs.imag);
101
        return lhs_mod < rhs_mod;
102
    }
103

104
    // 重载 > 运算符
105
    friend bool operator>(const Complex& lhs, const Complex& rhs) {
106
        return rhs < lhs;
107
    }
108

109
    // 重载 <= 运算符
110
    friend bool operator<=(const Complex& lhs, const Complex& rhs) {
111
        return !(rhs < lhs);
112
    }
113

114
    // 重载 >= 运算符
115
    friend bool operator>=(const Complex& lhs, const Complex& rhs) {
116
        return !(lhs < rhs);
117
    }
118

119
    // 重载 << 运算符
120
    friend std::ostream& operator<<(std::ostream& os, const Complex& c) {
121
        os << "(" << c.real;
122
        if (c.imag >= 0)
123
            os << " + " << c.imag << "i)";
124
        else
125
            os << " - " << -c.imag << "i)";
126
        return os;
127
    }
128

129
    // 重载 >> 运算符
130
    friend std::istream& operator>>(std::istream& is, Complex& c) {
131
        // 简单输入格式：real imag
132
        is >> c.real >> c.imag;
133
        return is;
134
    }
135

136
    // 重载 ~ 运算符（取反复数）
137
    Complex operator~() const {
138
        return Complex(this->real, -this->imag);
139
    }
140

141
    // 重载逻辑非运算符（!）
142
    bool operator!() const {
143
        return (this->real == 0 && this->imag == 0);
144
    }
145

146
    // 重载下标运算符（如 c[0] 返回 real, c[1] 返回 imag）
147
    double& operator[](size_t index) {
148
        if (index == 0)
149
            return real;
150
        else if (index == 1)
151
            return imag;
152
        else
153
            throw std::out_of_range("下标越界！");
154
    }
155

156
    const double& operator[](size_t index) const {
157
        if (index == 0)
158
            return real;
159
        else if (index == 1)
160
            return imag;
161
        else
162
            throw std::out_of_range("下标越界！");
163
    }
164

165
    // 重载前置 ++ 运算符
166
    Complex& operator++() {
167
        ++real;
168
        ++imag;
169
        return *this;
170
    }
171

172
    // 重载后置 ++ 运符
173
    Complex operator++(int) {
174
        Complex temp = *this;
175
        ++real;
176
        ++imag;
177
        return temp;
178
    }
179

180
    // 重载前置 -- 运算符
181
    Complex& operator--() {
182
        --real;
183
        --imag;
184
        return *this;
185
    }
186

187
    // 重载后置 -- 运算符
188
    Complex operator--(int) {
189
        Complex temp = *this;
190
        --real;
191
        --imag;
192
        return temp;
193
    }
194

195
    // 重载函数调用运算符
196
    double operator()(const std::string& part) const {
197
        if (part == "real")
198
            return real;
199
        else if (part == "imag")
200
            return imag;
201
        else
202
            throw std::invalid_argument("参数错误！");
203
    }
204
};
205

206
// 示例
207
int main() {
208
    Complex c1(3.0, 4.0);
209
    Complex c2(1.5, -2.5);
210
    Complex c3;
211

212
    // 赋值运算
213
    c3 = c1;
214
    std::cout << "c3 = " << c3 << std::endl;
215

216
    // 加法
217
    Complex c4 = c1 + c2;
218
    std::cout << "c1 + c2 = " << c4 << std::endl;
219

220
    // 减法
221
    Complex c5 = c1 - c2;
222
    std::cout << "c1 - c2 = " << c5 << std::endl;
223

224
    // 乘法
225
    Complex c6 = c1 * c2;
226
    std::cout << "c1 * c2 = " << c6 << std::endl;
227

228
    // 除法
229
    try {
230
        Complex c7 = c1 / c2;
231
        std::cout << "c1 / c2 = " << c7 << std::endl;
232
    } catch (const std::invalid_argument& e) {
233
        std::cerr << "错误: " << e.what() << std::endl;
234
    }
235

236
    // 比较运算
237
    if (c1 > c2)
238
        std::cout << "c1 的模长大于 c2" << std::endl;
239
    else
240
        std::cout << "c1 的模长不大于 c2" << std::endl;
241

242
    // 逻辑非运算
243
    Complex c_zero;
244
    if (!c1)
245
        std::cout << "c1 是零复数" << std::endl;
246
    else
247
        std::cout << "c1 不是零复数" << std::endl;
248

249
    if (!c_zero)
250
        std::cout << "c_zero 是零复数" << std::endl;
251
    else
252
        std::cout << "c_zero 不是零复数" << std::endl;
253

254
    // 取反运算
255
    Complex c_neg = ~c1;
256
    std::cout << "~c1 = " << c_neg << std::endl;
257

258
    // 下标运算
259
    try {
260
        std::cout << "c1[0] (real) = " << c1[0] << std::endl;
261
        std::cout << "c1[1] (imag) = " << c1[1] << std::endl;
262
        // std::cout << "c1[2] = " << c1[2] << std::endl; // 会抛出异常
263
    } catch (const std::out_of_range& e) {
264
        std::cerr << "错误: " << e.what() << std::endl;
265
    }
266

267
    // 自增自减运算符
268
    std::cout << "c1 = " << c1 << std::endl;
269
    std::cout << "++c1 = " << ++c1 << std::endl;
270
    std::cout << "c1++ = " << c1++ << std::endl;
271
    std::cout << "c1 = " << c1 << std::endl;
272
    std::cout << "--c1 = " << --c1 << std::endl;
273
    std::cout << "c1-- = " << c1-- << std::endl;
274
    std::cout << "c1 = " << c1 << std::endl;
275

276
    // 函数调用运算符
277
    std::cout << "c1 的实部: " << c1("real") << std::endl;
278
    std::cout << "c1 的虚部: " << c1("imag") << std::endl;
279

280
    // 输入运算
281
    std::cout << "请输入一个复数的实部和虚部，以空格分隔: ";
282
    Complex c_input;
283
    std::cin >> c_input;
284
    std::cout << "您输入的复数是: " << c_input << std::endl;
285

286
    return 0;
287
}

展开收起

示例运行：

1
c3 = (3 + 4i)
2
c1 + c2 = (4.5 + 1.5i)
3
c1 - c2 = (1.5 + 6.5i)
4
c1 * c2 = (13.5 + 1i)
5
c1 / c2 = (-0.823529 + 1.64706i)
6
c1 的模长大于 c2
7
c1 不是零复数
8
c_zero 是零复数
9
~c1 = (3 - 4i)
10
c1[0] (real) = 3
11
c1[1] (imag) = 4
12
c1 = (3 + 4i)
13
++c1 = (4 + 5i)
14
c1++ = (4 + 5i)
15
c1 = (5 + 6i)
16
--c1 = (4 + 5i)
17
c1-- = (4 + 5i)
18
c1 = (3 + 4i)
19
c1 的实部: 3
20
c1 的虚部: 4
21
请输入一个复数的实部和虚部，以空格分隔: 2.5 -3.5
22
您输入的复数是: (2.5 - 3.5i)

展开收起

说明：

该类集成了大部分可重载的运算符，包括算术、赋值、比较、逻辑、位运算、自增自减、下标、函数调用以及输入输出运算符。
某些运算符（如 &&, ||, ->*）未在此示例中体现，因为它们的重载较为复杂且不常见。
在实际开发中，应根据需求选择性地重载运算符，避免过度设计。

11. 其他可重载运算符#

11.1 逗号运算符 `,`#

作用：实现对象在逗号表达式中的行为。

示例类：Logger 类（用于示例）

1
#include <iostream>
2
#include <string>
3

4
class Logger {
5
private:
6
    std::string message;
7

8
public:
9
    // 构造函数
10
    Logger(const std::string& msg = "") : message(msg) {}
11

12
    // 重载逗号运算符（成员函数）
13
    Logger operator,(const Logger& other) const {
14
        // 简单示例：连接日志消息
15
        return Logger(this->message + ", " + other.message);
16
    }
17

18
    // 重载 << 运算符用于输出
19
    friend std::ostream& operator<<(std::ostream& os, const Logger& l);
20
};
21

22
// 实现 << 运算符
23
std::ostream& operator<<(std::ostream& os, const Logger& l) {
24
    os << l.message;
25
    return os;
26
}
27

28
// 示例
29
int main() {
30
    Logger log1("启动");
31
    Logger log2("加载配置");
32
    Logger log3("初始化");
33
    Logger combined = (log1, log2, log3);
34
    std::cout << "组合日志: " << combined << std::endl;
35
    return 0;
36
}

展开收起

输出：

1
组合日志: 启动, 加载配置, 初始化

说明：

重载 , 运算符可以自定义逗号表达式的行为，但在实际应用中不常见，应谨慎使用。
多个逗号运算符的重载会按从左至右的顺序依次调用。

运算符重载注意事项#

语义一致性：重载运算符后，其行为应与运算符的传统意义保持一致。例如，+ 应表示加法，避免引起混淆。
效率：尽量避免不必要的对象拷贝，可以通过返回引用或使用移动语义提升效率。
异常安全：在实现运算符重载时，考虑并处理可能的异常情况，确保程序的健壮性。
封装性：保持类的封装性，避免过度暴露内部细节。仅在必要时使用友元函数。
返回类型：根据运算符的用途选择合适的返回类型。例如，算术运算符通常返回新对象，赋值运算符返回引用等。
避免复杂的逻辑：运算符重载应简洁明了，不应包含过于复杂的逻辑，避免使代码难以理解和维护。
可读性：使用适当的注释和文档说明运算符重载的行为，增强代码的可读性。

小结#

运算符重载是C++中强大的特性，允许开发者为自定义类定义或重新定义运算符的行为，使对象的操作更加直观和符合逻辑。在设计和实现运算符重载时，应遵循语义一致性、效率和封装性等原则，避免滥用。通过本教案中的详细案例，学习者可以全面理解运算符重载的应用，并在实际编程中灵活运用。

无序map封装

Wed, 27 May 2026 00:00:00 GMT

unordermap用法#

unordered_map 是 C++ 标准库中的关联容器，提供了基于哈希表的键值对存储结构。与 map （基于红黑树实现）不同，unordered_map 提供的是平均常数时间复杂度的查找、插入和删除操作，但不保证元素的顺序。

以下是 unordered_map 的详细用法说明：

1. 头文件#

要使用 unordered_map，需要包含头文件：

1
#include <unordered_map>

2. 基本定义#

unordered_map 的基本模板定义如下：

1
std::unordered_map<KeyType, ValueType, Hash = std::hash<KeyType>, KeyEqual = std::equal_to<KeyType>, Allocator = std::allocator<std::pair<const KeyType, ValueType>>>

常用模板参数：#

KeyType：键的类型，需要支持哈希运算和相等比较。
ValueType：值的类型。
Hash：哈希函数，默认为 std::hash<KeyType>。
KeyEqual：键相等的比较函数，默认为 std::equal_to<KeyType>。
Allocator：内存分配器，默认为 std::allocator。

3. 常用操作#

3.1 创建和初始化#

1
#include <iostream>
2
#include <unordered_map>
3
#include <string>
4

5
int main() {
6
    // 创建一个空的 unordered_map，键为 string，值为 int
7
    std::unordered_map<std::string, int> umap;
8

9
    // 使用初始化列表初始化
10
    std::unordered_map<std::string, int> umap_init = {
11
        {"apple", 3},
12
        {"banana", 5},
13
        {"orange", 2}
14
    };
15

16
    // 使用其他容器范围初始化
17
    std::map<std::string, int> ordered_map = {{"carrot", 4}, {"lettuce", 1}};
18
    std::unordered_map<std::string, int> umap_from_map(ordered_map.begin(), ordered_map.end());
19

20
    return 0;
21
}

展开收起

3.2 插入元素#

1
// 方法1：使用下标操作符
2
umap["grape"] = 7;
3

4
// 方法2：使用 insert
5
umap.insert({"melon", 6});
6

7
// 方法3：使用 emplace，直接在容器内部构造元素
8
umap.emplace("kiwi", 4);

3.3 访问元素#

1
// 使用下标操作符访问或插入
2
int apple_count = umap["apple"]; // 如果 "apple" 不存在，会插入一个默认值
3

4
// 使用 at() 方法访问，不存在时会抛出异常
5
try {
6
    int banana_count = umap.at("banana");
7
} catch (const std::out_of_range& e) {
8
    std::cerr << "Key not found." << std::endl;
9
}
10

11
// 使用 find() 方法查找
12
auto it = umap.find("orange");
13
if (it != umap.end()) {
14
    std::cout << "Orange count: " << it->second << std::endl;
15
} else {
16
    std::cout << "Orange not found." << std::endl;
17
}

展开收起

3.4 删除元素#

1
// 根据键删除
2
umap.erase("grape");
3

4
// 根据迭代器删除
5
auto it = umap.find("banana");
6
if (it != umap.end()) {
7
    umap.erase(it);
8
}
9

10
// 清空整个容器
11
umap.clear();

3.5 遍历元素#

1
for (const auto& pair : umap) {
2
    std::cout << pair.first << ": " << pair.second << std::endl;
3
}
4

5
// 使用迭代器
6
for (auto it = umap.begin(); it != umap.end(); ++it) {
7
    std::cout << it->first << ": " << it->second << std::endl;
8
}

3.6 其他常用方法#

1
// 获取大小
2
size_t size = umap.size();
3

4
// 检查是否为空
5
bool is_empty = umap.empty();
6

7
// 获取桶的数量（用于哈希表内部结构）
8
size_t bucket_count = umap.bucket_count();
9

10
// 重新哈希，调整桶的数量
11
umap.rehash(20);
12

13
// 从一个容器中移交元素到另一个容器
14
std::unordered_map<std::string, int> umap2 = std::move(umap);

4. 性能优化#

4.1 预分配桶数#

如果预先知道元素的大致数量，可以通过 reserve 预分配内存，以减少哈希表的重哈希开销：

1
umap.reserve(100); // 预分配足够容纳100个元素的桶

4.2 自定义哈希函数#

如果键的类型是自定义类型或需要特殊的哈希策略，可以自定义哈希函数。例如，自定义结构体作为键：

1
struct Point {
2
    int x;
3
    int y;
4

5
    bool operator==(const Point& other) const {
6
        return x == other.x && y == other.y;
7
    }
8
};
9

10
// 自定义哈希函数
11
struct PointHash {
12
    std::size_t operator()(const Point& p) const {
13
        return std::hash<int>()(p.x) ^ (std::hash<int>()(p.y) << 1);
14
    }
15
};
16

17
// 定义 unordered_map 使用自定义哈希函数
18
std::unordered_map<Point, std::string, PointHash> point_map;
19
point_map[{1, 2}] = "A";
20
point_map[{3, 4}] = "B";

展开收起

4.3 自定义键相等比较#

如果需要自定义键的比较逻辑，可以提供自定义的 KeyEqual 函数对象：

1
struct PointEqual {
2
    bool operator()(const Point& a, const Point& b) const {
3
        return (a.x == b.x) && (a.y == b.y);
4
    }
5
};
6

7
// 定义 unordered_map 使用自定义哈希和比较函数
8
std::unordered_map<Point, std::string, PointHash, PointEqual> point_map;

5. 与 `map` 的比较#

底层实现：unordered_map 基于哈希表，实现的操作平均时间复杂度为常数级别；map 基于红黑树，实现的查找、插入、删除操作时间复杂度为对数级别。
元素顺序：unordered_map 不保证元素的顺序；map 按键的顺序（通常是升序）存储元素。
适用场景：当需要快速查找、插入和删除，且不关心元素顺序时，选择 unordered_map；当需要有序存储或按顺序遍历时，选择 map。

6. 完整示例#

以下是一个使用 unordered_map 的完整示例：

1
#include <iostream>
2
#include <unordered_map>
3
#include <string>
4

5
// 自定义类型
6
struct Person {
7
    std::string name;
8
    int age;
9

10
    bool operator==(const Person& other) const {
11
        return name == other.name && age == other.age;
12
    }
13
};
14

15
// 自定义哈希函数
16
struct PersonHash {
17
    std::size_t operator()(const Person& p) const {
18
        return std::hash<std::string>()(p.name) ^ (std::hash<int>()(p.age) << 1);
19
    }
20
};
21

22
int main() {
23
    // 创建一个 unordered_map，键为 string，值为 int
24
    std::unordered_map<std::string, int> fruit_count;
25
    fruit_count["apple"] = 5;
26
    fruit_count["banana"] = 3;
27
    fruit_count.emplace("orange", 2);
28

29
    // 访问元素
30
    std::cout << "Apple count: " << fruit_count["apple"] << std::endl;
31

32
    // 遍历
33
    for (const auto& pair : fruit_count) {
34
        std::cout << pair.first << ": " << pair.second << std::endl;
35
    }
36

37
    // 使用自定义类型作为键
38
    std::unordered_map<Person, std::string, PersonHash> person_map;
39
    Person p1{"Alice", 30};
40
    Person p2{"Bob", 25};
41
    person_map[p1] = "Engineer";
42
    person_map.emplace(p2, "Designer");
43

44
    // 访问自定义类型键的值
45
    Person p3{"Alice", 30};
46
    std::cout << "Alice's job: " << person_map[p3] << std::endl;
47

48
    return 0;
49
}

展开收起

输出示例：

1
Apple count: 5
2
banana: 3
3
orange: 2
4
apple: 5
5
Alice's job: Engineer

手写unordermap#

1. 哈希表的基本原理#

哈希表是一种基于键值对的数据结构，通过哈希函数（Hash Function）将键映射到表中的一个索引位置，以实现快速的数据访问。哈希表的关键特性包括：

哈希函数：将键映射到表中一个特定的桶（Bucket）或槽（Slot）。
冲突解决：当不同的键通过哈希函数映射到同一个桶时，需要一种机制来处理这些冲突。常见的方法有链地址法（Separate Chaining）和开放地址法（Open Addressing）。
负载因子（Load Factor）：表示表中已存储元素的数量与表大小之间的比率。高负载因子可能导致更多的冲突，需要通过扩容来维持性能。

在本实现中，我们将采用链地址法来处理哈希冲突，即每个桶存储一个链表（或其他动态数据结构）来存储具有相同哈希值的元素。

2. 数据结构设计#

HashNode 结构#

HashNode 用于存储键值对及相关的指针，以构建链表。每个 HashNode 包含键、值和指向下一个节点的指针。

1
#include <vector>
2
#include <list>
3
#include <utility> // For std::pair
4
#include <functional> // For std::hash
5
#include <iterator> // For iterator_traits
6
#include <stdexcept> // For exceptions
7

8
// HashNode 结构定义
9
template <typename Key, typename T>
10
struct HashNode {
11
    std::pair<const Key, T> data;
12
    HashNode* next;
13

14
    HashNode(const Key& key, const T& value)
15
        : data(std::make_pair(key, value)), next(nullptr) {}
16
};

展开收起

MyHashMap 类定义#

MyHashMap 是我们自定义的哈希表实现，支持基本的 Map 操作和迭代器功能。它使用一个向量（std::vector）来存储桶，每个桶是一个链表，用于处理冲突。

1
template <typename Key, typename T, typename Hash = std::hash<Key>>
2
class MyHashMap {
3
public:
4
    // 迭代器类前向声明
5
    class Iterator;
6

7
    // 类型定义
8
    using key_type = Key;
9
    using mapped_type = T;
10
    using value_type = std::pair<const Key, T>;
11
    using size_type = size_t;
12

13
    // 构造函数及析构函数
14
    MyHashMap(size_type initial_capacity = 16, double max_load_factor = 0.75);
15
    ~MyHashMap();
16

17
    // 禁止拷贝构造和赋值
18
    MyHashMap(const MyHashMap&) = delete;
19
    MyHashMap& operator=(const MyHashMap&) = delete;
20

21
    // 基本操作
22
    void insert(const Key& key, const T& value);
23
    T* find(const Key& key);
24
    const T* find(const Key& key) const;
25
    bool erase(const Key& key);
26
    size_type size() const;
27
    bool empty() const;
28
    void clear();
29

30
    // 迭代器操作
31
    Iterator begin();
32
    Iterator end();
33

34
    // 迭代器类
35
    class Iterator {
36
    public:
37
        // 迭代器别名
38
        using iterator_category = std::forward_iterator_tag;
39
        using value_type = std::pair<const Key, T>;
40
        using difference_type = std::ptrdiff_t;
41
        using pointer = value_type*;
42
        using reference = value_type&;
43

44
        // 构造函数
45
        Iterator(MyHashMap* map, size_type bucket_index, HashNode<Key, T>* node);
46

47
        // 解引用操作符
48
        reference operator*() const;
49
        pointer operator->() const;
50

51
        // 递增操作符
52
        Iterator& operator++();
53
        Iterator operator++(int);
54

55
        // 比较操作符
56
        bool operator==(const Iterator& other) const;
57
        bool operator!=(const Iterator& other) const;
58

59
    private:
60
        MyHashMap* map_;
61
        size_type bucket_index_;
62
        HashNode<Key, T>* current_node_;
63

64
        // 移动到下一个有效节点
65
        void advance();
66
    };
67

68
private:
69
    std::vector<HashNode<Key, T>*> buckets_;
70
    size_type bucket_count_;
71
    size_type element_count_;
72
    double max_load_factor_;
73
    Hash hash_func_;
74

75
    // 辅助函数
76
    void rehash();
77
};

展开收起

3. 基本操作实现#

构造函数及析构函数#

初始化哈希表，设置初始容量和负载因子。

1
// 构造函数
2
template <typename Key, typename T, typename Hash>
3
MyHashMap<Key, T, Hash>::MyHashMap(size_type initial_capacity, double max_load_factor)
4
    : bucket_count_(initial_capacity),
5
      element_count_(0),
6
      max_load_factor_(max_load_factor),
7
      hash_func_(Hash()) {
8
    buckets_.resize(bucket_count_, nullptr);
9
}
10

11
// 析构函数
12
template <typename Key, typename T, typename Hash>
13
MyHashMap<Key, T, Hash>::~MyHashMap() {
14
    clear();
15
}

展开收起

插入（Insert）#

向哈希表中插入键值对。如果键已存在，则更新其值。

1
template <typename Key, typename T, typename Hash>
2
void MyHashMap<Key, T, Hash>::insert(const Key& key, const T& value) {
3
    size_type hash_value = hash_func_(key);
4
    size_type index = hash_value % bucket_count_;
5

6
    HashNode<Key, T>* node = buckets_[index];
7
    while (node != nullptr) {
8
        if (node->data.first == key) {
9
            node->data.second = value; // 更新值
10
            return;
11
        }
12
        node = node->next;
13
    }
14

15
    // 键不存在，插入新节点到链表头部
16
    HashNode<Key, T>* new_node = new HashNode<Key, T>(key, value);
17
    new_node->next = buckets_[index];
18
    buckets_[index] = new_node;
19
    ++element_count_;
20

21
    // 检查负载因子，可能需要扩容
22
    double load_factor = static_cast<double>(element_count_) / bucket_count_;
23
    if (load_factor > max_load_factor_) {
24
        rehash();
25
    }
26
}

展开收起

查找（Find）#

根据键查找对应的值，返回指向值的指针。如果未找到，则返回 nullptr。

1
template <typename Key, typename T, typename Hash>
2
T* MyHashMap<Key, T, Hash>::find(const Key& key) {
3
    size_type hash_value = hash_func_(key);
4
    size_type index = hash_value % bucket_count_;
5

6
    HashNode<Key, T>* node = buckets_[index];
7
    while (node != nullptr) {
8
        if (node->data.first == key) {
9
            return &(node->data.second);
10
        }
11
        node = node->next;
12
    }
13
    return nullptr;
14
}
15

16
template <typename Key, typename T, typename Hash>
17
const T* MyHashMap<Key, T, Hash>::find(const Key& key) const {
18
    size_type hash_value = hash_func_(key);
19
    size_type index = hash_value % bucket_count_;
20

21
    HashNode<Key, T>* node = buckets_[index];
22
    while (node != nullptr) {
23
        if (node->data.first == key) {
24
            return &(node->data.second);
25
        }
26
        node = node->next;
27
    }
28
    return nullptr;
29
}

展开收起

删除（Erase）#

根据键删除对应的键值对，返回删除是否成功。

1
template <typename Key, typename T, typename Hash>
2
bool MyHashMap<Key, T, Hash>::erase(const Key& key) {
3
    size_type hash_value = hash_func_(key);
4
    size_type index = hash_value % bucket_count_;
5

6
    HashNode<Key, T>* node = buckets_[index];
7
    HashNode<Key, T>* prev = nullptr;
8

9
    while (node != nullptr) {
10
        if (node->data.first == key) {
11
            if (prev == nullptr) {
12
                buckets_[index] = node->next;
13
            } else {
14
                prev->next = node->next;
15
            }
16
            delete node;
17
            --element_count_;
18
            return true;
19
        }
20
        prev = node;
21
        node = node->next;
22
    }
23
    return false; // 未找到键
24
}

展开收起

清空（Clear）#

删除哈希表中的所有元素，释放内存。

1
template <typename Key, typename T, typename Hash>
2
void MyHashMap<Key, T, Hash>::clear() {
3
    for (size_type i = 0; i < bucket_count_; ++i) {
4
        HashNode<Key, T>* node = buckets_[i];
5
        while (node != nullptr) {
6
            HashNode<Key, T>* temp = node;
7
            node = node->next;
8
            delete temp;
9
        }
10
        buckets_[i] = nullptr;
11
    }
12
    element_count_ = 0;
13
}

动态扩容（Rehashing）#

当负载因子超过阈值时，扩展哈希表容量并重新分配所有元素。

1
template <typename Key, typename T, typename Hash>
2
void MyHashMap<Key, T, Hash>::rehash() {
3
    size_type new_bucket_count = bucket_count_ * 2;
4
    std::vector<HashNode<Key, T>*> new_buckets(new_bucket_count, nullptr);
5

6
    // 重新分配所有元素
7
    for (size_type i = 0; i < bucket_count_; ++i) {
8
        HashNode<Key, T>* node = buckets_[i];
9
        while (node != nullptr) {
10
            HashNode<Key, T>* next_node = node->next;
11
            size_type new_index = hash_func_(node->data.first) % new_bucket_count;
12

13
            // 插入到新桶的头部
14
            node->next = new_buckets[new_index];
15
            new_buckets[new_index] = node;
16

17
            node = next_node;
18
        }
19
    }
20

21
    // 替换旧桶
22
    buckets_ = std::move(new_buckets);
23
    bucket_count_ = new_bucket_count;
24
}

展开收起

获取大小和状态#

1
template <typename Key, typename T, typename Hash>
2
typename MyHashMap<Key, T, Hash>::size_type MyHashMap<Key, T, Hash>::size() const {
3
    return element_count_;
4
}
5

6
template <typename Key, typename T, typename Hash>
7
bool MyHashMap<Key, T, Hash>::empty() const {
8
    return element_count_ == 0;
9
}

4. 迭代器的实现#

为了支持迭代器操作，使 MyHashMap 能够像标准容器一样被遍历，我们需要实现一个内部的 Iterator 类。

Iterator 类定义#

Iterator 类需要跟踪当前桶的索引和当前节点指针。它还需要能够找到下一个有效的节点。

1
// Iterator 构造函数
2
template <typename Key, typename T, typename Hash>
3
MyHashMap<Key, T, Hash>::Iterator::Iterator(MyHashMap* map, size_type bucket_index, HashNode<Key, T>* node)
4
    : map_(map), bucket_index_(bucket_index), current_node_(node) {}
5

6
// 解引用操作符
7
template <typename Key, typename T, typename Hash>
8
typename MyHashMap<Key, T, Hash>::Iterator::reference
9
MyHashMap<Key, T, Hash>::Iterator::operator*() const {
10
    if (current_node_ == nullptr) {
11
        throw std::out_of_range("Iterator out of range");
12
    }
13
    return current_node_->data;
14
}
15

16
// 成员访问操作符
17
template <typename Key, typename T, typename Hash>
18
typename MyHashMap<Key, T, Hash>::Iterator::pointer
19
MyHashMap<Key, T, Hash>::Iterator::operator->() const {
20
    if (current_node_ == nullptr) {
21
        throw std::out_of_range("Iterator out of range");
22
    }
23
    return &(current_node_->data);
24
}
25

26
// 前置递增操作符
27
template <typename Key, typename T, typename Hash>
28
typename MyHashMap<Key, T, Hash>::Iterator&
29
MyHashMap<Key, T, Hash>::Iterator::operator++() {
30
    advance();
31
    return *this;
32
}
33

34
// 后置递增操作符
35
template <typename Key, typename T, typename Hash>
36
typename MyHashMap<Key, T, Hash>::Iterator
37
MyHashMap<Key, T, Hash>::Iterator::operator++(int) {
38
    Iterator temp = *this;
39
    advance();
40
    return temp;
41
}
42

43
// 比较操作符==
44
template <typename Key, typename T, typename Hash>
45
bool MyHashMap<Key, T, Hash>::Iterator::operator==(const Iterator& other) const {
46
    return map_ == other.map_ &&
47
           bucket_index_ == other.bucket_index_ &&
48
           current_node_ == other.current_node_;
49
}
50

51
// 比较操作符!=
52
template <typename Key, typename T, typename Hash>
53
bool MyHashMap<Key, T, Hash>::Iterator::operator!=(const Iterator& other) const {
54
    return !(*this == other);
55
}
56

57
// advance 函数：移动到下一个有效节点
58
template <typename Key, typename T, typename Hash>
59
void MyHashMap<Key, T, Hash>::Iterator::advance() {
60
    if (current_node_ != nullptr) {
61
        current_node_ = current_node_->next;
62
    }
63

64
    while (current_node_ == nullptr && bucket_index_ + 1 < map_->bucket_count_) {
65
        ++bucket_index_;
66
        current_node_ = map_->buckets_[bucket_index_];
67
    }
68
}

展开收起

迭代器操作#

在 MyHashMap 类中实现 begin() 和 end() 函数来返回迭代器。

1
// begin() 函数
2
template <typename Key, typename T, typename Hash>
3
typename MyHashMap<Key, T, Hash>::Iterator
4
MyHashMap<Key, T, Hash>::begin() {
5
    for (size_type i = 0; i < bucket_count_; ++i) {
6
        if (buckets_[i] != nullptr) {
7
            return Iterator(this, i, buckets_[i]);
8
        }
9
    }
10
    return end();
11
}
12

13
// end() 函数
14
template <typename Key, typename T, typename Hash>
15
typename MyHashMap<Key, T, Hash>::Iterator
16
MyHashMap<Key, T, Hash>::end() {
17
    return Iterator(this, bucket_count_, nullptr);
18
}

展开收起

5. 完整代码示例#

以下是完整的 MyHashMap 实现，包括所有上述内容：

1
#include <vector>
2
#include <list>
3
#include <utility> // For std::pair
4
#include <functional> // For std::hash
5
#include <iterator> // For iterator_traits
6
#include <stdexcept> // For exceptions
7
#include <iostream>
8

9
// HashNode 结构定义
10
template <typename Key, typename T>
11
struct HashNode {
12
    std::pair<const Key, T> data;
13
    HashNode* next;
14

15
    HashNode(const Key& key, const T& value)
16
        : data(std::make_pair(key, value)), next(nullptr) {}
17
};
18

19
// MyHashMap 类定义
20
template <typename Key, typename T, typename Hash = std::hash<Key>>
21
class MyHashMap {
22
public:
23
    // 迭代器类前向声明
24
    class Iterator;
25

26
    // 类型定义
27
    using key_type = Key;
28
    using mapped_type = T;
29
    using value_type = std::pair<const Key, T>;
30
    using size_type = size_t;
31

32
    // 构造函数及析构函数
33
    MyHashMap(size_type initial_capacity = 16, double max_load_factor = 0.75);
34
    ~MyHashMap();
35

36
    // 禁止拷贝构造和赋值
37
    MyHashMap(const MyHashMap&) = delete;
38
    MyHashMap& operator=(const MyHashMap&) = delete;
39

40
    // 基本操作
41
    void insert(const Key& key, const T& value);
42
    T* find(const Key& key);
43
    const T* find(const Key& key) const;
44
    bool erase(const Key& key);
45
    size_type size() const;
46
    bool empty() const;
47
    void clear();
48

49
    // 迭代器操作
50
    Iterator begin();
51
    Iterator end();
52

53
    // 迭代器类
54
    class Iterator {
55
    public:
56
        // 迭代器别名
57
        using iterator_category = std::forward_iterator_tag;
58
        using value_type = std::pair<Key, T>;
59
        using difference_type = std::ptrdiff_t;
60
        using pointer = value_type*;
61
        using reference = value_type&;
62

63
        // 构造函数
64
        Iterator(MyHashMap* map, size_type bucket_index, HashNode<Key, T>* node);
65

66
        // 解引用操作符
67
        reference operator*() const;
68
        pointer operator->() const;
69

70
        // 递增操作符
71
        Iterator& operator++();
72
        Iterator operator++(int);
73

74
        // 比较操作符
75
        bool operator==(const Iterator& other) const;
76
        bool operator!=(const Iterator& other) const;
77

78
    private:
79
        MyHashMap* map_;
80
        size_type bucket_index_;
81
        HashNode<Key, T>* current_node_;
82

83
        // 移动到下一个有效节点
84
        void advance();
85
    };
86

87
private:
88
    std::vector<HashNode<Key, T>*> buckets_;
89
    size_type bucket_count_;
90
    size_type element_count_;
91
    double max_load_factor_;
92
    Hash hash_func_;
93

94
    // 辅助函数
95
    void rehash();
96
};
97

98
// 构造函数
99
template <typename Key, typename T, typename Hash>
100
MyHashMap<Key, T, Hash>::MyHashMap(size_type initial_capacity, double max_load_factor)
101
    : bucket_count_(initial_capacity),
102
      element_count_(0),
103
      max_load_factor_(max_load_factor),
104
      hash_func_(Hash()) {
105
    buckets_.resize(bucket_count_, nullptr);
106
}
107

108
// 析构函数
109
template <typename Key, typename T, typename Hash>
110
MyHashMap<Key, T, Hash>::~MyHashMap() {
111
    clear();
112
}
113

114
// 插入函数
115
template <typename Key, typename T, typename Hash>
116
void MyHashMap<Key, T, Hash>::insert(const Key& key, const T& value) {
117
    size_type hash_value = hash_func_(key);
118
    size_type index = hash_value % bucket_count_;
119

120
    HashNode<Key, T>* node = buckets_[index];
121
    while (node != nullptr) {
122
        if (node->data.first == key) {
123
            node->data.second = value; // 更新值
124
            return;
125
        }
126
        node = node->next;
127
    }
128

129
    // 键不存在，插入新节点到链表头部
130
    HashNode<Key, T>* new_node = new HashNode<Key, T>(key, value);
131
    new_node->next = buckets_[index];
132
    buckets_[index] = new_node;
133
    ++element_count_;
134

135
    // 检查负载因子，可能需要扩容
136
    double load_factor = static_cast<double>(element_count_) / bucket_count_;
137
    if (load_factor > max_load_factor_) {
138
        rehash();
139
    }
140
}
141

142
// 查找函数（非常量版本）
143
template <typename Key, typename T, typename Hash>
144
T* MyHashMap<Key, T, Hash>::find(const Key& key) {
145
    size_type hash_value = hash_func_(key);
146
    size_type index = hash_value % bucket_count_;
147

148
    HashNode<Key, T>* node = buckets_[index];
149
    while (node != nullptr) {
150
        if (node->data.first == key) {
151
            return &(node->data.second);
152
        }
153
        node = node->next;
154
    }
155
    return nullptr;
156
}
157

158
// 查找函数（常量版本）
159
template <typename Key, typename T, typename Hash>
160
const T* MyHashMap<Key, T, Hash>::find(const Key& key) const {
161
    size_type hash_value = hash_func_(key);
162
    size_type index = hash_value % bucket_count_;
163

164
    HashNode<Key, T>* node = buckets_[index];
165
    while (node != nullptr) {
166
        if (node->data.first == key) {
167
            return &(node->data.second);
168
        }
169
        node = node->next;
170
    }
171
    return nullptr;
172
}
173

174
// 删除函数
175
template <typename Key, typename T, typename Hash>
176
bool MyHashMap<Key, T, Hash>::erase(const Key& key) {
177
    size_type hash_value = hash_func_(key);
178
    size_type index = hash_value % bucket_count_;
179

180
    HashNode<Key, T>* node = buckets_[index];
181
    HashNode<Key, T>* prev = nullptr;
182

183
    while (node != nullptr) {
184
        if (node->data.first == key) {
185
            if (prev == nullptr) {
186
                buckets_[index] = node->next;
187
            } else {
188
                prev->next = node->next;
189
            }
190
            delete node;
191
            --element_count_;
192
            return true;
193
        }
194
        prev = node;
195
        node = node->next;
196
    }
197
    return false; // 未找到键
198
}
199

200
// 清空函数
201
template <typename Key, typename T, typename Hash>
202
void MyHashMap<Key, T, Hash>::clear() {
203
    for (size_type i = 0; i < bucket_count_; ++i) {
204
        HashNode<Key, T>* node = buckets_[i];
205
        while (node != nullptr) {
206
            HashNode<Key, T>* temp = node;
207
            node = node->next;
208
            delete temp;
209
        }
210
        buckets_[i] = nullptr;
211
    }
212
    element_count_ = 0;
213
}
214

215
// 动态扩容函数
216
template <typename Key, typename T, typename Hash>
217
void MyHashMap<Key, T, Hash>::rehash() {
218
    size_type new_bucket_count = bucket_count_ * 2;
219
    std::vector<HashNode<Key, T>*> new_buckets(new_bucket_count, nullptr);
220

221
    // 重新分配所有元素
222
    for (size_type i = 0; i < bucket_count_; ++i) {
223
        HashNode<Key, T>* node = buckets_[i];
224
        while (node != nullptr) {
225
            HashNode<Key, T>* next_node = node->next;
226
            size_type new_index = hash_func_(node->data.first) % new_bucket_count;
227

228
            // 插入到新桶的头部
229
            node->next = new_buckets[new_index];
230
            new_buckets[new_index] = node;
231

232
            node = next_node;
233
        }
234
    }
235

236
    // 替换旧桶
237
    buckets_ = std::move(new_buckets);
238
    bucket_count_ = new_bucket_count;
239
}
240

241
// begin() 函数
242
template <typename Key, typename T, typename Hash>
243
typename MyHashMap<Key, T, Hash>::Iterator
244
MyHashMap<Key, T, Hash>::begin() {
245
    for (size_type i = 0; i < bucket_count_; ++i) {
246
        if (buckets_[i] != nullptr) {
247
            return Iterator(this, i, buckets_[i]);
248
        }
249
    }
250
    return end();
251
}
252

253
// end() 函数
254
template <typename Key, typename T, typename Hash>
255
typename MyHashMap<Key, T, Hash>::Iterator
256
MyHashMap<Key, T, Hash>::end() {
257
    return Iterator(this, bucket_count_, nullptr);
258
}
259

260
// Iterator 构造函数
261
template <typename Key, typename T, typename Hash>
262
MyHashMap<Key, T, Hash>::Iterator::Iterator(MyHashMap* map, size_type bucket_index, HashNode<Key, T>* node)
263
    : map_(map), bucket_index_(bucket_index), current_node_(node) {}
264

265
// 解引用操作符
266
template <typename Key, typename T, typename Hash>
267
typename MyHashMap<Key, T, Hash>::Iterator::reference
268
MyHashMap<Key, T, Hash>::Iterator::operator*() const {
269
    if (current_node_ == nullptr) {
270
        throw std::out_of_range("Iterator out of range");
271
    }
272
    return current_node_->data;
273
}
274

275
// 成员访问操作符
276
template <typename Key, typename T, typename Hash>
277
typename MyHashMap<Key, T, Hash>::Iterator::pointer
278
MyHashMap<Key, T, Hash>::Iterator::operator->() const {
279
    if (current_node_ == nullptr) {
280
        throw std::out_of_range("Iterator out of range");
281
    }
282
    return &(current_node_->data);
283
}
284

285
// 前置递增操作符
286
template <typename Key, typename T, typename Hash>
287
typename MyHashMap<Key, T, Hash>::Iterator&
288
MyHashMap<Key, T, Hash>::Iterator::operator++() {
289
    advance();
290
    return *this;
291
}
292

293
// 后置递增操作符
294
template <typename Key, typename T, typename Hash>
295
typename MyHashMap<Key, T, Hash>::Iterator
296
MyHashMap<Key, T, Hash>::Iterator::operator++(int) {
297
    Iterator temp = *this;
298
    advance();
299
    return temp;
300
}
301

302
// 比较操作符==
303
template <typename Key, typename T, typename Hash>
304
bool MyHashMap<Key, T, Hash>::Iterator::operator==(const Iterator& other) const {
305
    return map_ == other.map_ &&
306
           bucket_index_ == other.bucket_index_ &&
307
           current_node_ == other.current_node_;
308
}
309

310
// 比较操作符!=
311
template <typename Key, typename T, typename Hash>
312
bool MyHashMap<Key, T, Hash>::Iterator::operator!=(const Iterator& other) const {
313
    return !(*this == other);
314
}
315

316
// advance 函数：移动到下一个有效节点
317
template <typename Key, typename T, typename Hash>
318
void MyHashMap<Key, T, Hash>::Iterator::advance() {
319
   if(current_node_ != nullptr){
320
         current_node_ = current_node_->next;
321
    }
322
   while(current_node_ == nullptr){
323
        if(bucket_index_ +1  < map_->bucket_count_){
324
                   ++bucket_index_;
325
                   current_node_ = map_->buckets_[bucket_index_];
326
          }else if(bucket_index_ +1  == map_->bucket_count_){
327
                   ++bucket_index_;
328
                   break;
329
           }
330
       }
331
}

展开收起

6. 使用示例#

以下是一个使用 MyHashMap 的示例，展示如何插入、查找、删除以及使用迭代器遍历元素。

1
int main() {
2
    MyHashMap<std::string, int> myMap;
3

4
    // 插入元素
5
    myMap.insert("apple", 3);
6
    myMap.insert("banana", 5);
7
    myMap.insert("orange", 2);
8
    myMap.insert("grape", 7);
9
    myMap.insert("cherry", 4);
10

11
    // 使用迭代器遍历元素
12
    std::cout << "Map contents:\n";
13
    for(auto it = myMap.begin(); it != myMap.end(); ++it) {
14
        std::cout << it->first << " => " << it->second << "\n";
15
    }
16

17
    // 查找元素
18
    std::string keyToFind = "banana";
19
    int* value = myMap.find(keyToFind);
20
    if(value != nullptr) {
21
        std::cout << "\nFound " << keyToFind << " with value: " << *value << "\n";
22
    } else {
23
        std::cout << "\n" << keyToFind << " not found.\n";
24
    }
25

26
    // 删除元素
27
    myMap.erase("apple");
28
    myMap.erase("cherry");
29

30
    // 再次遍历
31
    std::cout << "\nAfter erasing apple and cherry:\n";
32
    for(auto it = myMap.begin(); it != myMap.end(); ++it) {
33
        std::cout << it->first << " => " << it->second << "\n";
34
    }
35

36
    return 0;
37
}

展开收起

预期输出#

1
Map contents:
2
cherry => 4
3
banana => 5
4
apple => 3
5
grape => 7
6
orange => 2
7

8
Found banana with value: 5
9

10
After erasing apple and cherry:
11
banana => 5
12
grape => 7
13
orange => 2

注意：由于哈希表的桶顺序依赖于哈希函数的实现，输出顺序可能与预期有所不同。

Hash() 在上述 MyHashMap 实现中是一个哈希函数对象。让我们详细解释一下它的含义以及它在代码中的作用。

`Hash` 是什么？#

在 MyHashMap 的模板定义中，Hash 是一个模板参数，用于指定键类型 Key 的哈希函数。它有一个默认值 std::hash<Key>，这意味着如果用户在实例化 MyHashMap 时没有提供自定义的哈希函数，std::hash<Key> 将被使用。

1
template <typename Key, typename T, typename Hash = std::hash<Key>>
2
class MyHashMap {
3
    // ...
4
};

默认情况下：`std::hash<Key>`#

std::hash 是 C++ 标准库（STL）中提供的一个模板结构，用于为各种内置类型（如 int, std::string 等）生成哈希值。std::hash<Key> 会根据 Key 的类型自动选择合适的哈希函数实现。

例如：

对于 int 类型，std::hash<int> 会生成一个简单的哈希值。
对于 std::string 类型，std::hash<std::string> 会基于字符串内容生成哈希值。

1
std::hash<int> intHasher;
2
size_t hashValue = intHasher(42); // 生成整数 42 的哈希值
3

4
std::hash<std::string> stringHasher;
5
size_t stringHash = stringHasher("hello"); // 生成字符串 "hello" 的哈希值

自定义哈希函数#

除了使用 std::hash，用户还可以自定义哈希函数，以适应特定的需求或优化性能。例如，假设你有一个自定义的键类型 Point：

1
struct Point {
2
    int x;
3
    int y;
4

5
    bool operator==(const Point& other) const {
6
        return x == other.x && y == other.y;
7
    }
8
};

你可以定义一个自定义的哈希函数 PointHasher：

1
struct PointHasher {
2
    size_t operator()(const Point& p) const {
3
        // 简单的哈希组合，实际应用中应选择更好的哈希组合方法
4
        return std::hash<int>()(p.x) ^ (std::hash<int>()(p.y) << 1);
5
    }
6
};

然后，在实例化 MyHashMap 时使用自定义哈希函数：

1
MyHashMap<Point, std::string, PointHasher> pointMap;
2
Point p1{1, 2};
3
pointMap.insert(p1, "Point1");

`Hash()` 在代码中的作用#

在 MyHashMap 的构造函数中，Hash() 用于实例化哈希函数对象，并将其赋值给成员变量 hash_func_：

1
// 构造函数
2
template <typename Key, typename T, typename Hash>
3
MyHashMap<Key, T, Hash>::MyHashMap(size_type initial_capacity, double max_load_factor)
4
    : bucket_count_(initial_capacity),
5
      element_count_(0),
6
      max_load_factor_(max_load_factor),
7
      hash_func_(Hash()) { // 这里的 Hash() 是一个默认构造函数调用
8
    buckets_.resize(bucket_count_, nullptr);
9
}

具体作用：#

实例化哈希函数对象：
- Hash() 会调用 Hash 类型的默认构造函数，创建一个哈希函数对象。
- 如果 Hash 是 std::hash<Key>，那么就创建一个 std::hash<Key> 对象。
存储哈希函数对象：
- 生成的哈希函数对象被存储在成员变量 hash_func_ 中，以便在哈希表的各种操作（如插入、查找、删除）中使用。
支持不同的哈希函数：
- 由于 Hash 是一个模板参数，可以灵活地使用不同的哈希函数，无需修改 MyHashMap 的内部实现。

示例代码解释#

以下是相关部分的简化示例，帮助理解 Hash 和 Hash() 的作用：

1
#include <vector>
2
#include <functional> // For std::hash
3

4
template <typename Key, typename T, typename Hash = std::hash<Key>>
5
class MyHashMap {
6
public:
7
    MyHashMap(size_t initial_capacity = 16, double max_load_factor = 0.75)
8
        : bucket_count_(initial_capacity),
9
          element_count_(0),
10
          max_load_factor_(max_load_factor),
11
          hash_func_(Hash()) { // 实例化哈希函数对象
12
        buckets_.resize(bucket_count_, nullptr);
13
    }
14

15
    void insert(const Key& key, const T& value) {
16
        size_t hash_value = hash_func_(key); // 使用哈希函数对象
17
        size_t index = hash_value % bucket_count_;
18
        // 插入逻辑...
19
    }
20

21
private:
22
    std::vector<HashNode<Key, T>*> buckets_;
23
    size_t bucket_count_;
24
    size_t element_count_;
25
    double max_load_factor_;
26
    Hash hash_func_; // 存储哈希函数对象
27
};

展开收起

总结#

Hash** 是模板参数**，用于指定键类型 Key 的哈希函数。默认情况下，它使用 C++ 标准库中的 std::hash<Key>。
Hash()** 是一个默认构造函数调用**，用于实例化哈希函数对象，并将其存储在 hash_func_ 成员变量中，以便在哈希表操作中使用。
用户可以自定义哈希函数，通过提供自定义的哈希函数对象，实现对特定键类型的优化或满足特殊需求。

map用法及手写map算法

Tue, 26 May 2026 00:00:00 GMT

std::map 用法#

std::map 是 C++ 标准模板库（STL）中的一个关联容器，用于存储键值对（key-value pairs），其中每个键都是唯一的，并且按照特定的顺序（通常是升序）自动排序。std::map 通常基于红黑树实现，提供对元素的高效查找、插入和删除操作。

1. 基本特性#

有序性：std::map 中的元素按照键的顺序自动排序，默认使用 < 运算符进行比较。
唯一键：每个键在 std::map 中必须是唯一的，如果尝试插入重复的键，则插入操作会失败。
关联容器：通过键快速访问对应的值，通常具有对数时间复杂度（O(log n)）。
可变性：可以动态地插入和删除元素。

2. 头文件和命名空间#

要使用 std::map，需要包含头文件 <map> 并使用 std 命名空间：

1
#include <map>
2
#include <iostream>
3
#include <string>
4

5
using namespace std;

3. 声明和初始化#

3.1 声明一个 `std::map`#

1
// 键为 int，值为 std::string 的 map
2
map<int, string> myMap;
3

4
// 键为 std::string，值为 double 的 map
5
map<string, double> priceMap;

3.2 初始化 `std::map`#

可以使用初始化列表或其他方法初始化 map：

1
map<int, string> myMap = {
2
    {1, "Apple"},
3
    {2, "Banana"},
4
    {3, "Cherry"}
5
};

4. 主要操作#

4.1 插入元素#

有几种方法可以向 std::map 中插入元素：

4.1.1 使用 `insert` 函数#

1
myMap.insert(pair<int, string>(4, "Date"));
2
// 或者使用 `make_pair`
3
myMap.insert(make_pair(5, "Elderberry"));
4
// 或者使用初始化列表
5
myMap.insert({6, "Fig"});

4.1.2 使用下标运算符 `[]`#

1
myMap[7] = "Grape";
2
// 如果键 8 不存在，则会插入键 8 并赋值
3
myMap[8] = "Honeydew";

注意：使用 [] 运算符时，如果键不存在，会自动插入该键，并将值初始化为类型的默认值。

4.2 访问元素#

4.2.1 使用下标运算符 `[]`#

1
string fruit = myMap[1]; // 获取键为 1 的值 "Apple"

注意：如果键不存在，[] 会插入该键并返回默认值。

4.2.2 使用 `at` 成员函数#

1
try {
2
    string fruit = myMap.at(2); // 获取键为 2 的值 "Banana"
3
} catch (const out_of_range& e) {
4
    cout << "Key not found." << endl;
5
}

at 函数在键不存在时会抛出 std::out_of_range 异常，适合需要异常处理的场景。

4.2.3 使用 `find` 成员函数#

1
auto it = myMap.find(3);
2
if (it != myMap.end()) {
3
    cout << "Key 3: " << it->second << endl; // 输出 "Cherry"
4
} else {
5
    cout << "Key 3 not found." << endl;
6
}

find 返回一个迭代器，指向找到的元素，若未找到则返回 map::end()。

4.3 删除元素#

4.3.1 使用 `erase` 函数#

1
// 按键删除
2
myMap.erase(2);
3

4
// 按迭代器删除
5
auto it = myMap.find(3);
6
if (it != myMap.end()) {
7
    myMap.erase(it);
8
}
9

10
// 删除区间 [first, last)
11
myMap.erase(myMap.begin(), myMap.find(5));

4.3.2 使用 `clear` 函数#

1
myMap.clear(); // 删除所有元素

4.4 遍历 `std::map`#

4.4.1 使用迭代器#

1
for (map<int, string>::iterator it = myMap.begin(); it != myMap.end(); ++it) {
2
    cout << "Key: " << it->first << ", Value: " << it->second << endl;
3
}

4.4.2 使用基于范围的 `for` 循环（C++11 及以上）#

1
for (const auto& pair : myMap) {
2
    cout << "Key: " << pair.first << ", Value: " << pair.second << endl;
3
}

4.5 常用成员函数#

size()：返回容器中元素的数量。
empty()：判断容器是否为空。
count(key)：返回具有指定键的元素数量（对于 map，返回 0 或 1）。
lower_bound(key) 和 upper_bound(key)：返回迭代器，分别指向第一个不小于和第一个大于指定键的元素。
equal_range(key)：返回一个范围，包含所有等于指定键的元素。

5. 自定义键的排序#

默认情况下，std::map 使用 < 运算符对键进行排序。如果需要自定义排序方式，可以提供一个自定义的比较函数或函数对象。

5.1 使用函数对象#

1
struct Compare {
2
    bool operator()(const int& a, const int& b) const {
3
        return a > b; // 降序排序
4
    }
5
};
6

7
map<int, string, Compare> myMapDesc;
8
myMapDesc[1] = "Apple";
9
myMapDesc[2] = "Banana";
10
// ...

5.2 使用 lambda 表达式（C++11 及以上）#

需要注意，std::map 的第三个模板参数必须是可比较类型，不能直接使用 lambda 表达式作为模板参数。不过，可以使用 std::function 或自定义结构体来包装 lambda。

1
struct CompareLambda {
2
    bool operator()(const int& a, const int& b) const {
3
        return a > b; // 降序排序
4
    }
5
};
6

7
map<int, string, CompareLambda> myMapDesc;
8
myMapDesc[1] = "Apple";
9
// ...

6. `std::map` 与其他关联容器的比较#

std::unordered_map：基于哈希表实现，提供平均常数时间复杂度的查找、插入和删除操作，但不保证元素的顺序。适用于对顺序无要求且需要高效查找的场景。
std::multimap：允许多个相同键的元素，其他特性与 std::map 类似。适用于需要存储重复键值对的场景。

7. 性能考虑#

时间复杂度：
- 查找、插入、删除：O(log n)
- 遍历：O(n)
空间复杂度：std::map 通常需要额外的空间来维护树结构，相比 std::vector 等序列容器，内存开销更大。

选择使用 std::map 还是其他容器，应根据具体需求和性能要求进行权衡。

8. 完整示例#

以下是一个完整的示例，展示了 std::map 的基本用法：

1
#include <iostream>
2
#include <map>
3
#include <string>
4

5
using namespace std;
6

7
int main() {
8
    // 创建一个 map，键为 int，值为 string
9
    map<int, string> myMap;
10

11
    // 插入元素
12
    myMap[1] = "Apple";
13
    myMap[2] = "Banana";
14
    myMap.insert({3, "Cherry"});
15
    myMap.insert(make_pair(4, "Date"));
16

17
    // 访问元素
18
    cout << "Key 1: " << myMap[1] << endl;
19
    cout << "Key 2: " << myMap.at(2) << endl;
20

21
    // 查找元素
22
    int keyToFind = 3;
23
    auto it = myMap.find(keyToFind);
24
    if (it != myMap.end()) {
25
        cout << "Found key " << keyToFind << ": " << it->second << endl;
26
    } else {
27
        cout << "Key " << keyToFind << " not found." << endl;
28
    }
29

30
    // 遍历 map
31
    cout << "All elements:" << endl;
32
    for (const auto& pair : myMap) {
33
        cout << "Key: " << pair.first << ", Value: " << pair.second << endl;
34
    }
35

36
    // 删除元素
37
    myMap.erase(2);
38
    cout << "After deleting key 2:" << endl;
39
    for (const auto& pair : myMap) {
40
        cout << "Key: " << pair.first << ", Value: " << pair.second << endl;
41
    }
42

43
    // 检查是否为空
44
    if (!myMap.empty()) {
45
        cout << "Map is not empty. Size: " << myMap.size() << endl;
46
    }
47

48
    // 清空所有元素
49
    myMap.clear();
50
    cout << "After clearing, map is " << (myMap.empty() ? "empty." : "not empty.") << endl;
51

52
    return 0;
53
}

展开收起

输出：

1
Key 1: Apple
2
Key 2: Banana
3
Found key 3: Cherry
4
All elements:
5
Key: 1, Value: Apple
6
Key: 2, Value: Banana
7
Key: 3, Value: Cherry
8
Key: 4, Value: Date
9
After deleting key 2:
10
Key: 1, Value: Apple
11
Key: 3, Value: Cherry
12
Key: 4, Value: Date
13
Map is not empty. Size: 3
14
After clearing, map is empty.

BST实现map#

1. 选择底层数据结构#

std::map 通常基于平衡的二叉搜索树（如红黑树）实现，以保证操作的时间复杂度为 O(log n)。为了简化实现，本文将采用普通的二叉搜索树，即不进行自平衡处理。不过在实际应用中，为了保证性能，建议使用自平衡的树结构（例如红黑树、AVL 树）。

2. 设计数据结构#

2.1 节点结构#

首先，需要定义树的节点结构，每个节点包含键值对以及指向子节点的指针。

1
#include <iostream>
2
#include <stack>
3
#include <utility> // For std::pair
4
#include <exception>
5

6
template <typename Key, typename T>
7
struct TreeNode {
8
    std::pair<Key, T> data;
9
    TreeNode* left;
10
    TreeNode* right;
11
    TreeNode* parent;
12

13
    TreeNode(const Key& key, const T& value, TreeNode* parentNode = nullptr)
14
        : data(std::make_pair(key, value)), left(nullptr), right(nullptr), parent(parentNode) {}
15
};

展开收起

2.2 Map 类的定义#

接下来，定义 MyMap 类，包含根节点和基本操作。

1
template <typename Key, typename T>
2
class MyMap {
3
public:
4
    MyMap() : root(nullptr) {}
5
    ~MyMap() { clear(root); }
6

7
    // 禁止拷贝构造和赋值
8
    MyMap(const MyMap&) = delete;
9
    MyMap& operator=(const MyMap&) = delete;
10

11
    // 插入或更新键值对
12
    void insert(const Key& key, const T& value) {
13
        if (root == nullptr) {
14
            root = new TreeNode<Key, T>(key, value);
15
            return;
16
        }
17

18
        TreeNode<Key, T>* current = root;
19
        TreeNode<Key, T>* parent = nullptr;
20

21
        while (current != nullptr) {
22
            parent = current;
23
            if (key < current->data.first) {
24
                current = current->left;
25
            } else if (key > current->data.first) {
26
                current = current->right;
27
            } else {
28
                // 键已存在，更新值
29
                current->data.second = value;
30
                return;
31
            }
32
        }
33

34
        if (key < parent->data.first) {
35
            parent->left = new TreeNode<Key, T>(key, value, parent);
36
        } else {
37
            parent->right = new TreeNode<Key, T>(key, value, parent);
38
        }
39
    }
40

41
    // 查找元素，返回指向节点的指针
42
    TreeNode<Key, T>* find(const Key& key) const {
43
        TreeNode<Key, T>* current = root;
44
        while (current != nullptr) {
45
            if (key < current->data.first) {
46
                current = current->left;
47
            } else if (key > current->data.first) {
48
                current = current->right;
49
            } else {
50
                return current;
51
            }
52
        }
53
        return nullptr;
54
    }
55

56
    // 删除元素
57
    void erase(const Key& key) {
58
        TreeNode<Key, T>* node = find(key);
59
        if (node == nullptr) return; // 没有找到要删除的节点
60

61
        // 节点有两个子节点
62
        if (node->left != nullptr && node->right != nullptr) {
63
            // 找到中序后继
64
            TreeNode<Key, T>* successor = minimum(node->right);
65
            node->data = successor->data; // 替换数据
66
            node = successor; // 将要删除的节点指向后继节点
67
        }
68

69
        // 节点有一个或没有子节点
70
        TreeNode<Key, T>* child = (node->left) ? node->left : node->right;
71
        if (child != nullptr) {
72
            child->parent = node->parent;
73
        }
74

75
        if (node->parent == nullptr) {
76
            root = child;
77
        } else if (node == node->parent->left) {
78
            node->parent->left = child;
79
        } else {
80
            node->parent->right = child;
81
        }
82

83
        delete node;
84
    }
85

86
    // 清空所有节点
87
    void clear() {
88
        clear(root);
89
        root = nullptr;
90
    }
91

92
    // 获取迭代器
93
    class Iterator {
94
    public:
95
        Iterator(TreeNode<Key, T>* node = nullptr) : current(node) {}
96

97
        std::pair<const Key, T>& operator*() const {
98
            return current->data;
99
        }
100

101
        std::pair<const Key, T>* operator->() const {
102
            return &(current->data);
103
        }
104

105
        // 前置递增
106
        Iterator& operator++() {
107
            current = successor(current);
108
            return *this;
109
        }
110

111
        // 后置递增
112
        Iterator operator++(int) {
113
            Iterator temp = *this;
114
            current = successor(current);
115
            return temp;
116
        }
117

118
        bool operator==(const Iterator& other) const {
119
            return current == other.current;
120
        }
121

122
        bool operator!=(const Iterator& other) const {
123
            return current != other.current;
124
        }
125

126
    private:
127
        TreeNode<Key, T>* current;
128

129
        TreeNode<Key, T>* minimum(TreeNode<Key, T>* node) const {
130
            while (node->left != nullptr) {
131
                node = node->left;
132
            }
133
            return node;
134
        }
135

136
        TreeNode<Key, T>* successor(TreeNode<Key, T>* node) const {
137
            if (node->right != nullptr) {
138
                return minimum(node->right);
139
            }
140

141
            TreeNode<Key, T>* p = node->parent;
142
            while (p != nullptr && node == p->right) {
143
                node = p;
144
                p = p->parent;
145
            }
146
            return p;
147
        }
148
    };
149

150
    Iterator begin() const {
151
        return Iterator(minimum(root));
152
    }
153

154
    Iterator end() const {
155
        return Iterator(nullptr);
156
    }
157

158
private:
159
    TreeNode<Key, T>* root;
160

161
    // 删除树中的所有节点
162
    void clear(TreeNode<Key, T>* node) {
163
        if (node == nullptr) return;
164
        clear(node->left);
165
        clear(node->right);
166
        delete node;
167
    }
168

169
    // 找到最小的节点
170
    TreeNode<Key, T>* minimum(TreeNode<Key, T>* node) const {
171
        if (node == nullptr) return nullptr;
172
        while (node->left != nullptr) {
173
            node = node->left;
174
        }
175
        return node;
176
    }
177

178
    // 找到最大的节点
179
    TreeNode<Key, T>* maximum(TreeNode<Key, T>* node) const {
180
        if (node == nullptr) return nullptr;
181
        while (node->right != nullptr) {
182
            node = node->right;
183
        }
184
        return node;
185
    }
186
};

展开收起

2.3 解释#

TreeNode 结构：
- data: 存储键值对 std::pair<Key, T>。
- left 和 right: 指向左子节点和右子节点。
- parent: 指向父节点，便于迭代器中查找后继节点。
MyMap 类：
- 构造与析构：
  - 构造函数初始化根节点为空。
  - 析构函数调用 clear 释放所有节点内存。
- 插入 (insert)：
  - 从根节点开始，根据键的大小确定插入左子树还是右子树。
  - 如果键已存在，更新对应的值。
- 查找 (find)：
  - 按照键的大小在树中查找对应的节点。
- 删除 (erase)：
  - 查找到目标节点。
  - 如果节点有两个子节点，找到中序后继节点并替换当前节点的数据，然后删除后继节点。
  - 如果节点有一个或没有子节点，直接替换节点指针并删除节点。
- 清空 (clear)：
  - 使用递归方式删除所有节点。
- 迭代器：
  - 定义了嵌套的 Iterator 类，支持前置和后置递增操作。
  - 迭代器通过中序遍历实现，保证键的顺序性。
  - begin() 返回最小的节点，end() 返回 nullptr。

3. 使用示例#

下面提供一个使用 MyMap 的示例，展示插入、查找、删除和迭代操作。

1
int main() {
2
    MyMap<std::string, int> myMap;
3

4
    // 插入元素
5
    myMap.insert("apple", 3);
6
    myMap.insert("banana", 5);
7
    myMap.insert("orange", 2);
8
    myMap.insert("grape", 7);
9
    myMap.insert("cherry", 4);
10

11
    // 使用迭代器遍历元素（按键的字母顺序）
12
    std::cout << "Map contents (in-order):\n";
13
    for(auto it = myMap.begin(); it != myMap.end(); ++it) {
14
        std::cout << it->first << " => " << it->second << "\n";
15
    }
16

17
    // 查找元素
18
    std::string keyToFind = "banana";
19
    auto node = myMap.find(keyToFind);
20
    if(node != nullptr) {
21
        std::cout << "\nFound " << keyToFind << " with value: " << node->data.second << "\n";
22
    } else {
23
        std::cout << "\n" << keyToFind << " not found.\n";
24
    }
25

26
    // 删除元素
27
    myMap.erase("apple");
28
    myMap.erase("cherry");
29

30
    // 再次遍历
31
    std::cout << "\nAfter erasing apple and cherry:\n";
32
    for(auto it = myMap.begin(); it != myMap.end(); ++it) {
33
        std::cout << it->first << " => " << it->second << "\n";
34
    }
35

36
    return 0;
37
}

展开收起

输出结果#

1
Map contents (in-order):
2
apple => 3
3
banana => 5
4
cherry => 4
5
grape => 7
6
orange => 2
7

8
Found banana with value: 5
9

10
After erasing apple and cherry:
11
banana => 5
12
grape => 7
13
orange => 2

4. 迭代器的详细实现#

为了支持迭代器的正常使用，Iterator 类实现了以下功能：

解引用操作符 (operator\*** 和 operator->)**：
- 允许访问键值对，如 it->first 和 it->second。
递增操作符 (operator++)：
- 前置递增（++it）和后置递增（it++）用于移动到下一个元素。
- 通过查找当前节点的中序后继节点实现。
比较操作符 (operator==** 和 operator!=)**：
- 判断两个迭代器是否指向同一个节点。

中序后继节点的查找#

迭代器使用中序遍历来确保键的有序性。计算后继节点的步骤如下：

当前节点有右子树：
- 后继节点是右子树中的最小节点。
当前节点没有右子树：
- 向上查找，直到找到一个节点是其父节点的左子树，此时父节点即为后继节点。

如果没有后继节点（即当前节点是最大的节点），则返回 nullptr，表示迭代器到达 end()。

5. 扩展功能#

上述实现是一个基本的 Map，还可以根据需要扩展更多功能，例如：

支持 const 迭代器：
- 定义 const_iterator，确保在只读操作时数据不被修改。
实现平衡树：
- 为了提高性能，可以实现红黑树、AVL 树等自平衡二叉搜索树，保证操作的时间复杂度为 O(log n)。
添加更多成员函数：
- 如 operator[]、count、lower_bound、upper_bound 等，增加容器的功能性。
异常处理：
- 增加对异常情况的处理，例如在删除不存在的键时抛出异常等。
迭代器的逆向遍历：
- 实现双向迭代器，支持逆序遍历（rbegin() 和 rend()）。

AVL树#

AVL树（Adelson-Velsky and Landis树）是一种自平衡的二叉搜索树（BST），它在插入和删除操作后通过旋转来保持树的平衡，从而确保基本操作（如查找、插入和删除）的时间复杂度保持在O(log n)。使用AVL树来实现map（键值对映射）是一个高效的选择，特别适合需要频繁查找、插入和删除操作的场景。

1. 模板化AVL树节点#

首先，我们需要将AVLNode结构模板化，使其能够处理不同类型的键和值。我们假设键类型KeyType支持operator<进行比较，因为AVL树需要对键进行排序以维护其性质。

首先，我们定义AVL树的节点。每个节点包含一个键（key）、一个值（value）、节点高度（height），以及指向左子节点和右子节点的指针。

1
#include <iostream>
2
#include <string>
3
#include <vector>
4
#include <algorithm> // 用于 std::max
5
#include <functional> // 用于 std::function
6

7
// 模板化的AVL树节点结构
8
template <typename KeyType, typename ValueType>
9
struct AVLNode {
10
    KeyType key;
11
    ValueType value;
12
    int height;
13
    AVLNode* left;
14
    AVLNode* right;
15

16
    AVLNode(const KeyType& k, const ValueType& val)
17
        : key(k), value(val), height(1), left(nullptr), right(nullptr) {}
18
};

展开收起

说明：

KeyType：键的类型，需要支持比较操作（如 operator<）。

ValueType：值的类型，可以是任何类型。

2. 辅助函数的模板化#

辅助函数同样需要模板化，以适应不同的AVLNode类型。

获取节点高度#

获取节点的高度。如果节点为空，则高度为0。

1
template <typename KeyType, typename ValueType>
2
int getHeight(AVLNode<KeyType, ValueType>* node) {
3
    if (node == nullptr)
4
        return 0;
5
    return node->height;
6
}

获取平衡因子#

平衡因子（Balance Factor）是左子树高度减去右子树高度。

1
template <typename KeyType, typename ValueType>
2
int getBalance(AVLNode<KeyType, ValueType>* node) {
3
    if (node == nullptr)
4
        return 0;
5
    return getHeight(node->left) - getHeight(node->right);
6
}

右旋转#

右旋转用于处理左子树过高的情况（例如，左左情况）。

1
    y                             x
2
   / \                           / \
3
  x   T3            ==>          z   y
4
 / \                               / \
5
z   T2                            T2  T3

实现

1
template <typename KeyType, typename ValueType>
2
AVLNode<KeyType, ValueType>* rightRotate(AVLNode<KeyType, ValueType>* y) {
3
    AVLNode<KeyType, ValueType>* x = y->left;
4
    AVLNode<KeyType, ValueType>* T2 = x->right;
5

6
    // 执行旋转
7
    x->right = y;
8
    y->left = T2;
9

10
    // 更新高度
11
    y->height = std::max(getHeight(y->left), getHeight(y->right)) + 1;
12
    x->height = std::max(getHeight(x->left), getHeight(x->right)) + 1;
13

14
    // 返回新的根
15
    return x;
16
}

展开收起

左旋转#

左旋转用于处理右子树过高的情况（例如，右右情况）。

1
    x                             y
2
   / \                           / \
3
  T1  y           ==>            x   z
4
     / \                       / \
5
    T2  z                     T1  T2

具体实现

1
template <typename KeyType, typename ValueType>
2
AVLNode<KeyType, ValueType>* leftRotate(AVLNode<KeyType, ValueType>* x) {
3
    AVLNode<KeyType, ValueType>* y = x->right;
4
    AVLNode<KeyType, ValueType>* T2 = y->left;
5

6
    // 执行旋转
7
    y->left = x;
8
    x->right = T2;
9

10
    // 更新高度
11
    x->height = std::max(getHeight(x->left), getHeight(x->right)) + 1;
12
    y->height = std::max(getHeight(y->left), getHeight(y->right)) + 1;
13

14
    // 返回新的根
15
    return y;
16
}

展开收起

3. AVL树的核心操作模板化#

插入节点#

插入操作遵循标准的二叉搜索树插入方式，然后通过旋转保持树的平衡。

1
template <typename KeyType, typename ValueType>
2
AVLNode<KeyType, ValueType>* insertNode(AVLNode<KeyType, ValueType>* node, const KeyType& key, const ValueType& value) {
3
    // 1. 执行标准的BST插入
4
    if (node == nullptr)
5
        return new AVLNode<KeyType, ValueType>(key, value);
6

7
    if (key < node->key)
8
        node->left = insertNode(node->left, key, value);
9
    else if (key > node->key)
10
        node->right = insertNode(node->right, key, value);
11
    else {
12
        // 如果键已经存在，更新其值
13
        node->value = value;
14
        return node;
15
    }
16

17
    // 2. 更新节点高度
18
    node->height = 1 + std::max(getHeight(node->left), getHeight(node->right));
19

20
    // 3. 获取平衡因子
21
    int balance = getBalance(node);
22

23
    // 4. 根据平衡因子进行旋转
24

25
    // 左左情况
26
    if (balance > 1 && key < node->left->key)
27
        return rightRotate(node);
28

29
    // 右右情况
30
    if (balance < -1 && key > node->right->key)
31
        return leftRotate(node);
32

33
    // 左右情况
34
    if (balance > 1 && key > node->left->key) {
35
        node->left = leftRotate(node->left);
36
        return rightRotate(node);
37
    }
38

39
    // 右左情况
40
    if (balance < -1 && key < node->right->key) {
41
        node->right = rightRotate(node->right);
42
        return leftRotate(node);
43
    }
44

45
    return node;
46
}

展开收起

查找节点#

按键查找节点，返回对应的值。如果键不存在，返回nullptr。

1
template <typename KeyType, typename ValueType>
2
ValueType* searchNode(AVLNode<KeyType, ValueType>* node, const KeyType& key) {
3
    if (node == nullptr)
4
        return nullptr;
5

6
    if (key == node->key)
7
        return &(node->value);
8
    else if (key < node->key)
9
        return searchNode(node->left, key);
10
    else
11
        return searchNode(node->right, key);
12
}

获取最小值节点#

用于删除节点时找到中序后继。

1
template <typename KeyType, typename ValueType>
2
AVLNode<KeyType, ValueType>* getMinValueNode(AVLNode<KeyType, ValueType>* node) {
3
    AVLNode<KeyType, ValueType>* current = node;
4
    while (current->left != nullptr)
5
        current = current->left;
6
    return current;
7
}

删除节点#

删除操作分为三种情况：删除节点是叶子节点、有一个子节点或有两个子节点。删除后，通过旋转保持树的平衡。

1
template <typename KeyType, typename ValueType>
2
AVLNode<KeyType, ValueType>* deleteNode(AVLNode<KeyType, ValueType>* root, const KeyType& key) {
3
    // 1. 执行标准的BST删除
4
    if (root == nullptr)
5
        return root;
6

7
    if (key < root->key)
8
        root->left = deleteNode(root->left, key);
9
    else if (key > root->key)
10
        root->right = deleteNode(root->right, key);
11
    else {
12
        // 节点有一个或没有子节点
13
        if ((root->left == nullptr) || (root->right == nullptr)) {
14
            AVLNode<KeyType, ValueType>* temp = root->left ? root->left : root->right;
15

16
            // 没有子节点
17
            if (temp == nullptr) {
18
                temp = root;
19
                root = nullptr;
20
            }
21
            else // 一个子节点
22
                *root = *temp; // 复制内容
23

24
            delete temp;
25
        }
26
        else {
27
            // 节点有两个子节点，获取中序后继
28
            AVLNode<KeyType, ValueType>* temp = getMinValueNode(root->right);
29
            // 复制中序后继的内容到此节点
30
            root->key = temp->key;
31
            root->value = temp->value;
32
            // 删除中序后继
33
            root->right = deleteNode(root->right, temp->key);
34
        }
35
    }
36

37
    // 如果树只有一个节点
38
    if (root == nullptr)
39
        return root;
40

41
    // 2. 更新节点高度
42
    root->height = 1 + std::max(getHeight(root->left), getHeight(root->right));
43

44
    // 3. 获取平衡因子
45
    int balance = getBalance(root);
46

47
    // 4. 根据平衡因子进行旋转
48

49
    // 左左情况
50
    if (balance > 1 && getBalance(root->left) >= 0)
51
        return rightRotate(root);
52

53
    // 左右情况
54
    if (balance > 1 && getBalance(root->left) < 0) {
55
        root->left = leftRotate(root->left);
56
        return rightRotate(root);
57
    }
58

59
    // 右右情况
60
    if (balance < -1 && getBalance(root->right) <= 0)
61
        return leftRotate(root);
62

63
    // 右左情况
64
    if (balance < -1 && getBalance(root->right) > 0) {
65
        root->right = rightRotate(root->right);
66
        return leftRotate(root);
67
    }
68

69
    return root;
70
}

展开收起

4. 模板化的AVLMap类#

现在，我们将所有模板化的函数集成到一个模板类AVLMap中。这个类将提供如下功能：

put(const KeyType& key, const ValueType& value)：插入或更新键值对。
get(const KeyType& key)：查找键对应的值，返回指向值的指针，如果键不存在则返回nullptr。
remove(const KeyType& key)：删除指定键的键值对。
inorderTraversal()：中序遍历，返回有序的键值对列表。

1
template <typename KeyType, typename ValueType>
2
class AVLMap {
3
private:
4
    AVLNode<KeyType, ValueType>* root;
5

6
    // 中序遍历辅助函数
7
    void inorderHelper(AVLNode<KeyType, ValueType>* node, std::vector<std::pair<KeyType, ValueType>>& res) const {
8
        if (node != nullptr) {
9
            inorderHelper(node->left, res);
10
            res.emplace_back(node->key, node->value);
11
            inorderHelper(node->right, res);
12
        }
13
    }
14

15
public:
16
    AVLMap() : root(nullptr) {}
17

18
    // 插入或更新键值对
19
    void put(const KeyType& key, const ValueType& value) {
20
        root = insertNode(root, key, value);
21
    }
22

23
    // 查找值，返回指向值的指针，如果键不存在则返回nullptr
24
    ValueType* get(const KeyType& key) {
25
        return searchNode(root, key);
26
    }
27

28
    // 删除键值对
29
    void remove(const KeyType& key) {
30
        root = deleteNode(root, key);
31
    }
32

33
    // 中序遍历，返回有序的键值对
34
    std::vector<std::pair<KeyType, ValueType>> inorderTraversal() const {
35
        std::vector<std::pair<KeyType, ValueType>> res;
36
        inorderHelper(root, res);
37
        return res;
38
    }
39

40
    // 析构函数，释放所有节点的内存
41
    ~AVLMap() {
42
        // 使用后序遍历释放节点
43
        std::function<void(AVLNode<KeyType, ValueType>*)> destroy = [&](AVLNode<KeyType, ValueType>* node) {
44
            if (node) {
45
                destroy(node->left);
46
                destroy(node->right);
47
                delete node;
48
            }
49
        };
50
        destroy(root);
51
    }
52
};

展开收起

说明：

模板参数：

KeyType：键的类型，需要支持operator<进行比较。

ValueType：值的类型，可以是任意类型。

内存管理：

析构函数使用后序遍历释放所有动态分配的节点，防止内存泄漏。

异常安全：

当前实现没有处理异常情况。如果需要更高的异常安全性，可以进一步增强代码，例如在插入过程中捕获异常并回滚操作。

5. 使用示例#

下面的示例展示了如何使用模板化的AVLMap类，使用不同类型的键和值。

示例 1：使用`int`作为键，`std::string`作为值#

1
#include <iostream>
2
#include <string>
3
#include <vector>
4

5
// 假设上面的AVLNode结构、辅助函数和AVLMap类已经定义
6

7
int main() {
8
    AVLMap<int, std::string> avlMap;
9

10
    // 插入键值对
11
    avlMap.put(10, "十");
12
    avlMap.put(20, "二十");
13
    avlMap.put(30, "三十");
14
    avlMap.put(40, "四十");
15
    avlMap.put(50, "五十");
16
    avlMap.put(25, "二十五");
17

18
    // 中序遍历
19
    std::vector<std::pair<int, std::string>> traversal = avlMap.inorderTraversal();
20
    std::cout << "中序遍历: ";
21
    for (const auto& pair : traversal) {
22
        std::cout << "(" << pair.first << ", \"" << pair.second << "\") ";
23
    }
24
    std::cout << std::endl;
25

26
    // 查找键
27
    std::string* val = avlMap.get(20);
28
    if (val)
29
        std::cout << "获取键20的值: " << *val << std::endl;
30
    else
31
        std::cout << "键20不存在。" << std::endl;
32

33
    val = avlMap.get(25);
34
    if (val)
35
        std::cout << "获取键25的值: " << *val << std::endl;
36
    else
37
        std::cout << "键25不存在。" << std::endl;
38

39
    val = avlMap.get(60);
40
    if (val)
41
        std::cout << "获取键60的值: " << *val << std::endl;
42
    else
43
        std::cout << "键60不存在。" << std::endl;
44

45
    // 删除键20
46
    avlMap.remove(20);
47
    std::cout << "删除键20后，中序遍历: ";
48
    traversal = avlMap.inorderTraversal();
49
    for (const auto& pair : traversal) {
50
        std::cout << "(" << pair.first << ", \"" << pair.second << "\") ";
51
    }
52
    std::cout << std::endl;
53

54
    return 0;
55
}

展开收起

输出:

Terminal window

1
中序遍历: (10, "十") (20, "二十") (25, "二十五") (30, "三十") (40, "四十") (50, "五十")
2
获取键20的值: 二十
3
获取键25的值: 二十五
4
键60不存在。
5
删除键20后，中序遍历: (10, "十") (25, "二十五") (30, "三十") (40, "四十") (50, "五十")

示例 2：使用`std::string`作为键，`double`作为值#

1
#include <iostream>
2
#include <string>
3
#include <vector>
4

5
// 假设上面的AVLNode结构、辅助函数和AVLMap类已经定义
6

7
int main() {
8
    AVLMap<std::string, double> avlMap;
9

10
    // 插入键值对
11
    avlMap.put("apple", 1.99);
12
    avlMap.put("banana", 0.99);
13
    avlMap.put("cherry", 2.99);
14
    avlMap.put("date", 3.49);
15
    avlMap.put("elderberry", 5.99);
16
    avlMap.put("fig", 2.49);
17

18
    // 中序遍历
19
    std::vector<std::pair<std::string, double>> traversal = avlMap.inorderTraversal();
20
    std::cout << "中序遍历: ";
21
    for (const auto& pair : traversal) {
22
        std::cout << "(\"" << pair.first << "\", " << pair.second << ") ";
23
    }
24
    std::cout << std::endl;
25

26
    // 查找键
27
    double* val = avlMap.get("banana");
28
    if (val)
29
        std::cout << "获取键\"banana\"的值: " << *val << std::endl;
30
    else
31
        std::cout << "键\"banana\"不存在。" << std::endl;
32

33
    val = avlMap.get("fig");
34
    if (val)
35
        std::cout << "获取键\"fig\"的值: " << *val << std::endl;
36
    else
37
        std::cout << "键\"fig\"不存在。" << std::endl;
38

39
    val = avlMap.get("grape");
40
    if (val)
41
        std::cout << "获取键\"grape\"的值: " << *val << std::endl;
42
    else
43
        std::cout << "键\"grape\"不存在。" << std::endl;
44

45
    // 删除键"banana"
46
    avlMap.remove("banana");
47
    std::cout << "删除键\"banana\"后，中序遍历: ";
48
    traversal = avlMap.inorderTraversal();
49
    for (const auto& pair : traversal) {
50
        std::cout << "(\"" << pair.first << "\", " << pair.second << ") ";
51
    }
52
    std::cout << std::endl;
53

54
    return 0;
55
}

展开收起

输出:

Terminal window

1
中序遍历: ("apple", 1.99) ("banana", 0.99) ("cherry", 2.99) ("date", 3.49) ("elderberry", 5.99) ("fig", 2.49)
2
获取键"banana"的值: 0.99
3
获取键"fig"的值: 2.49
4
键"grape"不存在。
5
删除键"banana"后，中序遍历: ("apple", 1.99) ("cherry", 2.99) ("date", 3.49) ("elderberry", 5.99) ("fig", 2.49)

6. 完整的通用代码#

以下是模板化的AVLMap的完整实现代码，包括所有辅助函数和类定义：

1
#include <iostream>
2
#include <string>
3
#include <vector>
4
#include <algorithm>   // 用于 std::max
5
#include <functional>  // 用于 std::function
6

7
// 模板化的AVL树节点结构
8
template <typename KeyType, typename ValueType>
9
struct AVLNode {
10
    KeyType key;
11
    ValueType value;
12
    int height;
13
    AVLNode* left;
14
    AVLNode* right;
15

16
    AVLNode(const KeyType& k, const ValueType& val)
17
        : key(k), value(val), height(1), left(nullptr), right(nullptr) {}
18
};
19

20
// 获取节点高度
21
template <typename KeyType, typename ValueType>
22
int getHeight(AVLNode<KeyType, ValueType>* node) {
23
    if (node == nullptr)
24
        return 0;
25
    return node->height;
26
}
27

28
// 获取平衡因子
29
template <typename KeyType, typename ValueType>
30
int getBalance(AVLNode<KeyType, ValueType>* node) {
31
    if (node == nullptr)
32
        return 0;
33
    return getHeight(node->left) - getHeight(node->right);
34
}
35

36
// 右旋转
37
template <typename KeyType, typename ValueType>
38
AVLNode<KeyType, ValueType>* rightRotate(AVLNode<KeyType, ValueType>* y) {
39
    AVLNode<KeyType, ValueType>* x = y->left;
40
    AVLNode<KeyType, ValueType>* T2 = x->right;
41

42
    // 执行旋转
43
    x->right = y;
44
    y->left = T2;
45

46
    // 更新高度
47
    y->height = std::max(getHeight(y->left), getHeight(y->right)) + 1;
48
    x->height = std::max(getHeight(x->left), getHeight(x->right)) + 1;
49

50
    // 返回新的根
51
    return x;
52
}
53

54
// 左旋转
55
template <typename KeyType, typename ValueType>
56
AVLNode<KeyType, ValueType>* leftRotate(AVLNode<KeyType, ValueType>* x) {
57
    AVLNode<KeyType, ValueType>* y = x->right;
58
    AVLNode<KeyType, ValueType>* T2 = y->left;
59

60
    // 执行旋转
61
    y->left = x;
62
    x->right = T2;
63

64
    // 更新高度
65
    x->height = std::max(getHeight(x->left), getHeight(x->right)) + 1;
66
    y->height = std::max(getHeight(y->left), getHeight(y->right)) + 1;
67

68
    // 返回新的根
69
    return y;
70
}
71

72
// 插入节点
73
template <typename KeyType, typename ValueType>
74
AVLNode<KeyType, ValueType>* insertNode(AVLNode<KeyType, ValueType>* node, const KeyType& key, const ValueType& value) {
75
    // 1. 执行标准的BST插入
76
    if (node == nullptr)
77
        return new AVLNode<KeyType, ValueType>(key, value);
78

79
    if (key < node->key)
80
        node->left = insertNode(node->left, key, value);
81
    else if (key > node->key)
82
        node->right = insertNode(node->right, key, value);
83
    else {
84
        // 如果键已经存在，更新其值
85
        node->value = value;
86
        return node;
87
    }
88

89
    // 2. 更新节点高度
90
    node->height = 1 + std::max(getHeight(node->left), getHeight(node->right));
91

92
    // 3. 获取平衡因子
93
    int balance = getBalance(node);
94

95
    // 4. 根据平衡因子进行旋转
96

97
    // 左左情况
98
    if (balance > 1 && key < node->left->key)
99
        return rightRotate(node);
100

101
    // 右右情况
102
    if (balance < -1 && key > node->right->key)
103
        return leftRotate(node);
104

105
    // 左右情况
106
    if (balance > 1 && key > node->left->key) {
107
        node->left = leftRotate(node->left);
108
        return rightRotate(node);
109
    }
110

111
    // 右左情况
112
    if (balance < -1 && key < node->right->key) {
113
        node->right = rightRotate(node->right);
114
        return leftRotate(node);
115
    }
116

117
    return node;
118
}
119

120
// 查找节点
121
template <typename KeyType, typename ValueType>
122
ValueType* searchNode(AVLNode<KeyType, ValueType>* node, const KeyType& key) {
123
    if (node == nullptr)
124
        return nullptr;
125

126
    if (key == node->key)
127
        return &(node->value);
128
    else if (key < node->key)
129
        return searchNode(node->left, key);
130
    else
131
        return searchNode(node->right, key);
132
}
133

134
// 获取最小值节点
135
template <typename KeyType, typename ValueType>
136
AVLNode<KeyType, ValueType>* getMinValueNode(AVLNode<KeyType, ValueType>* node) {
137
    AVLNode<KeyType, ValueType>* current = node;
138
    while (current->left != nullptr)
139
        current = current->left;
140
    return current;
141
}
142

143
// 删除节点
144
template <typename KeyType, typename ValueType>
145
AVLNode<KeyType, ValueType>* deleteNode(AVLNode<KeyType, ValueType>* root, const KeyType& key) {
146
    // 1. 执行标准的BST删除
147
    if (root == nullptr)
148
        return root;
149

150
    if (key < root->key)
151
        root->left = deleteNode(root->left, key);
152
    else if (key > root->key)
153
        root->right = deleteNode(root->right, key);
154
    else {
155
        // 节点有一个或没有子节点
156
        if ((root->left == nullptr) || (root->right == nullptr)) {
157
            AVLNode<KeyType, ValueType>* temp = root->left ? root->left : root->right;
158

159
            // 没有子节点
160
            if (temp == nullptr) {
161
                temp = root;
162
                root = nullptr;
163
            }
164
            else // 一个子节点
165
                *root = *temp; // 复制内容
166

167
            delete temp;
168
        }
169
        else {
170
            // 节点有两个子节点，获取中序后继
171
            AVLNode<KeyType, ValueType>* temp = getMinValueNode(root->right);
172
            // 复制中序后继的内容到此节点
173
            root->key = temp->key;
174
            root->value = temp->value;
175
            // 删除中序后继
176
            root->right = deleteNode(root->right, temp->key);
177
        }
178
    }
179

180
    // 如果树只有一个节点
181
    if (root == nullptr)
182
        return root;
183

184
    // 2. 更新节点高度
185
    root->height = 1 + std::max(getHeight(root->left), getHeight(root->right));
186

187
    // 3. 获取平衡因子
188
    int balance = getBalance(root);
189

190
    // 4. 根据平衡因子进行旋转
191

192
    // 左左情况
193
    if (balance > 1 && getBalance(root->left) >= 0)
194
        return rightRotate(root);
195

196
    // 左右情况
197
    if (balance > 1 && getBalance(root->left) < 0) {
198
        root->left = leftRotate(root->left);
199
        return rightRotate(root);
200
    }
201

202
    // 右右情况
203
    if (balance < -1 && getBalance(root->right) <= 0)
204
        return leftRotate(root);
205

206
    // 右左情况
207
    if (balance < -1 && getBalance(root->right) > 0) {
208
        root->right = rightRotate(root->right);
209
        return leftRotate(root);
210
    }
211

212
    return root;
213
}
214

215
// 模板化的AVLMap类
216
template <typename KeyType, typename ValueType>
217
class AVLMap {
218
private:
219
    AVLNode<KeyType, ValueType>* root;
220

221
    // 中序遍历辅助函数
222
    void inorderHelper(AVLNode<KeyType, ValueType>* node, std::vector<std::pair<KeyType, ValueType>>& res) const {
223
        if (node != nullptr) {
224
            inorderHelper(node->left, res);
225
            res.emplace_back(node->key, node->value);
226
            inorderHelper(node->right, res);
227
        }
228
    }
229

230
public:
231
    AVLMap() : root(nullptr) {}
232

233
    // 插入或更新键值对
234
    void put(const KeyType& key, const ValueType& value) {
235
        root = insertNode(root, key, value);
236
    }
237

238
    // 查找值，返回指向值的指针，如果键不存在则返回nullptr
239
    ValueType* get(const KeyType& key) {
240
        return searchNode(root, key);
241
    }
242

243
    // 删除键值对
244
    void remove(const KeyType& key) {
245
        root = deleteNode(root, key);
246
    }
247

248
    // 中序遍历，返回有序的键值对
249
    std::vector<std::pair<KeyType, ValueType>> inorderTraversal() const {
250
        std::vector<std::pair<KeyType, ValueType>> res;
251
        inorderHelper(root, res);
252
        return res;
253
    }
254

255
    // 析构函数，释放所有节点的内存
256
    ~AVLMap() {
257
        // 使用后序遍历释放节点
258
        std::function<void(AVLNode<KeyType, ValueType>*)> destroy = [&](AVLNode<KeyType, ValueType>* node) {
259
            if (node) {
260
                destroy(node->left);
261
                destroy(node->right);
262
                delete node;
263
            }
264
        };
265
        destroy(root);
266
    }
267
};
268

269
// 示例主函数
270
int main() {
271
    // 示例 1：int 键，std::string 值
272
    std::cout << "示例 1：int 键，std::string 值\n";
273
    AVLMap<int, std::string> avlMap1;
274

275
    // 插入键值对
276
    avlMap1.put(10, "十");
277
    avlMap1.put(20, "二十");
278
    avlMap1.put(30, "三十");
279
    avlMap1.put(40, "四十");
280
    avlMap1.put(50, "五十");
281
    avlMap1.put(25, "二十五");
282

283
    // 中序遍历
284
    std::vector<std::pair<int, std::string>> traversal1 = avlMap1.inorderTraversal();
285
    std::cout << "中序遍历: ";
286
    for (const auto& pair : traversal1) {
287
        std::cout << "(" << pair.first << ", \"" << pair.second << "\") ";
288
    }
289
    std::cout << std::endl;
290

291
    // 查找键
292
    std::string* val1 = avlMap1.get(20);
293
    if (val1)
294
        std::cout << "获取键20的值: " << *val1 << std::endl;
295
    else
296
        std::cout << "键20不存在。" << std::endl;
297

298
    val1 = avlMap1.get(25);
299
    if (val1)
300
        std::cout << "获取键25的值: " << *val1 << std::endl;
301
    else
302
        std::cout << "键25不存在。" << std::endl;
303

304
    val1 = avlMap1.get(60);
305
    if (val1)
306
        std::cout << "获取键60的值: " << *val1 << std::endl;
307
    else
308
        std::cout << "键60不存在。" << std::endl;
309

310
    // 删除键20
311
    avlMap1.remove(20);
312
    std::cout << "删除键20后，中序遍历: ";
313
    traversal1 = avlMap1.inorderTraversal();
314
    for (const auto& pair : traversal1) {
315
        std::cout << "(" << pair.first << ", \"" << pair.second << "\") ";
316
    }
317
    std::cout << std::endl;
318

319
    std::cout << "\n-----------------------------\n";
320

321
    // 示例 2：std::string 键，double 值
322
    std::cout << "示例 2：std::string 键，double 值\n";
323
    AVLMap<std::string, double> avlMap2;
324

325
    // 插入键值对
326
    avlMap2.put("apple", 1.99);
327
    avlMap2.put("banana", 0.99);
328
    avlMap2.put("cherry", 2.99);
329
    avlMap2.put("date", 3.49);
330
    avlMap2.put("elderberry", 5.99);
331
    avlMap2.put("fig", 2.49);
332

333
    // 中序遍历
334
    std::vector<std::pair<std::string, double>> traversal2 = avlMap2.inorderTraversal();
335
    std::cout << "中序遍历: ";
336
    for (const auto& pair : traversal2) {
337
        std::cout << "(\"" << pair.first << "\", " << pair.second << ") ";
338
    }
339
    std::cout << std::endl;
340

341
    // 查找键
342
    double* val2 = avlMap2.get("banana");
343
    if (val2)
344
        std::cout << "获取键\"banana\"的值: " << *val2 << std::endl;
345
    else
346
        std::cout << "键\"banana\"不存在。" << std::endl;
347

348
    val2 = avlMap2.get("fig");
349
    if (val2)
350
        std::cout << "获取键\"fig\"的值: " << *val2 << std::endl;
351
    else
352
        std::cout << "键\"fig\"不存在。" << std::endl;
353

354
    val2 = avlMap2.get("grape");
355
    if (val2)
356
        std::cout << "获取键\"grape\"的值: " << *val2 << std::endl;
357
    else
358
        std::cout << "键\"grape\"不存在。" << std::endl;
359

360
    // 删除键"banana"
361
    avlMap2.remove("banana");
362
    std::cout << "删除键\"banana\"后，中序遍历: ";
363
    traversal2 = avlMap2.inorderTraversal();
364
    for (const auto& pair : traversal2) {
365
        std::cout << "(\"" << pair.first << "\", " << pair.second << ") ";
366
    }
367
    std::cout << std::endl;
368

369
    return 0;
370
}

展开收起

说明#

平衡维护：在每次插入或删除后，都会更新节点的高度并计算平衡因子。如果某个节点的平衡因子超出了[-1, 1]范围，就需要通过旋转来重新平衡树。
查找操作：由于AVL树的高度被保持在O(log n)，查找操作的时间复杂度为O(log n)。
更新操作：如果插入的键已经存在，则更新其对应的值。
遍历操作：中序遍历可以按键的顺序遍历所有键值对。
内存管理：确保在析构函数中正确释放所有动态分配的内存，避免内存泄漏。
泛型支持（可选）：为了使AVLMap更加通用，可以将其模板化，以支持不同类型的键和值。例如：

编译与运行：

假设保存为 avlmap.cpp，使用以下命令编译并运行：

Terminal window

1
g++ -std=c++11 -o avlmap avlmap.cpp
2
./avlmap

预期输出：

1
示例 1：int 键，std::string 值
2
中序遍历: (10, "十") (20, "二十") (25, "二十五") (30, "三十") (40, "四十") (50, "五十")
3
获取键20的值: 二十
4
获取键25的值: 二十五
5
键60不存在。
6
删除键20后，中序遍历: (10, "十") (25, "二十五") (30, "三十") (40, "四十") (50, "五十")
7

8
-----------------------------
9
示例 2：std::string 键，double 值
10
中序遍历: ("apple", 1.99) ("banana", 0.99) ("cherry", 2.99) ("date", 3.49) ("elderberry", 5.99) ("fig", 2.49)
11
获取键"banana"的值: 0.99
12
获取键"fig"的值: 2.49
13
键"grape"不存在。
14
删除键"banana"后，中序遍历: ("apple", 1.99) ("cherry", 2.99) ("date", 3.49) ("elderberry", 5.99) ("fig", 2.49)

7. 注意事项与扩展#

1. 键类型的要求#

为了使AVLMap正常工作，键类型KeyType必须支持以下操作：

比较操作：必须定义operator<，因为AVL树依赖于它来维护排序。如果使用自定义类型作为键，请确保定义了operator<。

1
struct CustomKey {
2
    int id;
3
    std::string name;
4

5
    bool operator<(const CustomKey& other) const {
6
        if (id != other.id)
7
            return id < other.id;
8
        return name < other.name;
9
    }
10
};

2. 泛型支持与约束#

在C++20之前，模板并不支持在模板参数上强制施加约束（需要依赖文档和用户理解）。从C++20起，可以使用**概念（Concepts）**来施加约束。

1
#include <concepts>
2

3
template <typename KeyType, typename ValueType>
4
requires std::totally_ordered<KeyType>
5
class AVLMap {
6
    // 类定义
7
};

这样，编译器会在实例化模板时检查KeyType是否满足std::totally_ordered，即是否支持所有必要的比较操作。

3. 性能优化#

内存管理：当前实现使用递归进行插入和删除，如果树非常深，可能会导致栈溢出。可以考虑使用迭代方法或优化递归深度。
缓存友好：使用自适应数据结构（如缓存友好的节点布局）可以提升性能。
多线程支持：当前实现不是线程安全的。如果需要在多线程环境中使用，需要添加适当的同步机制。

4. 额外功能#

根据需求，你可以为AVLMap添加更多功能：

迭代器：实现输入迭代器、中序遍历迭代器，以便支持范围基（range-based）for循环。
查找最小/最大键：提供方法findMin()和findMax()。
前驱/后继查找：在树中查找给定键的前驱和后继节点。
支持不同的平衡因子策略：例如，允许用户指定自定义的平衡策略。

5. 与标准库的比较#

虽然自己实现AVLMap是一项很好的学习练习，但在实际生产环境中，建议使用C++标准库中已经高度优化和测试过的容器，如std::map（通常实现为红黑树）、std::unordered_map（哈希表）等。

1
#include <map>
2

3
// 使用 std::map
4
int main() {
5
    std::map<int, std::string> stdMap;
6

7
    // 插入键值对
8
    stdMap[10] = "十";
9
    stdMap[20] = "二十";
10
    stdMap[30] = "三十";
11

12
    // 遍历
13
    for (const auto& pair : stdMap) {
14
        std::cout << "(" << pair.first << ", \"" << pair.second << "\") ";
15
    }
16
    std::cout << std::endl;
17

18
    return 0;
19
}

展开收起

std::map提供了与AVLMap类似的功能，并且经过了高度优化，适用于大多数应用场景。

红黑树#

红黑树（Red-Black Tree）是一种自平衡的二叉搜索树，它通过对节点进行颜色标记（红色或黑色）并遵循特定的规则来保证树的平衡性，从而确保基本操作（如查找、插入、删除）的时间复杂度为 O(log n)。红黑树广泛应用于计算机科学中，例如在实现关联容器（如 std::map、std::set）时常用到。

1. 红黑树的五大性质#

红黑树通过以下 五大性质 维持其平衡性：

节点颜色：每个节点要么是红色，要么是黑色。
根节点颜色：根节点是黑色。
叶子节点颜色：所有叶子节点（NIL 节点，即空节点）都是黑色的。这里的叶子节点不存储实际数据，仅作为树的终端。
红色节点限制：如果一个节点是红色的，则它的两个子节点都是黑色的。也就是说，红色节点不能有红色的子节点。
黑色平衡：从任意节点到其所有后代叶子节点的路径上，包含相同数量的黑色节点。这被称为每条路径上的黑色高度相同。

这些性质的意义#

性质1 和 性质2 确保节点颜色的基本规则，便于后续操作中进行颜色判断和调整。
性质3 保证了所有实际节点的子节点（NIL 节点）的统一性，简化了操作逻辑。
性质4 防止了连续的红色节点出现，避免导致过度不平衡。
性质5 保证了树的平衡性，使得树的高度始终保持在 O(log n) 的范围内，从而确保基本操作的高效性。

这些性质共同作用，使得红黑树在最坏情况下也能保持较好的性能表现。

2. 红黑树的插入操作#

插入操作是红黑树中常见的操作，与标准的二叉搜索树（BST）插入类似，但需要额外的步骤来维护红黑树的性质。

2.1 插入步骤概述#

插入操作通常分为以下两个主要步骤：

标准二叉搜索树插入：根据键值比较，将新节点插入到合适的位置，初始颜色为红色。
插入后的修正（Insert Fixup）：通过重新着色和旋转操作，恢复红黑树的五大性质。

2.2 插入后的修正（Insert Fixup）#

插入一个红色节点可能会破坏红黑树的性质，尤其是性质4（红色节点不能连续）。为了修复这些潜在的冲突，需要进行颜色调整和旋转操作。

修正步骤：#

插入修正的过程通常遵循以下规则（以下描述假设新插入的节点 z 是红色）：

父节点为黑色：
- 如果 z 的父节点是黑色的，那么插入操作不会破坏红黑树的性质，修正过程结束。
父节点为红色：
- 情况1：z 的叔叔节点（即 z 的父节点的兄弟节点）也是红色。
  - 将父节点和叔叔节点重新着色为黑色。
  - 将祖父节点重新着色为红色。
  - 将 z 指向祖父节点，继续检查上层节点，防止高层的性质被破坏。
- 情况2：z 的叔叔节点是黑色，且 z 是其父节点的右子节点。
  - 对 z 的父节点进行左旋转。
  - 将 z 指向其新的左子节点（即原父节点）。
- 情况3：z 的叔叔节点是黑色，且 z 是其父节点的左子节点。
  - 将父节点重新着色为黑色。
  - 将祖父节点重新着色为红色。
  - 对祖父节点进行右旋转。

旋转操作的重要性#

在修正过程中，旋转操作用于调整树的局部结构，使得红黑树的性质得以恢复。这些旋转包括左旋转和右旋转，在后续章节中将详细介绍。

插入修正的代码实现示例#

以下是红黑树插入修正的一个简化版 C++ 实现：

1
template <typename Key, typename Value>
2
void RedBlackTree<Key, Value>::insertFixUp(RBTreeNode<Key, Value>* z) {
3
    while (z->parent != nullptr && z->parent->color == RED) {
4
        if (z->parent == z->parent->parent->left) {
5
            RBTreeNode<Key, Value>* y = z->parent->parent->right; // 叔叔节点
6
            if (y != nullptr && y->color == RED) {
7
                // 情况1：叔叔为红色
8
                z->parent->color = BLACK;
9
                y->color = BLACK;
10
                z->parent->parent->color = RED;
11
                z = z->parent->parent;
12
            } else {
13
                if (z == z->parent->right) {
14
                    // 情况2：z为右子节点
15
                    z = z->parent;
16
                    leftRotate(z);
17
                }
18
                // 情况3：z为左子节点
19
                z->parent->color = BLACK;
20
                z->parent->parent->color = RED;
21
                rightRotate(z->parent->parent);
22
            }
23
        } else {
24
            // 情况对称：父节点是右子节点
25
            RBTreeNode<Key, Value>* y = z->parent->parent->left; // 叔叔节点
26
            if (y != nullptr && y->color == RED) {
27
                // 情况1
28
                z->parent->color = BLACK;
29
                y->color = BLACK;
30
                z->parent->parent->color = RED;
31
                z = z->parent->parent;
32
            } else {
33
                if (z == z->parent->left) {
34
                    // 情况2
35
                    z = z->parent;
36
                    rightRotate(z);
37
                }
38
                // 情况3
39
                z->parent->color = BLACK;
40
                z->parent->parent->color = RED;
41
                leftRotate(z->parent->parent);
42
            }
43
        }
44
    }
45
    root->color = BLACK; // 最终根节点必须为黑色
46
}

展开收起

3. 红黑树的删除操作#

删除操作同样重要且复杂，因为它可能破坏红黑树的多个性质。与插入类似，删除操作也需要两个主要步骤：

标准二叉搜索树删除：按照 BST 的规则删除节点。
删除后的修正（Delete Fixup）：通过重新着色和旋转操作，恢复红黑树的性质。

3.1 删除步骤概述#

删除操作分为以下步骤：

定位要删除的节点：
- 如果要删除的节点 z 有两个子节点，则找到其中序后继节点 y（即 z 的右子树中的最小节点）。
- 将 y 的值复制到 z，然后将删除目标转移到 y。此时 y 至多只有一个子节点。
删除节点：
- 若 y 只有一个子节点 x（可能为 NIL），则用 x 替代 y 的位置。
- 记录被删除节点的原颜色 y_original_color。
删除修正（仅当 y_original_color 为黑色时）：
- 因为删除一个黑色节点会影响路径上的黑色数量，需通过多次调整来恢复红黑树的性质。

3.2 删除后的修正（Delete Fixup）#

删除后的修正较为复杂，涉及多种情况处理。以下为主要的修正步骤和可能遇到的情况：

修正步骤：#

初始化：设 x 为替代被删除的节点的位置，x 可能为实际节点或 NIL 节点。
循环修正：
- 当 x 不是根节点，且 x 的颜色为黑色，进入修正循环。
- 判断 x 是其父节点的左子节点还是右子节点，并相应地设定兄弟节点 w。
处理不同情况：情况1：w 是红色的。

情况2：w 是黑色，且 w 的两个子节点都是黑色。

情况3：w 是黑色，且 w 的左子节点是红色，右子节点是黑色。

情况4：w 是黑色，且 w 的右子节点是红色。

1
- 将 **w** 重新着色为黑色。
2
- 将 **x** 的父节点重新着色为红色。
3
- 对 **x** 的父节点进行左旋转或右旋转，取决于是左子节点还是右子节点。
4
- 更新 **w**，继续修正过程。
5
- 将 **w** 重新着色为红色。
6
- 将 **x** 设为其父节点，继续修正。
7
- 将 **w** 的左子节点重新着色为黑色。
8
- 将 **w** 重新着色为红色。
9
- 对 **w** 进行右旋转或左旋转，取决于是左子节点还是右子节点。
10
- 更新 **w**，进入**情况4**。
11
- 将 **w** 的颜色设为 **x** 的父节点颜色。
12
- 将 **x** 的父节点重新着色为黑色。
13
- 将 **w** 的右子节点重新着色为黑色。
14
- 对 **x** 的父节点进行左旋转或右旋转，取决于是左子节点还是右子节点。
15
- 结束修正。

展开收起

4. 最终步骤：将 x 设为根节点，并将其颜色设为黑色，确保根节点的颜色为黑色。

删除修正的代码实现示例#

由于删除修正涉及较多的情况，以下为一个简化版的红黑树删除修正的 C++ 实现：

1
template <typename Key, typename Value>
2
void RedBlackTree<Key, Value>::deleteFixUp(RBTreeNode<Key, Value>* x) {
3
    while (x != root && (x == nullptr || x->color == BLACK)) {
4
        if (x == x->parent->left) {
5
            RBTreeNode<Key, Value>* w = x->parent->right; // 兄弟节点
6
            if (w->color == RED) {
7
                // 情况1
8
                w->color = BLACK;
9
                x->parent->color = RED;
10
                leftRotate(x->parent);
11
                w = x->parent->right;
12
            }
13
            if ((w->left == nullptr || w->left->color == BLACK) &&
14
                (w->right == nullptr || w->right->color == BLACK)) {
15
                // 情况2
16
                w->color = RED;
17
                x = x->parent;
18
            } else {
19
                if (w->right == nullptr || w->right->color == BLACK) {
20
                    // 情况3
21
                    if (w->left != nullptr)
22
                        w->left->color = BLACK;
23
                    w->color = RED;
24
                    rightRotate(w);
25
                    w = x->parent->right;
26
                }
27
                // 情况4
28
                w->color = x->parent->color;
29
                x->parent->color = BLACK;
30
                if (w->right != nullptr)
31
                    w->right->color = BLACK;
32
                leftRotate(x->parent);
33
                x = root; // 修正完成
34
            }
35
        } else {
36
            // 情况对称：x 是右子节点
37
            RBTreeNode<Key, Value>* w = x->parent->left; // 兄弟节点
38
            if (w->color == RED) {
39
                // 情况1
40
                w->color = BLACK;
41
                x->parent->color = RED;
42
                rightRotate(x->parent);
43
                w = x->parent->left;
44
            }
45
            if ((w->right == nullptr || w->right->color == BLACK) &&
46
                (w->left == nullptr || w->left->color == BLACK)) {
47
                // 情况2
48
                w->color = RED;
49
                x = x->parent;
50
            } else {
51
                if (w->left == nullptr || w->left->color == BLACK) {
52
                    // 情况3
53
                    if (w->right != nullptr)
54
                        w->right->color = BLACK;
55
                    w->color = RED;
56
                    leftRotate(w);
57
                    w = x->parent->left;
58
                }
59
                // 情况4
60
                w->color = x->parent->color;
61
                x->parent->color = BLACK;
62
                if (w->left != nullptr)
63
                    w->left->color = BLACK;
64
                rightRotate(x->parent);
65
                x = root; // 修正完成
66
            }
67
        }
68
    }
69
    if (x != nullptr)
70
        x->color = BLACK;
71
}

展开收起

4. 旋转操作详解#

旋转操作是红黑树中用于重新平衡树的关键操作，包括左旋转和右旋转。旋转操作通过调整节点的父子关系，改变树的局部结构，从而保持红黑树的性质。

4.1 左旋转（Left Rotate）#

左旋转围绕节点 x 进行，其目的是将 x 的右子节点 y 提升为 x 的父节点，x 变为 y 的左子节点，y 的左子节点 b 成为 x 的右子节点。

旋转前：

旋转后：

左旋转的代码实现：

1
template <typename Key, typename Value>
2
void RedBlackTree<Key, Value>::leftRotate(RBTreeNode<Key, Value>* x) {
3
    RBTreeNode<Key, Value>* y = x->right;
4
    x->right = y->left;
5
    if (y->left != nullptr)
6
        y->left->parent = x;
7

8
    y->parent = x->parent;
9
    if (x->parent == nullptr)
10
        root = y;
11
    else if (x == x->parent->left)
12
        x->parent->left = y;
13
    else
14
        x->parent->right = y;
15

16
    y->left = x;
17
    x->parent = y;
18
}

展开收起

4.2 右旋转（Right Rotate）#

右旋转是 左旋转 的镜像操作，围绕节点 y 进行，其目的是将 y 的左子节点 x 提升为 y 的父节点，y 变为 x 的右子节点，x 的右子节点 b 成为 y 的左子节点。

旋转前：

旋转后：

右旋转的代码实现：

1
template <typename Key, typename Value>
2
void RedBlackTree<Key, Value>::rightRotate(RBTreeNode<Key, Value>* y) {
3
    RBTreeNode<Key, Value>* x = y->left;
4
    y->left = x->right;
5
    if (x->right != nullptr)
6
        x->right->parent = y;
7

8
    x->parent = y->parent;
9
    if (y->parent == nullptr)
10
        root = x;
11
    else if (y == y->parent->right)
12
        y->parent->right = x;
13
    else
14
        y->parent->left = x;
15

16
    x->right = y;
17
    y->parent = x;
18
}

展开收起

旋转操作的作用#

通过旋转操作，可以改变树的高度和形状，确保红黑树的性质在插入和删除后得到维护。旋转不会破坏二叉搜索树的性质，仅改变节点之间的指向关系。

5.简化版红黑树实现#

节点结构体#

首先，我们定义红黑树节点的结构体：

1
#include <iostream>
2

3
enum Color { RED, BLACK };
4

5
template <typename Key, typename Value>
6
struct RBTreeNode {
7
    Key key;
8
    Value value;
9
    Color color;
10
    RBTreeNode* parent;
11
    RBTreeNode* left;
12
    RBTreeNode* right;
13

14
    RBTreeNode(Key k, Value v)
15
        : key(k), value(v), color(RED), parent(nullptr), left(nullptr), right(nullptr) {}
16
};

展开收起

红黑树类#

接下来，我们定义红黑树的主要类，包括插入、删除和遍历功能：

1
#include <iostream>
2

3
enum Color { RED, BLACK };
4

5
template <typename Key, typename Value>
6
struct RBTreeNode {
7
    Key key;
8
    Value value;
9
    Color color;
10
    RBTreeNode* parent;
11
    RBTreeNode* left;
12
    RBTreeNode* right;
13

14
    RBTreeNode(Key k, Value v)
15
        : key(k), value(v), color(RED), parent(nullptr), left(nullptr), right(nullptr) {}
16
};
17

18
template <typename Key, typename Value>
19
class RedBlackTree {
20
private:
21
    RBTreeNode<Key, Value>* root;
22

23
    void leftRotate(RBTreeNode<Key, Value>* x) {
24
        RBTreeNode<Key, Value>* y = x->right;
25
        x->right = y->left;
26
        if (y->left != nullptr)
27
            y->left->parent = x;
28

29
        y->parent = x->parent;
30
        if (x->parent == nullptr)
31
            root = y;
32
        else if (x == x->parent->left)
33
            x->parent->left = y;
34
        else
35
            x->parent->right = y;
36

37
        y->left = x;
38
        x->parent = y;
39
    }
40

41
    void rightRotate(RBTreeNode<Key, Value>* y) {
42
        RBTreeNode<Key, Value>* x = y->left;
43
        y->left = x->right;
44
        if (x->right != nullptr)
45
            x->right->parent = y;
46

47
        x->parent = y->parent;
48
        if (y->parent == nullptr)
49
            root = x;
50
        else if (y == y->parent->right)
51
            y->parent->right = x;
52
        else
53
            y->parent->left = x;
54

55
        x->right = y;
56
        y->parent = x;
57
    }
58

59
    void insertFixUp(RBTreeNode<Key, Value>* z) {
60
        while (z->parent != nullptr && z->parent->color == RED) {
61
            if (z->parent == z->parent->parent->left) {
62
                RBTreeNode<Key, Value>* y = z->parent->parent->right; // 叔叔节点
63
                if (y != nullptr && y->color == RED) {
64
                    // 情况1
65
                    z->parent->color = BLACK;
66
                    y->color = BLACK;
67
                    z->parent->parent->color = RED;
68
                    z = z->parent->parent;
69
                } else {
70
                    if (z == z->parent->right) {
71
                        // 情况2
72
                        z = z->parent;
73
                        leftRotate(z);
74
                    }
75
                    // 情况3
76
                    z->parent->color = BLACK;
77
                    z->parent->parent->color = RED;
78
                    rightRotate(z->parent->parent);
79
                }
80
            } else {
81
                // 父节点是右子节点，情况对称
82
                RBTreeNode<Key, Value>* y = z->parent->parent->left; // 叔叔节点
83
                if (y != nullptr && y->color == RED) {
84
                    // 情况1
85
                    z->parent->color = BLACK;
86
                    y->color = BLACK;
87
                    z->parent->parent->color = RED;
88
                    z = z->parent->parent;
89
                } else {
90
                    if (z == z->parent->left) {
91
                        // 情况2
92
                        z = z->parent;
93
                        rightRotate(z);
94
                    }
95
                    // 情况3
96
                    z->parent->color = BLACK;
97
                    z->parent->parent->color = RED;
98
                    leftRotate(z->parent->parent);
99
                }
100
            }
101
        }
102
        root->color = BLACK;
103
    }
104

105
    void inorderHelper(RBTreeNode<Key, Value>* node) const {
106
        if (node == nullptr) return;
107
        inorderHelper(node->left);
108
        std::cout << node->key << " ";
109
        inorderHelper(node->right);
110
    }
111

112
public:
113
    RedBlackTree() : root(nullptr) {}
114

115
    RBTreeNode<Key, Value>* getRoot() const { return root; }
116

117
    void insert(const Key& key, const Value& value) {
118
        RBTreeNode<Key, Value>* z = new RBTreeNode<Key, Value>(key, value);
119
        RBTreeNode<Key, Value>* y = nullptr;
120
        RBTreeNode<Key, Value>* x = root;
121

122
        while (x != nullptr) {
123
            y = x;
124
            if (z->key < x->key)
125
                x = x->left;
126
            else
127
                x = x->right;
128
        }
129

130
        z->parent = y;
131
        if (y == nullptr)
132
            root = z;
133
        else if (z->key < y->key)
134
            y->left = z;
135
        else
136
            y->right = z;
137

138
        // 插入后修正红黑树性质
139
        insertFixUp(z);
140
    }
141

142
    void inorderTraversal() const {
143
        inorderHelper(root);
144
        std::cout << std::endl;
145
    }
146

147
    // 为简化示例，删除操作未实现
148
    // 完整实现需要包含 deleteFixUp 等步骤
149
};

展开收起

简要说明#

上述红黑树类包含以下主要功能：

插入操作 (insert)：
- 插入新的键值对，并调用 insertFixUp 进行修正，以保持红黑树的性质。
旋转操作 (leftRotate** 和 rightRotate)**：
- 通过旋转操作重新调整树的结构，确保树的平衡。
修正插入后的红黑树性质 (insertFixUp)：
- 根据红黑树的五大性质，通过重新着色和旋转来修正可能的违规情况。
中序遍历 (inorderTraversal)：
- 以中序遍历的方式输出树中的键，结果应为升序。

注意：为了简化示例，删除操作 (delete) 及其修正 (deleteFixUp) 未在此实现。如果需要完整的删除功能，请参考之前的详细解释或使用标准库中的实现。

6. 红黑树与其他平衡树的比较#

红黑树并非唯一的自平衡二叉搜索树，其他常见的平衡树包括 AVL 树（Adelson-Velsky和Landis树）和 Splay 树。以下是红黑树与 AVL 树的比较：

红黑树 vs AVL 树#

特性	红黑树 (Red-Black Tree)	AVL 树 (AVL Tree)
平衡性	相对不严格，每个路径上的黑色节点相同。	更严格，任意节点的左右子树高度差不超过1。
插入/删除效率	较快，插入和删除操作较少的旋转，适用于频繁修改的场景。	较慢，插入和删除可能需要多次旋转，适用于查找操作多于修改的场景。
查找效率	O(log n)	O(log n)，常数因子更小，查找速度略快。
实现复杂度	相对简单，旋转操作较少。	实现较复杂，需严格维护高度平衡。
应用场景	操作频繁、需要快速插入和删除的场景。	查找操作频繁、插入和删除相对较少的场景。

选择依据#

红黑树更适用于需要频繁插入和删除操作，并且查找操作相对较多的场景，因为其插入和删除操作的调整成本较低。
AVL 树适用于查找操作极为频繁，而修改操作相对较少的场景，因为其高度更严格，查找效率更高。

7. 红黑树的应用场景#

由于红黑树高效的查找、插入和删除性能，它在计算机科学中的多个领域都有广泛的应用：

标准库中的关联容器：
- C++ 标准库中的 std::map 和 std::set 通常基于红黑树实现。
- Java 的 TreeMap 和 TreeSet 也是基于红黑树。
操作系统：
- Linux 内核中的调度器和虚拟内存管理使用红黑树来管理进程和内存资源。
数据库系统：
- 一些数据库索引结构使用红黑树来提高查询效率。
编译器设计：
- 语法分析树和符号表管理中可能使用红黑树来高效存储和查找符号。

手写线程安全智能指针

Mon, 25 May 2026 00:00:00 GMT

现有 `SimpleSharedPtr` 的线程安全性分析#

在多线程环境下，确保智能指针的线程安全性主要涉及以下几个方面：

引用计数管理：多个线程可能会同时拷贝、移动或销毁智能指针实例，导致引用计数的修改。若引用计数不是原子操作，则会引发数据竞争和未定义行为。
指针和控制块的访问：多个线程可能会同时访问或修改同一个智能指针实例的 ptr 和 control 成员，这需要同步机制来保护。

当前 SimpleSharedPtr 的问题：

引用计数非原子：ControlBlock::ref_count 是普通的 int 类型，当多个线程同时修改 ref_count 时，会引发竞态条件。
缺乏同步机制：SimpleSharedPtr 的成员函数（如拷贝构造、赋值操作符等）在修改 ptr 和 control 时没有任何同步机制，导致多个线程同时操作同一个 SimpleSharedPtr 实例时不安全。

实现线程安全的 `SimpleSharedPtr`#

为了解决上述问题，可以从以下几个方面入手：

方法一：使用 `std::atomic` 管理引用计数#

将 ControlBlock::ref_count 从普通的 int 替换为 std::atomic<int>，以确保引用计数的线程安全递增和递减。

优点：

简单高效，避免使用互斥锁带来的性能开销。
类似于标准库中 std::shared_ptr 实现的引用计数管理。

缺点：

只能保证引用计数本身的线程安全，无法保护 ptr 和 control 的同步访问。

方法二：引入互斥锁保护指针操作#

在 SimpleSharedPtr 中引入 std::mutex，在所有可能修改 ptr 和 control 的操作中加锁。

优点：

确保 ptr 和 control 在多线程访问时的一致性。
提供更全面的线程安全保障。

缺点：

引入锁机制，可能带来性能开销，特别是在高并发场景下。

方法三：组合使用 `std::atomic` 和互斥锁#

结合使用 std::atomic<int> 进行引用计数的管理，并使用 std::mutex 保护指针和控制块的访问。

优点：

引用计数管理高效且线程安全。
指针和控制块的访问得到完全的同步保护。

缺点：

复杂性较高，需要同时管理原子操作和互斥锁。

完整线程安全的 `ThreadSafeSharedPtr` 实现#

结合上述方法二和方法一，我们可以实现一个名为 ThreadSafeSharedPtr 的类模板，确保在多线程环境下的安全性。以下是具体实现：

1
#include <iostream>
2
#include <atomic>
3
#include <mutex>
4
#include <thread>
5

6
// 控制块结构
7
struct ControlBlock {
8
    std::atomic<int> ref_count;
9

10
    ControlBlock() : ref_count(1) {}
11
};
12

13
// 线程安全的 shared_ptr 实现
14
template <typename T>
15
class ThreadSafeSharedPtr {
16
private:
17
    T* ptr;                 // 指向管理的对象
18
    ControlBlock* control;  // 指向控制块
19

20
    // 互斥锁，用于保护 ptr 和 control
21
    mutable std::mutex mtx;
22

23
    // 释放当前资源
24
    void release() {
25
        if (control) {
26
            // 原子递减引用计数
27
            if (--(control->ref_count) == 0) {
28
                delete ptr;
29
                delete control;
30
                std::cout << "Resource and ControlBlock destroyed." << std::endl;
31
            } else {
32
                std::cout << "Decremented ref_count to " << control->ref_count.load() << std::endl;
33
            }
34
        }
35
        ptr = nullptr;
36
        control = nullptr;
37
    }
38

39
public:
40
    // 默认构造函数
41
    ThreadSafeSharedPtr() : ptr(nullptr), control(nullptr) {
42
        std::cout << "Default constructed ThreadSafeSharedPtr (nullptr)." << std::endl;
43
    }
44

45
    // 参数化构造函数
46
    explicit ThreadSafeSharedPtr(T* p) : ptr(p) {
47
        if (p) {
48
            control = new ControlBlock();
49
            std::cout << "Constructed ThreadSafeSharedPtr, ref_count = " << control->ref_count.load() << std::endl;
50
        } else {
51
            control = nullptr;
52
        }
53
    }
54

55
    // 拷贝构造函数
56
    ThreadSafeSharedPtr(const ThreadSafeSharedPtr& other) {
57
        std::lock_guard<std::mutex> lock(other.mtx);
58
        ptr = other.ptr;
59
        control = other.control;
60
        if (control) {
61
            control->ref_count++;
62
            std::cout << "Copied ThreadSafeSharedPtr, ref_count = " << control->ref_count.load() << std::endl;
63
        }
64
    }
65

66
    // 拷贝赋值操作符
67
    ThreadSafeSharedPtr& operator=(const ThreadSafeSharedPtr& other) {
68
        if (this != &other) {
69
            // 为避免死锁，使用 std::scoped_lock 同时锁定两个互斥锁
70
            std::scoped_lock lock(mtx, other.mtx);
71
            release();
72
            ptr = other.ptr;
73
            control = other.control;
74
            if (control) {
75
                control->ref_count++;
76
                std::cout << "Assigned ThreadSafeSharedPtr, ref_count = " << control->ref_count.load() << std::endl;
77
            }
78
        }
79
        return *this;
80
    }
81

82
    // 移动构造函数
83
    ThreadSafeSharedPtr(ThreadSafeSharedPtr&& other) noexcept {
84
        std::lock_guard<std::mutex> lock(other.mtx);
85
        ptr = other.ptr;
86
        control = other.control;
87
        other.ptr = nullptr;
88
        other.control = nullptr;
89
        std::cout << "Moved ThreadSafeSharedPtr." << std::endl;
90
    }
91

92
    // 移动赋值操作符
93
    ThreadSafeSharedPtr& operator=(ThreadSafeSharedPtr&& other) noexcept {
94
        if (this != &other) {
95
            // 为避免死锁，使用 std::scoped_lock 同时锁定两个互斥锁
96
            std::scoped_lock lock(mtx, other.mtx);
97
            release();
98
            ptr = other.ptr;
99
            control = other.control;
100
            other.ptr = nullptr;
101
            other.control = nullptr;
102
            std::cout << "Move-assigned ThreadSafeSharedPtr." << std::endl;
103
        }
104
        return *this;
105
    }
106

107
    // 析构函数
108
    ~ThreadSafeSharedPtr() {
109
        release();
110
    }
111

112
    // 解引用操作符
113
    T& operator*() const {
114
        std::lock_guard<std::mutex> lock(mtx);
115
        return *ptr;
116
    }
117

118
    // 箭头操作符
119
    T* operator->() const {
120
        std::lock_guard<std::mutex> lock(mtx);
121
        return ptr;
122
    }
123

124
    // 获取引用计数
125
    int use_count() const {
126
        std::lock_guard<std::mutex> lock(mtx);
127
        return control ? control->ref_count.load() : 0;
128
    }
129

130
    // 获取裸指针
131
    T* get() const {
132
        std::lock_guard<std::mutex> lock(mtx);
133
        return ptr;
134
    }
135

136
    // 重置指针
137
    void reset(T* p = nullptr) {
138
        std::lock_guard<std::mutex> lock(mtx);
139
        release();
140
        ptr = p;
141
        if (p) {
142
            control = new ControlBlock();
143
            std::cout << "Reset ThreadSafeSharedPtr, ref_count = " << control->ref_count.load() << std::endl;
144
        } else {
145
            control = nullptr;
146
        }
147
    }
148
};
149

150
// 测试类
151
class Test {
152
public:
153
    Test(int val) : value(val) {
154
        std::cout << "Test Constructor: " << value << std::endl;
155
    }
156
    ~Test() {
157
        std::cout << "Test Destructor: " << value << std::endl;
158
    }
159
    void show() const {
160
        std::cout << "Value: " << value << std::endl;
161
    }
162

163
private:
164
    int value;
165
};

展开收起

关键改动说明#

引用计数原子化：
- 将

1
ControlBlock::ref_count

从普通的

1
int

改为

1
std::atomic<int>

：

1
std::atomic<int> ref_count;

1
- 使用原子操作管理引用计数，确保多线程下的安全递增和递减：

1
control->ref_count++;
2
if (--(control->ref_count) == 0) { ... }

1
- 使用 `ref_count.load()` 获取当前引用计数的值。

2. 引入互斥锁： - 在

1
ThreadSafeSharedPtr

中引入

1
std::mutex mtx

，用于保护

1
ptr

和

1
control

的访问：

1
mutable std::mutex mtx;

1
- 在所有可能修改或访问

1
ptr

和

1
control

的成员函数中加锁，确保同步：

1
std::lock_guard<std::mutex> lock(mtx);

1
- 在拷贝构造函数和拷贝赋值操作符中，为避免死锁，使用

1
std::scoped_lock

同时锁定两个互斥锁：

1
std::scoped_lock lock(mtx, other.mtx);

线程安全的成员函数：
- 对于 operator* 和 operator->，在返回前锁定互斥锁，确保在多线程环境中的安全访问。
- 其他成员函数如 use_count、get 和 reset 同样在访问共享资源前加锁。

注意事项#

避免死锁：在需要同时锁定多个互斥锁时，使用 std::scoped_lock（C++17 引入）可以同时锁定多个互斥锁，避免死锁风险。
性能开销：引入互斥锁会带来一定的性能开销，尤其是在高并发场景下。根据实际需求，权衡线程安全性和性能之间的关系。

测试线程安全的 `ThreadSafeSharedPtr`#

为了验证 ThreadSafeSharedPtr 的线程安全性，我们可以编写一个多线程程序，让多个线程同时拷贝、赋值和销毁智能指针。

1
#include <iostream>
2
#include <thread>
3
#include <vector>
4
#include "ThreadSafeSharedPtr.h" // 假设将上述代码保存为该头文件
5

6
// 测试类
7
class Test {
8
public:
9
    Test(int val) : value(val) {
10
        std::cout << "Test Constructor: " << value << std::endl;
11
    }
12
    ~Test() {
13
        std::cout << "Test Destructor: " << value << std::endl;
14
    }
15
    void show() const {
16
        std::cout << "Value: " << value << std::endl;
17
    }
18

19
private:
20
    int value;
21
};
22

23
void thread_func_copy(ThreadSafeSharedPtr<Test> sptr, int thread_id) {
24
    std::cout << "Thread " << thread_id << " is copying shared_ptr." << std::endl;
25
    ThreadSafeSharedPtr<Test> local_sptr = sptr;
26
    std::cout << "Thread " << thread_id << " copied shared_ptr, use_count = " << local_sptr.use_count() << std::endl;
27
    local_sptr->show();
28
}
29

30
void thread_func_reset(ThreadSafeSharedPtr<Test>& sptr, int new_val, int thread_id) {
31
    std::cout << "Thread " << thread_id << " is resetting shared_ptr." << std::endl;
32
    sptr.reset(new Test(new_val));
33
    std::cout << "Thread " << thread_id << " reset shared_ptr, use_count = " << sptr.use_count() << std::endl;
34
    sptr->show();
35
}
36

37
int main() {
38
    std::cout << "Creating ThreadSafeSharedPtr with Test(100)." << std::endl;
39
    ThreadSafeSharedPtr<Test> sptr(new Test(100));
40
    std::cout << "Initial use_count: " << sptr.use_count() << std::endl;
41

42
    // 创建多个线程进行拷贝操作
43
    const int num_threads = 5;
44
    std::vector<std::thread> threads_copy;
45

46
    for(int i = 0; i < num_threads; ++i) {
47
        threads_copy.emplace_back(thread_func_copy, sptr, i);
48
    }
49

50
    for(auto& t : threads_copy) {
51
        t.join();
52
    }
53

54
    std::cout << "After copy threads, use_count: " << sptr.use_count() << std::endl;
55

56
    // 创建多个线程进行 reset 操作
57
    std::vector<std::thread> threads_reset;
58

59
    for(int i = 0; i < num_threads; ++i) {
60
        threads_reset.emplace_back(thread_func_reset, std::ref(sptr), 200 + i, i);
61
    }
62

63
    for(auto& t : threads_reset) {
64
        t.join();
65
    }
66

67
    std::cout << "After reset threads, final use_count: " << sptr.use_count() << std::endl;
68

69
    std::cout << "Exiting main." << std::endl;
70
    return 0;
71
}

展开收起

预期输出示例（具体顺序可能因线程调度而异）：

1
Creating ThreadSafeSharedPtr with Test(100).
2
Test Constructor: 100
3
Constructed ThreadSafeSharedPtr, ref_count = 1
4
Initial use_count: 1
5
Thread 0 is copying shared_ptr.
6
Copied ThreadSafeSharedPtr, ref_count = 2
7
Thread 0 copied shared_ptr, use_count = 2
8
Value: 100
9
Thread 1 is copying shared_ptr.
10
Copied ThreadSafeSharedPtr, ref_count = 3
11
Thread 1 copied shared_ptr, use_count = 3
12
Value: 100
13
...
14
After copy threads, use_count: 6
15
Thread 0 is resetting shared_ptr.
16
Decremented ref_count to 5
17
Resource and ControlBlock destroyed.
18
Test Constructor: 200
19
Reset ThreadSafeSharedPtr, ref_count = 1
20
Value: 200
21
...
22
After reset threads, final use_count: 1
23
Exiting main.
24
Test Destructor: 200

展开收起

说明：

多个线程同时拷贝 sptr，引用计数正确递增。
多个线程同时重置 sptr，确保引用计数和资源管理的正确性。
最终，只有最新分配的对象存在，引用计数为 1。

注意事项和最佳实践#

引用计数的原子性：
- 使用 std::atomic<int> 来保证引用计数的线程安全递增和递减。
- 避免使用普通的 int，因为在多线程环境下会导致数据竞争。
互斥锁的使用：
- 使用 std::mutex 来保护 ptr 和 control 的访问，防止多个线程同时修改智能指针实例。
- 尽量缩小锁的范围，避免在互斥锁保护的临界区内执行耗时操作，以减少性能开销。
避免死锁：
- 在需要同时锁定多个互斥锁时，使用 std::scoped_lock 来一次性锁定，确保锁的顺序一致，避免死锁风险。
尽量遵循 RAII 原则：
- 使用 std::lock_guard 或 std::scoped_lock 等 RAII 机制来管理互斥锁，确保在异常抛出时自动释放锁，防止死锁。
避免多重管理：
- 确保不通过裸指针绕过智能指针的引用计数管理，避免资源泄漏或重复释放。
性能考虑：
- 在高并发场景下，频繁的锁操作可能成为性能瓶颈。根据实际需求，可以考虑使用更轻量级的同步机制，如 std::shared_mutex（C++17）用于读多写少的场景。

总结#

通过将 ControlBlock::ref_count 改为 std::atomic<int>，并在 ThreadSafeSharedPtr 中引入互斥锁来保护 ptr 和 control 的访问，可以实现一个线程安全的智能指针。这种实现确保了在多线程环境下，多个线程可以安全地拷贝、赋值和销毁智能指针，同时正确管理引用计数和资源。

关键点总结：

引用计数的原子性：使用 std::atomic<int> 保证引用计数操作的线程安全。
互斥锁保护：使用 std::mutex 保护智能指针实例的内部状态，防止多个线程同时修改。
RAII 机制：利用 std::lock_guard 和 std::scoped_lock 等 RAII 机制，确保锁的正确管理和释放。
避免死锁：在需要同时锁定多个互斥锁时，使用 std::scoped_lock 以避免死锁风险。
性能优化：平衡线程安全性和性能，避免不必要的锁竞争。

手写双端对列

Sun, 24 May 2026 00:00:00 GMT

1. 双端队列 (Deque) 概述#

双端队列（Double-Ended Queue，简称 deque）是一种允许在其两端进行高效插入和删除操作的数据结构。与普通队列（只允许在一端插入和另一端删除）相比，双端队列更为灵活。

C++ 标准库中已经提供了 std::deque，但通过自行实现一个双端队列，可以更好地理解其内部机制和迭代器的工作原理。

2. 实现思路#

为了实现一个高效的双端队列，我们需要考虑以下几点：

动态数组：使用动态数组（如环形缓冲区）来存储元素，以便支持在两端进行常数时间的插入和删除。
头尾指针：维护头部和尾部的索引，以便快速访问两端。
自动扩展：当容量不足时，自动调整内部缓冲区的大小。
迭代器支持：定义一个迭代器类，允许用户使用像 begin() 和 end() 这样的函数进行遍历。

接下来，我们将一步步实现这些功能。

3. 详细实现#

3.1 内部数据结构#

我们将使用一个动态分配的数组作为内部缓冲区，并通过头尾索引来管理队列的前后端。为了支持在两端高效插入和删除，我们将采用环形缓冲区的概念，即当索引达到数组的末端时，自动回绕到数组的开头。

3.2 Deque 类#

下面是 Deque 类的基本结构和关键成员：

1
#include <iostream>
2
#include <stdexcept>
3
#include <iterator>
4

5
template <typename T>
6
class Deque {
7
private:
8
    T* buffer;               // 内部缓冲区
9
    size_t capacity;         // 缓冲区容量
10
    size_t front_idx;        // 头部索引
11
    size_t back_idx;         // 尾部索引
12
    size_t count;            // 当前元素数量
13

14
    // 调整容量
15
    void resize(size_t new_capacity) {
16
        T* new_buffer = new T[new_capacity];
17
        // 重新排列元素
18
        for (size_t i = 0; i < count; ++i) {
19
            new_buffer[i] = buffer[(front_idx + i) % capacity];
20
        }
21
        delete[] buffer;
22
        buffer = new_buffer;
23
        capacity = new_capacity;
24
        front_idx = 0;
25
        back_idx = count;
26
    }
27

28
public:
29
    // 构造函数
30
    Deque(size_t initial_capacity = 8)
31
        : capacity(initial_capacity), front_idx(0), back_idx(0), count(0) {
32
        buffer = new T[capacity];
33
    }
34

35
    // 析构函数
36
    ~Deque() {
37
        delete[] buffer;
38
    }
39

40
    // 复制构造函数和赋值运算符（省略，为简洁起见）
41

42
    // 检查是否为空
43
    bool empty() const {
44
        return count == 0;
45
    }
46

47
    // 获取大小
48
    size_t size() const {
49
        return count;
50
    }
51

52
    // 在前面插入元素
53
    void push_front(const T& value) {
54
        if (count == capacity) {
55
            resize(capacity * 2);
56
        }
57
        front_idx = (front_idx == 0) ? capacity - 1 : front_idx - 1;
58
        buffer[front_idx] = value;
59
        ++count;
60
    }
61

62
    // 在后面插入元素
63
    void push_back(const T& value) {
64
        if (count == capacity) {
65
            resize(capacity * 2);
66
        }
67
        buffer[back_idx] = value;
68
        back_idx = (back_idx + 1) % capacity;
69
        ++count;
70
    }
71

72
    // 从前面删除元素
73
    void pop_front() {
74
        if (empty()) {
75
            throw std::out_of_range("Deque is empty");
76
        }
77
        front_idx = (front_idx + 1) % capacity;
78
        --count;
79
    }
80

81
    // 从后面删除元素
82
    void pop_back() {
83
        if (empty()) {
84
            throw std::out_of_range("Deque is empty");
85
        }
86
        back_idx = (back_idx == 0) ? capacity - 1 : back_idx - 1;
87
        --count;
88
    }
89

90
    // 获取前端元素
91
    T& front() {
92
        if (empty()) {
93
            throw std::out_of_range("Deque is empty");
94
        }
95
        return buffer[front_idx];
96
    }
97

98
    const T& front() const {
99
        if (empty()) {
100
            throw std::out_of_range("Deque is empty");
101
        }
102
        return buffer[front_idx];
103
    }
104

105
    // 获取后端元素
106
    T& back() {
107
        if (empty()) {
108
            throw std::out_of_range("Deque is empty");
109
        }
110
        size_t last_idx = (back_idx == 0) ? capacity - 1 : back_idx - 1;
111
        return buffer[last_idx];
112
    }
113

114
    const T& back() const {
115
        if (empty()) {
116
            throw std::out_of_range("Deque is empty");
117
        }
118
        size_t last_idx = (back_idx == 0) ? capacity - 1 : back_idx - 1;
119
        return buffer[last_idx];
120
    }
121

122
    // 迭代器类将放在这里（见下一部分）
123

124
    // 迭代器类定义
125
    class Iterator {
126
    private:
127
        Deque<T>* deque_ptr;
128
        size_t index;
129
        size_t pos;
130

131
    public:
132
        using iterator_category = std::bidirectional_iterator_tag;
133
        using value_type        = T;
134
        using difference_type   = std::ptrdiff_t;
135
        using pointer           = T*;
136
        using reference         = T&;
137

138
        Iterator(Deque<T>* deque, size_t position)
139
            : deque_ptr(deque), pos(position) {}
140

141
        // 解引用操作
142
        reference operator*() const {
143
            size_t real_idx = (deque_ptr->front_idx + pos) % deque_ptr->capacity;
144
            return deque_ptr->buffer[real_idx];
145
        }
146

147
        pointer operator->() const {
148
            size_t real_idx = (deque_ptr->front_idx + pos) % deque_ptr->capacity;
149
            return &(deque_ptr->buffer[real_idx]);
150
        }
151

152
        // 前置递增
153
        Iterator& operator++() {
154
            ++pos;
155
            return *this;
156
        }
157

158
        // 后置递增
159
        Iterator operator++(int) {
160
            Iterator temp = *this;
161
            ++pos;
162
            return temp;
163
        }
164

165
        // 前置递减
166
        Iterator& operator--() {
167
            --pos;
168
            return *this;
169
        }
170

171
        // 后置递减
172
        Iterator operator--(int) {
173
            Iterator temp = *this;
174
            --pos;
175
            return temp;
176
        }
177

178
        // 比较操作
179
        bool operator==(const Iterator& other) const {
180
            return (deque_ptr == other.deque_ptr) && (pos == other.pos);
181
        }
182

183
        bool operator!=(const Iterator& other) const {
184
            return !(*this == other);
185
        }
186
    };
187

188
    // 获取 begin 迭代器
189
    Iterator begin() {
190
        return Iterator(this, 0);
191
    }
192

193
    // 获取 end 迭代器
194
    Iterator end() {
195
        return Iterator(this, count);
196
    }
197
};

展开收起

3.3 迭代器类#

在上面的 Deque 类中，我们定义了一个嵌套的 Iterator 类。这个迭代器支持前向和后向遍历，并且可以与标准的 C++ 迭代器兼容。

关键点解释：

成员变量：
- deque_ptr：指向包含此迭代器的 Deque 实例。
- pos：相对于队列头部的位置。
重载运算符：
- operator* 和 operator->：用于访问当前元素。
- operator++ 和 operator--：前置和后置递增和递减，用于移动迭代器。
- operator== 和 operator!=：用于比较两个迭代器是否相同。
注意事项：
- 迭代器并不管理元素的生命周期，只是提供遍历接口。
- 迭代器的有效性依赖于队列的修改操作（如插入和删除）。在实际应用中，需要注意迭代器失效的问题。

4. 使用示例#

下面是一个使用上述 Deque 类及其迭代器的示例程序：

1
#include <iostream>
2
#include <string>
3

4
// 假设 Deque 类已经定义在这里
5

6
int main() {
7
    Deque<std::string> dq;
8

9
    // 在后面插入元素
10
    dq.push_back("Apple");
11
    dq.push_back("Banana");
12
    dq.push_back("Cherry");
13

14
    // 在前面插入元素
15
    dq.push_front("Date");
16
    dq.push_front("Elderberry");
17

18
    // 显示队列大小
19
    std::cout << "Deque 大小: " << dq.size() << std::endl;
20

21
    // 使用迭代器进行遍历
22
    std::cout << "Deque 元素: ";
23
    for (auto it = dq.begin(); it != dq.end(); ++it) {
24
        std::cout << *it << " ";
25
    }
26
    std::cout << std::endl;
27

28
    // 访问前端和后端元素
29
    std::cout << "前端元素: " << dq.front() << std::endl;
30
    std::cout << "后端元素: " << dq.back() << std::endl;
31

32
    // 删除元素
33
    dq.pop_front();
34
    dq.pop_back();
35

36
    // 再次遍历
37
    std::cout << "删除元素后的 Deque: ";
38
    for (auto it = dq.begin(); it != dq.end(); ++it) {
39
        std::cout << *it << " ";
40
    }
41
    std::cout << std::endl;
42

43
    return 0;
44
}

展开收起

预期输出#

1
Deque 大小: 5
2
Deque 元素: Elderberry Date Apple Banana Cherry
3
前端元素: Elderberry
4
后端元素: Cherry
5
删除元素后的 Deque: Date Apple Banana

解释：

插入操作：
- 使用 push_back 在队列的后端插入 “Apple”, “Banana”, “Cherry”。
- 使用 push_front 在队列的前端插入 “Date”, “Elderberry”。
- 最终队列顺序为：Elderberry, Date, Apple, Banana, Cherry
遍历操作：
- 使用迭代器从 begin() 到 end() 遍历并打印所有元素。
访问元素：
- 使用 front() 获取队列前端的元素。
- 使用 back() 获取队列后端的元素。
删除操作：
- 使用 pop_front 删除前端元素（“Elderberry”）。
- 使用 pop_back 删除后端元素（“Cherry”）。
- 删除后，队列顺序为：Date, Apple, Banana

5. 完整代码#

以下是完整的 Deque 类及其使用示例代码：

1
#include <iostream>
2
#include <stdexcept>
3
#include <iterator>
4

5
// Deque 类定义
6
template <typename T>
7
class Deque {
8
private:
9
    T* buffer;               // 内部缓冲区
10
    size_t capacity;         // 缓冲区容量
11
    size_t front_idx;        // 头部索引
12
    size_t back_idx;         // 尾部索引
13
    size_t count;            // 当前元素数量
14

15
    // 调整容量
16
    void resize(size_t new_capacity) {
17
        T* new_buffer = new T[new_capacity];
18
        // 重新排列元素
19
        for (size_t i = 0; i < count; ++i) {
20
            new_buffer[i] = buffer[(front_idx + i) % capacity];
21
        }
22
        delete[] buffer;
23
        buffer = new_buffer;
24
        capacity = new_capacity;
25
        front_idx = 0;
26
        back_idx = count;
27
    }
28

29
public:
30
    // 构造函数
31
    Deque(size_t initial_capacity = 8)
32
        : capacity(initial_capacity), front_idx(0), back_idx(0), count(0) {
33
        buffer = new T[capacity];
34
    }
35

36
    // 析构函数
37
    ~Deque() {
38
        delete[] buffer;
39
    }
40

41
    // 禁用复制构造函数和赋值运算符（为了简洁，可根据需要实现）
42
    Deque(const Deque& other) = delete;
43
    Deque& operator=(const Deque& other) = delete;
44

45
    // 检查是否为空
46
    bool empty() const {
47
        return count == 0;
48
    }
49

50
    // 获取大小
51
    size_t size() const {
52
        return count;
53
    }
54

55
    // 在前面插入元素
56
    void push_front(const T& value) {
57
        if (count == capacity) {
58
            resize(capacity * 2);
59
        }
60
        front_idx = (front_idx == 0) ? capacity - 1 : front_idx - 1;
61
        buffer[front_idx] = value;
62
        ++count;
63
    }
64

65
    // 在后面插入元素
66
    void push_back(const T& value) {
67
        if (count == capacity) {
68
            resize(capacity * 2);
69
        }
70
        buffer[back_idx] = value;
71
        back_idx = (back_idx + 1) % capacity;
72
        ++count;
73
    }
74

75
    // 从前面删除元素
76
    void pop_front() {
77
        if (empty()) {
78
            throw std::out_of_range("Deque is empty");
79
        }
80
        front_idx = (front_idx + 1) % capacity;
81
        --count;
82
    }
83

84
    // 从后面删除元素
85
    void pop_back() {
86
        if (empty()) {
87
            throw std::out_of_range("Deque is empty");
88
        }
89
        back_idx = (back_idx == 0) ? capacity - 1 : back_idx - 1;
90
        --count;
91
    }
92

93
    // 获取前端元素
94
    T& front() {
95
        if (empty()) {
96
            throw std::out_of_range("Deque is empty");
97
        }
98
        return buffer[front_idx];
99
    }
100

101
    const T& front() const {
102
        if (empty()) {
103
            throw std::out_of_range("Deque is empty");
104
        }
105
        return buffer[front_idx];
106
    }
107

108
    // 获取后端元素
109
    T& back() {
110
        if (empty()) {
111
            throw std::out_of_range("Deque is empty");
112
        }
113
        size_t last_idx = (back_idx == 0) ? capacity - 1 : back_idx - 1;
114
        return buffer[last_idx];
115
    }
116

117
    const T& back() const {
118
        if (empty()) {
119
            throw std::out_of_range("Deque is empty");
120
        }
121
        size_t last_idx = (back_idx == 0) ? capacity - 1 : back_idx - 1;
122
        return buffer[last_idx];
123
    }
124

125
    // 迭代器类定义
126
    class Iterator {
127
    private:
128
        Deque<T>* deque_ptr;
129
        size_t pos;
130

131
    public:
132
        using iterator_category = std::bidirectional_iterator_tag;
133
        using value_type        = T;
134
        using difference_type   = std::ptrdiff_t;
135
        using pointer           = T*;
136
        using reference         = T&;
137

138
        Iterator(Deque<T>* deque, size_t position)
139
            : deque_ptr(deque), pos(position) {}
140

141
        // 解引用操作
142
        reference operator*() const {
143
            size_t real_idx = (deque_ptr->front_idx + pos) % deque_ptr->capacity;
144
            return deque_ptr->buffer[real_idx];
145
        }
146

147
        pointer operator->() const {
148
            size_t real_idx = (deque_ptr->front_idx + pos) % deque_ptr->capacity;
149
            return &(deque_ptr->buffer[real_idx]);
150
        }
151

152
        // 前置递增
153
        Iterator& operator++() {
154
            ++pos;
155
            return *this;
156
        }
157

158
        // 后置递增
159
        Iterator operator++(int) {
160
            Iterator temp = *this;
161
            ++pos;
162
            return temp;
163
        }
164

165
        // 前置递减
166
        Iterator& operator--() {
167
            --pos;
168
            return *this;
169
        }
170

171
        // 后置递减
172
        Iterator operator--(int) {
173
            Iterator temp = *this;
174
            --pos;
175
            return temp;
176
        }
177

178
        // 比较操作
179
        bool operator==(const Iterator& other) const {
180
            return (deque_ptr == other.deque_ptr) && (pos == other.pos);
181
        }
182

183
        bool operator!=(const Iterator& other) const {
184
            return !(*this == other);
185
        }
186
    };
187

188
    // 获取 begin 迭代器
189
    Iterator begin() {
190
        return Iterator(this, 0);
191
    }
192

193
    // 获取 end 迭代器
194
    Iterator end() {
195
        return Iterator(this, count);
196
    }
197
};
198

199
// 使用示例
200
int main() {
201
    Deque<std::string> dq;
202

203
    // 在后面插入元素
204
    dq.push_back("Apple");
205
    dq.push_back("Banana");
206
    dq.push_back("Cherry");
207

208
    // 在前面插入元素
209
    dq.push_front("Date");
210
    dq.push_front("Elderberry");
211

212
    // 显示队列大小
213
    std::cout << "Deque 大小: " << dq.size() << std::endl;
214

215
    // 使用迭代器进行遍历
216
    std::cout << "Deque 元素: ";
217
    for (auto it = dq.begin(); it != dq.end(); ++it) {
218
        std::cout << *it << " ";
219
    }
220
    std::cout << std::endl;
221

222
    // 访问前端和后端元素
223
    std::cout << "前端元素: " << dq.front() << std::endl;
224
    std::cout << "后端元素: " << dq.back() << std::endl;
225

226
    // 删除元素
227
    dq.pop_front();
228
    dq.pop_back();
229

230
    // 再次遍历
231
    std::cout << "删除元素后的 Deque: ";
232
    for (auto it = dq.begin(); it != dq.end(); ++it) {
233
        std::cout << *it << " ";
234
    }
235
    std::cout << std::endl;
236

237
    return 0;
238
}

展开收起

编译和运行#

保存上述代码到一个文件，例如 DequeWithIterator.cpp，然后使用 C++ 编译器进行编译和运行：

Terminal window

1
g++ -std=c++11 -o DequeWithIterator DequeWithIterator.cpp
2
./DequeWithIterator

预期输出#

1
Deque 大小: 5
2
Deque 元素: Elderberry Date Apple Banana Cherry
3
前端元素: Elderberry
4
后端元素: Cherry
5
删除元素后的 Deque: Date Apple Banana

6. 总结#

通过上述步骤，我们成功实现了一个支持双端插入和删除的双端队列（deque），并添加了迭代器支持，使其能够与标准的 C++ 迭代器接口兼容。这个实现包含了以下关键点：

内部缓冲区管理：
- 使用动态数组并采用环形缓冲区的方式，支持高效的双端操作。
- 自动调整缓冲区的容量，确保在元素数量增加时仍能保持高效。
迭代器实现：
- 定义了一个嵌套的 Iterator 类，支持前向和后向遍历。
- 重载了必要的运算符（如 *, ->, ++, --, ==, !=），以实现与标准迭代器的兼容。
基本操作：
- push_front 和 push_back：分别在队列的前端和后端插入元素。
- pop_front 和 pop_back：分别从队列的前端和后端删除元素。
- front 和 back：访问队列的前端和后端元素。

stl容器

Sat, 23 May 2026 00:00:00 GMT

简介#

C++的标准模板库（STL）提供了多种通用容器，用于存储和管理数据。这些容器各有特点，适用于不同的应用场景。理解每种容器的用法和内部实现原理，对于编写高效且可维护的代码至关重要。本教案将详细介绍几种常用的STL容器，包括vector、list、deque、map、unordered_map、set、unordered_set以及容器适配器如stack、queue和priority_queue。

`vector`：动态数组#

用法#

vector是STL中最常用的序列容器之一，提供了动态大小的数组功能。它支持随机访问，允许在末尾高效地添加和删除元素。

内部实现原理#

vector在内部使用动态数组（通常是连续的内存块）来存储元素。当需要扩展容量时，它会分配一块更大的内存，将现有元素复制到新内存中，然后释放旧内存。这种策略在平均情况下保证了push_back的常数时间复杂度。

性能特性#

随机访问：支持常数时间的随机访问（O(1)）。
末尾插入/删除：push_back和pop_back操作在摊销分析下是常数时间（O(1)）。
中间插入/删除：在中间位置插入或删除元素需要移动后续元素，时间复杂度为线性时间（O(n)）。

应用场景#

需要频繁随机访问元素。
主要在容器末尾进行插入和删除操作。
当容器大小不需要频繁调整（避免频繁的内存重新分配）。

代码示例#

1
#include <iostream>
2
#include <vector>
3

4
int main() {
5
    // 创建一个空的整数vector
6
    std::vector<int> numbers;
7

8
    // 向vector末尾添加元素
9
    numbers.push_back(10);
10
    numbers.push_back(20);
11
    numbers.push_back(30);
12

13
    // 通过索引访问元素
14
    std::cout << "第一个元素: " << numbers[0] << std::endl;
15

16
    // 遍历vector
17
    std::cout << "所有元素: ";
18
    for(auto it = numbers.begin(); it != numbers.end(); ++it) {
19
        std::cout << *it << " ";
20
    }
21
    std::cout << std::endl;
22

23
    // 删除最后一个元素
24
    numbers.pop_back();
25

26
    // 打印删除后的vector
27
    std::cout << "删除最后一个元素后: ";
28
    for(auto num : numbers) {
29
        std::cout << num << " ";
30
    }
31
    std::cout << std::endl;
32

33
    return 0;
34
}

展开收起

输出#

1
第一个元素: 10
2
所有元素: 10 20 30
3
删除最后一个元素后: 10 20

`list`：双向链表#

用法#

list是一个实现了双向链表的数据结构，适合在容器中间频繁插入和删除元素。与vector不同，list不支持随机访问，但在任何位置的插入和删除操作都是常数时间。

内部实现原理#

list在内部使用双向链表，每个元素包含指向前一个和后一个元素的指针。这使得在已知位置插入或删除元素时，无需移动其他元素，只需更新指针即可。

性能特性#

随机访问：不支持随机访问，访问第n个元素需要线性时间（O(n)）。
中间插入/删除：已知位置的插入和删除操作是常数时间（O(1)）。
遍历：顺序遍历，适合需要频繁遍历但不需要随机访问的场景。

应用场景#

需要在容器中间频繁插入或删除元素。
不需要进行随机访问。
对内存的局部性要求不高（链表元素在内存中不连续）。

代码示例#

1
#include <iostream>
2
#include <list>
3

4
int main() {
5
    // 创建一个空的整数list
6
    std::list<int> numbers;
7

8
    // 向list末尾添加元素
9
    numbers.push_back(100);
10
    numbers.push_back(200);
11
    numbers.push_back(300);
12

13
    // 向list前端添加元素
14
    numbers.push_front(50);
15

16
    // 遍历list
17
    std::cout << "所有元素: ";
18
    for(auto it = numbers.begin(); it != numbers.end(); ++it) {
19
        std::cout << *it << " ";
20
    }
21
    std::cout << std::endl;
22

23
    // 插入元素
24
    auto it = numbers.begin();
25
    ++it; // 指向第二个元素
26
    numbers.insert(it, 150);
27

28
    // 打印插入后的list
29
    std::cout << "插入元素后: ";
30
    for(auto num : numbers) {
31
        std::cout << num << " ";
32
    }
33
    std::cout << std::endl;
34

35
    // 删除元素
36
    numbers.remove(200);
37

38
    // 打印删除后的list
39
    std::cout << "删除元素后: ";
40
    for(auto num : numbers) {
41
        std::cout << num << " ";
42
    }
43
    std::cout << std::endl;
44

45
    return 0;
46
}

展开收起

输出#

1
所有元素: 50 100 200 300
2
插入元素后: 50 150 100 200 300
3
删除元素后: 50 150 100 300

模拟实现一个简化版的 `List`#

为了更好地理解 std::list 的内部工作原理，我们可以尝试模拟实现一个简化版的双向链表。下面将逐步介绍如何设计和实现这个 List 类。

类设计#

我们的 List 类将包含以下组件：

节点结构体（Node）：表示链表的每个节点。
迭代器类（Iterator）：允许用户遍历链表。
List** 类**：管理链表的基本操作，如插入、删除和遍历。

节点结构体#

每个节点包含数据域和前后指针：

1
template<typename T>
2
struct Node {
3
    T data;
4
    Node* prev;
5
    Node* next;
6

7
    Node(const T& value = T()) : data(value), prev(nullptr), next(nullptr) {}
8
};

迭代器实现#

为了实现双向迭代器，我们需要定义一个 Iterator 类，支持 ++ 和 -- 操作。

1
template<typename T>
2
class List;
3

4
template<typename T>
5
class Iterator {
6
public:
7
    using self_type = Iterator<T>;
8
    using value_type = T;
9
    using reference = T&;
10
    using pointer = T*;
11
    using iterator_category = std::bidirectional_iterator_tag;
12
    using difference_type = std::ptrdiff_t;
13

14
    Iterator(Node<T>* ptr = nullptr) : node_ptr(ptr) {}
15

16
    // Dereference operator
17
    reference operator*() const { return node_ptr->data; }
18

19
    // Arrow operator
20
    pointer operator->() const { return &(node_ptr->data); }
21

22
    // Pre-increment
23
    self_type& operator++() {
24
        if (node_ptr) node_ptr = node_ptr->next;
25
        return *this;
26
    }
27

28
    // Post-increment
29
    self_type operator++(int) {
30
        self_type temp = *this;
31
        ++(*this);
32
        return temp;
33
    }
34

35
    // Pre-decrement
36
    self_type& operator--() {
37
        if (node_ptr) node_ptr = node_ptr->prev;
38
        return *this;
39
    }
40

41
    // Post-decrement
42
    self_type operator--(int) {
43
        self_type temp = *this;
44
        --(*this);
45
        return temp;
46
    }
47

48
    // Equality comparison
49
    bool operator==(const self_type& other) const {
50
        return node_ptr == other.node_ptr;
51
    }
52

53
    // Inequality comparison
54
    bool operator!=(const self_type& other) const {
55
        return node_ptr != other.node_ptr;
56
    }
57

58
private:
59
    Node<T>* node_ptr;
60

61
    friend class List<T>;
62
};

展开收起

`List` 类#

List 类提供链表的基本功能。

1
#include <iostream>
2

3
template<typename T>
4
class List {
5
public:
6
    using iterator = Iterator<T>;
7
    using const_iterator = Iterator<T>;
8

9
    // 构造函数
10
    List() {
11
        head = new Node<T>(); // 哨兵节点
12
        tail = new Node<T>(); // 哨兵节点
13
        head->next = tail;
14
        tail->prev = head;
15
    }
16

17
    // 析构函数
18
    ~List() {
19
        clear();
20
        delete head;
21
        delete tail;
22
    }
23

24
    // 禁止拷贝构造和赋值操作（简化实现）
25
    List(const List& other) = delete;
26
    List& operator=(const List& other) = delete;
27

28
    // 插入元素到迭代器位置之前
29
    iterator insert(iterator pos, const T& value) {
30
        Node<T>* current = pos.node_ptr;
31
        Node<T>* new_node = new Node<T>(value);
32

33
        Node<T>* prev_node = current->prev;
34

35
        new_node->next = current;
36
        new_node->prev = prev_node;
37

38
        prev_node->next = new_node;
39
        current->prev = new_node;
40

41
        return iterator(new_node);
42
    }
43

44
    // 删除迭代器指向的元素
45
    iterator erase(iterator pos) {
46
        Node<T>* current = pos.node_ptr;
47
        if (current == head || current == tail) {
48
            // 不能删除哨兵节点
49
            return pos;
50
        }
51

52
        Node<T>* prev_node = current->prev;
53
        Node<T>* next_node = current->next;
54

55
        prev_node->next = next_node;
56
        next_node->prev = prev_node;
57

58
        delete current;
59

60
        return iterator(next_node);
61
    }
62

63
    // 在头部插入元素
64
    void push_front(const T& value) {
65
        insert(begin(), value);
66
    }
67

68
    // 在尾部插入元素
69
    void push_back(const T& value) {
70
        insert(end(), value);
71
    }
72

73
    // 在头部删除元素
74
    void pop_front() {
75
        if (!empty()) {
76
            erase(begin());
77
        }
78
    }
79

80
    // 在尾部删除元素
81
    void pop_back() {
82
        if (!empty()) {
83
            iterator temp = end();
84
            --temp;
85
            erase(temp);
86
        }
87
    }
88

89
    // 获取头元素引用
90
    T& front() {
91
        return head->next->data;
92
    }
93

94
    // 获取尾元素引用
95
    T& back() {
96
        return tail->prev->data;
97
    }
98

99
    // 判断是否为空
100
    bool empty() const {
101
        return head->next == tail;
102
    }
103

104
    // 获取链表大小（O(n)复杂度）
105
    size_t size() const {
106
        size_t count = 0;
107
        for(auto it = begin(); it != end(); ++it) {
108
            ++count;
109
        }
110
        return count;
111
    }
112

113
    // 清空链表
114
    void clear() {
115
        Node<T>* current = head->next;
116
        while(current != tail) {
117
            Node<T>* temp = current;
118
            current = current->next;
119
            delete temp;
120
        }
121
        head->next = tail;
122
        tail->prev = head;
123
    }
124

125
    // 获取开始迭代器
126
    iterator begin() {
127
        return iterator(head->next);
128
    }
129

130
    // 获取结束迭代器
131
    iterator end() {
132
        return iterator(tail);
133
    }
134

135
    // 打印链表（辅助函数）
136
    void print() const {
137
        Node<T>* current = head->next;
138
        while(current != tail) {
139
            std::cout << current->data << " ";
140
            current = current->next;
141
        }
142
        std::cout << std::endl;
143
    }
144

145
private:
146
    Node<T>* head; // 头哨兵
147
    Node<T>* tail; // 尾哨兵
148
};

展开收起

完整代码示例#

下面是一个完整的示例，包括创建 List 对象，进行各种操作，并打印结果。

1
#include <iostream>
2

3
// 节点结构体
4
template<typename T>
5
struct Node {
6
    T data;
7
    Node* prev;
8
    Node* next;
9

10
    Node(const T& value = T()) : data(value), prev(nullptr), next(nullptr) {}
11
};
12

13
// 迭代器类
14
template<typename T>
15
class Iterator {
16
public:
17
    using self_type = Iterator<T>;
18
    using value_type = T;
19
    using reference = T&;
20
    using pointer = T*;
21
    using iterator_category = std::bidirectional_iterator_tag;
22
    using difference_type = std::ptrdiff_t;
23

24
    Iterator(Node<T>* ptr = nullptr) : node_ptr(ptr) {}
25

26
    // Dereference operator
27
    reference operator*() const { return node_ptr->data; }
28

29
    // Arrow operator
30
    pointer operator->() const { return &(node_ptr->data); }
31

32
    // Pre-increment
33
    self_type& operator++() {
34
        if (node_ptr) node_ptr = node_ptr->next;
35
        return *this;
36
    }
37

38
    // Post-increment
39
    self_type operator++(int) {
40
        self_type temp = *this;
41
        ++(*this);
42
        return temp;
43
    }
44

45
    // Pre-decrement
46
    self_type& operator--() {
47
        if (node_ptr) node_ptr = node_ptr->prev;
48
        return *this;
49
    }
50

51
    // Post-decrement
52
    self_type operator--(int) {
53
        self_type temp = *this;
54
        --(*this);
55
        return temp;
56
    }
57

58
    // Equality comparison
59
    bool operator==(const self_type& other) const {
60
        return node_ptr == other.node_ptr;
61
    }
62

63
    // Inequality comparison
64
    bool operator!=(const self_type& other) const {
65
        return node_ptr != other.node_ptr;
66
    }
67

68
private:
69
    Node<T>* node_ptr;
70

71
    friend class List<T>;
72
};
73

74
// List 类
75
template<typename T>
76
class List {
77
public:
78
    using iterator = Iterator<T>;
79
    using const_iterator = Iterator<T>;
80

81
    // 构造函数
82
    List() {
83
        head = new Node<T>(); // 头哨兵
84
        tail = new Node<T>(); // 尾哨兵
85
        head->next = tail;
86
        tail->prev = head;
87
    }
88

89
    // 析构函数
90
    ~List() {
91
        clear();
92
        delete head;
93
        delete tail;
94
    }
95

96
    // 禁止拷贝构造和赋值操作（简化实现）
97
    List(const List& other) = delete;
98
    List& operator=(const List& other) = delete;
99

100
    // 插入元素到迭代器位置之前
101
    iterator insert(iterator pos, const T& value) {
102
        Node<T>* current = pos.node_ptr;
103
        Node<T>* new_node = new Node<T>(value);
104

105
        Node<T>* prev_node = current->prev;
106

107
        new_node->next = current;
108
        new_node->prev = prev_node;
109

110
        prev_node->next = new_node;
111
        current->prev = new_node;
112

113
        return iterator(new_node);
114
    }
115

116
    // 删除迭代器指向的元素
117
    iterator erase(iterator pos) {
118
        Node<T>* current = pos.node_ptr;
119
        if (current == head || current == tail) {
120
            // 不能删除哨兵节点
121
            return pos;
122
        }
123

124
        Node<T>* prev_node = current->prev;
125
        Node<T>* next_node = current->next;
126

127
        prev_node->next = next_node;
128
        next_node->prev = prev_node;
129

130
        delete current;
131

132
        return iterator(next_node);
133
    }
134

135
    // 在头部插入元素
136
    void push_front(const T& value) {
137
        insert(begin(), value);
138
    }
139

140
    // 在尾部插入元素
141
    void push_back(const T& value) {
142
        insert(end(), value);
143
    }
144

145
    // 在头部删除元素
146
    void pop_front() {
147
        if (!empty()) {
148
            erase(begin());
149
        }
150
    }
151

152
    // 在尾部删除元素
153
    void pop_back() {
154
        if (!empty()) {
155
            iterator temp = end();
156
            --temp;
157
            erase(temp);
158
        }
159
    }
160

161
    // 获取头元素引用
162
    T& front() {
163
        return head->next->data;
164
    }
165

166
    // 获取尾元素引用
167
    T& back() {
168
        return tail->prev->data;
169
    }
170

171
    // 判断是否为空
172
    bool empty() const {
173
        return head->next == tail;
174
    }
175

176
    // 获取链表大小（O(n)复杂度）
177
    size_t size() const {
178
        size_t count = 0;
179
        for(auto it = begin(); it != end(); ++it) {
180
            ++count;
181
        }
182
        return count;
183
    }
184

185
    // 清空链表
186
    void clear() {
187
        Node<T>* current = head->next;
188
        while(current != tail) {
189
            Node<T>* temp = current;
190
            current = current->next;
191
            delete temp;
192
        }
193
        head->next = tail;
194
        tail->prev = head;
195
    }
196

197
    // 获取开始迭代器
198
    iterator begin() {
199
        return iterator(head->next);
200
    }
201

202
    // 获取结束迭代器
203
    iterator end() {
204
        return iterator(tail);
205
    }
206

207
    // 打印链表（辅助函数）
208
    void print() const {
209
        Node<T>* current = head->next;
210
        while(current != tail) {
211
            std::cout << current->data << " ";
212
            current = current->next;
213
        }
214
        std::cout << std::endl;
215
    }
216

217
private:
218
    Node<T>* head; // 头哨兵
219
    Node<T>* tail; // 尾哨兵
220
};
221

222
// 测试代码
223
int main() {
224
    List<int> lst;
225

226
    // 插入元素
227
    lst.push_back(10);    // 链表: 10
228
    lst.push_front(5);    // 链表: 5, 10
229
    lst.push_back(15);    // 链表: 5, 10, 15
230
    lst.insert(++lst.begin(), 7); // 链表: 5, 7, 10, 15
231

232
    // 打印链表
233
    std::cout << "链表内容: ";
234
    lst.print(); // 输出: 5 7 10 15
235

236
    // 删除元素
237
    lst.pop_front(); // 链表: 7, 10, 15
238
    lst.pop_back();  // 链表: 7, 10
239

240
    // 打印链表
241
    std::cout << "删除头尾后链表内容: ";
242
    lst.print(); // 输出: 7 10
243

244
    // 插入和删除
245
    auto it = lst.begin();
246
    lst.insert(it, 3);  // 链表: 3, 7, 10
247
    lst.erase(++it);    // 链表: 3, 10
248

249
    // 打印链表
250
    std::cout << "插入和删除后链表内容: ";
251
    lst.print(); // 输出: 3 10
252

253
    // 清空链表
254
    lst.clear();
255
    std::cout << "清空后，链表是否为空: " << (lst.empty() ? "是" : "否") << std::endl;
256

257
    return 0;
258
}

展开收起

代码解释#

**节点结构体 **Node：包含数据域 data，前驱指针 prev 和后继指针 next。
**迭代器类 **Iterator：
- 构造函数：接受一个 Node<T>* 指针。
- 重载操作符：
 - * 和 -> 用于访问节点数据。
 - ++ 和 -- 支持前向和后向遍历。
 - == 和 != 用于比较迭代器。
List** 类**：
- 成员变量：
  - head 和 tail 是头尾哨兵节点。
- 构造函数：初始化头尾哨兵，并将它们互相连接。
- 析构函数：清空链表并删除哨兵节点。
- insert：在指定位置前插入新节点。
- erase：删除指定位置的节点。
- push_front** 和 **push_back：分别在头部和尾部插入元素。
- pop_front** 和 **pop_back：分别删除头部和尾部元素。
- front** 和 **back：访问头尾元素。
- empty** 和 **size：检查链表是否为空和获取链表大小。
- clear：清空链表。
- begin** 和 **end：返回开始和结束迭代器。
- print：辅助函数，用于打印链表内容。
测试代码：创建 List<int> 对象，并执行一系列的插入、删除和遍历操作，验证 List 类的功能。

编译和运行#

保存上述代码到一个名为 List.cpp 的文件中，然后使用以下命令编译和运行：

Terminal window

1
g++ -std=c++11 -o List List.cpp
2
./List

输出结果：

1
链表内容: 5 7 10 15
2
删除头尾后链表内容: 7 10
3
插入和删除后链表内容: 3 10
4
清空后，链表是否为空: 是

迭代器分类#

1. 迭代器（Iterator）简介#

在 C++ 中，迭代器 是一种用于遍历容器（如 std::vector、std::list 等）元素的对象。它们提供了类似指针的接口，使得算法可以独立于具体的容器而工作。迭代器的设计允许算法以统一的方式处理不同类型的容器。

2. 迭代器类别（Iterator Categories）#

为了使不同类型的迭代器能够支持不同的操作，C++ 标准库将迭代器分为以下几种类别，每种类别支持的操作能力逐级增强：

输入迭代器（Input Iterator）
输出迭代器（Output Iterator）
前向迭代器（Forward Iterator）
双向迭代器（Bidirectional Iterator）
随机访问迭代器（Random Access Iterator）
无效迭代器（Contiguous Iterator）（C++20 引入）

每个类别都继承自前一个类别，具备更强的功能。例如，双向迭代器不仅支持前向迭代器的所有操作，还支持反向迭代（即可以向后移动）。

主要迭代器类别及其特性

类别	支持的操作	示例容器
输入迭代器	只读访问、单向前进	单向链表 `std::forward_list`
输出迭代器	只写访问、单向前进	输出流 `std::ostream_iterator`
前向迭代器	读写访问、单向前进	向量 `std::vector`
双向迭代器	读写访问、单向前进和反向迭代	双向链表 `std::list`
随机访问迭代器	读写访问、单向前进、反向迭代、跳跃移动（支持算术运算）	向量 `std::vector`、队列 `std::deque`
无效迭代器（新）	随机访问迭代器的所有功能，且元素在内存中连续排列	新的 C++ 容器如 `std::span`

3. `iterator_category` 的作用#

iterator_category 是迭代器类型中的一个别名，用于标识该迭代器所属的类别。它是标准库中 迭代器特性（Iterator Traits） 的一部分，标准算法会根据迭代器的类别优化其行为。

为什么需要 `iterator_category`#

标准库中的算法（如 std::sort、std::find 等）需要知道迭代器支持哪些操作，以便选择最优的实现方式。例如：

对于随机访问迭代器，可以使用快速的随机访问算法（如快速排序）。
对于双向迭代器，只能使用适用于双向迭代的算法（如归并排序）。
对于输入迭代器，只能进行单次遍历，许多复杂算法无法使用。

通过指定 iterator_category，你可以让标准算法了解你自定义迭代器的能力，从而选择合适的方法进行操作。

`iterator_category` 的声明#

在你的自定义迭代器类中，通过以下方式声明迭代器类别：

1
using iterator_category = std::bidirectional_iterator_tag;

这表示该迭代器是一个 双向迭代器，支持向前和向后遍历。

4. `std::bidirectional_iterator_tag` 详解#

std::bidirectional_iterator_tag 是一个标签（Tag），用于标识迭代器类别。C++ 标准库中有多个这样的标签，分别对应不同的迭代器类别：

std::input_iterator_tag
std::output_iterator_tag
std::forward_iterator_tag
std::bidirectional_iterator_tag
std::random_access_iterator_tag
std::contiguous_iterator_tag（C++20）

这些标签本质上是空的结构体，用于类型区分。在标准算法中，通常会通过这些标签进行 重载选择（Overload Resolution） 或 特化（Specialization），以实现针对不同迭代器类别的优化。

继承关系#

迭代器标签是有继承关系的：

std::forward_iterator_tag 继承自 std::input_iterator_tag
std::bidirectional_iterator_tag 继承自 std::forward_iterator_tag
std::random_access_iterator_tag 继承自 std::bidirectional_iterator_tag
std::contiguous_iterator_tag 继承自 std::random_access_iterator_tag

这种继承关系反映了迭代器类别的能力层级。例如，双向迭代器 具备 前向迭代器 的所有能力，加上反向遍历的能力。

5. 迭代器特性（Iterator Traits）详解#

C++ 提供了 迭代器特性（Iterator Traits），通过模板类 std::iterator_traits 来获取迭代器的相关信息。通过这些特性，标准算法可以泛化地处理不同类型的迭代器。

迭代器特性包含的信息#

std::iterator_traits 提供以下信息：

iterator_category：迭代器类别标签。
value_type：迭代器指向的元素类型。
difference_type：迭代器间的距离类型（通常是 std::ptrdiff_t）。
pointer：指向元素的指针类型。
reference：对元素的引用类型。

自定义迭代器与 `iterator_traits`#

当你定义自己的迭代器时，确保提供这些类型别名，以便标准库算法能够正确识别和使用你的迭代器。例如：

1
template<typename T>
2
class Iterator {
3
public:
4
    using iterator_category = std::bidirectional_iterator_tag;
5
    using value_type        = T;
6
    using difference_type   = std::ptrdiff_t;
7
    using pointer           = T*;
8
    using reference         = T&;
9

10
    // 其他成员函数...
11
};

这样，使用 std::iterator_traits<Iterator<T>> 时，就能正确获取迭代器的特性。

`deque`：双端队列#

用法#

deque（双端队列）是一种支持在两端高效插入和删除元素的序列容器。与vector相比，deque支持在前端和后端均以常数时间进行插入和删除操作。

内部实现原理#

deque通常由一系列固定大小的数组块组成，这些块通过一个中央映射数组进行管理。这种结构使得在两端扩展时不需要重新分配整个容器的内存，从而避免了vector在前端插入的高成本。

性能特性#

随机访问：支持常数时间的随机访问（O(1)）。
前后插入/删除：在前端和后端插入和删除元素的操作都是常数时间（O(1)）。
中间插入/删除：在中间位置插入或删除元素需要移动元素，时间复杂度为线性时间（O(n)）。

应用场景#

需要在容器两端频繁插入和删除元素。
需要随机访问元素。
不需要频繁在中间位置插入和删除元素。

双端队列简介#

**双端队列（deque）**是一种序列容器，允许在其两端高效地插入和删除元素。与vector不同，deque不仅支持在末尾添加或删除元素（如vector），还支持在头部进行同样的操作。此外，deque提供了随机访问能力，可以像vector一样通过索引访问元素。

主要特点#

双端操作：支持在头部和尾部高效的插入和删除操作。
随机访问：可以像数组和vector一样通过索引访问元素。
动态大小：可以根据需要增长和收缩，无需预先定义大小。

内存分配策略#

deque内部并不使用一个单一的连续内存块，而是将元素分割成多个固定大小的块（也称为缓冲区或页面），并通过一个中央映射数组（通常称为map）来管理这些块。具体来说，deque的内部结构可以分为以下几个部分：

中央映射数组（Map）：
- 一个指针数组，指向各个数据块。
- map本身也是动态分配的，可以根据需要增长或收缩。
- map允许deque在两端添加新的数据块，而无需移动现有的数据块。
数据块（Blocks）：
- 每个数据块是一个固定大小的连续内存区域，用于存储元素。
- 数据块的大小通常与编译器和平台相关，但在大多数实现中，数据块的大小在运行时是固定的（如512字节或更多，具体取决于元素类型的大小）。
起始和结束指针：
- deque维护指向中央映射数组中第一个有效数据块的指针以及第一个无效数据块的指针。
- 这些指针帮助deque快速地在两端添加或删除数据块。

双端队列的操作实现#

插入操作#

在末尾插入 (push_back)

检查当前末端数据块的剩余空间：
- 如果有空间，直接在当前末端数据块中插入新元素。
- 如果没有空间，分配一个新的数据块，并将其指针添加到map中，然后在新块中插入元素。
更新末尾指针：
- 如果分配了新块，末尾指针指向该块的第一个元素。
- 否则，末尾指针移动到当前末端数据块的下一个位置。

在前端插入 (push_front)

检查当前前端数据块的剩余空间：
- 如果有空间，直接在当前前端数据块中插入新元素。
- 如果没有空间，分配一个新的数据块，并将其指针添加到map的前面，然后在新块中插入元素。
更新前端指针：
- 如果分配了新块，前端指针指向该块的最后一个元素。
- 否则，前端指针移动到当前前端数据块的前一个位置。

删除操作#

从末尾删除 (pop_back)

检查末端数据块是否有元素：
- 如果有，移除最后一个元素，并更新末尾指针。
- 如果数据块变为空，释放该数据块并从map中移除其指针，然后更新末尾指针指向前一个块。

从前端删除 (pop_front)

检查前端数据块是否有元素：
- 如果有，移除第一个元素，并更新前端指针。
- 如果数据块变为空，释放该数据块并从map中移除其指针，然后更新前端指针指向下一个块。

访问操作#

随机访问

deque支持通过索引进行随机访问，其内部机制如下：

计算元素的位置：
- 根据给定的索引，确定对应的数据块和数据块内的偏移量。
- 使用map数组定位到具体的块，然后通过偏移量定位到块内的元素。
访问元素：
- 一旦定位到具体的位置，即可像数组一样访问元素。

迭代器访问

deque提供双向迭代器，支持使用标准的C++迭代器操作（如++、--等）进行遍历。

双端队列的性能特性#

理解deque的内部实现有助于理解其性能特性。以下是deque的主要操作及其时间复杂度：

操作	时间复杂度	说明
随机访问（通过索引）	常数时间（O(1)）	通过计算块和偏移量直接访问元素
插入/删除前端	常数时间（O(1)）	仅涉及前端指针和可能的数据块分配
插入/删除末端	常数时间（O(1)）	仅涉及末端指针和可能的数据块分配
中间插入/删除	线性时间（O(n)）	需要移动数据块内的元素，可能涉及多个块的操作
查找元素	线性时间（O(n)）	需要遍历元素进行查找
插入单个元素	平均常数时间（O(1)）	在前端或末端插入，通常不需移动大量元素
插入大量元素	线性时间（O(n)）	需要分配新的数据块并进行元素复制

优缺点#

优点#

双端操作高效：在两端插入和删除元素非常快速，不需要移动大量元素。
支持随机访问：可以像vector一样通过索引高效访问元素。
动态增长：无需预先定义大小，可以根据需要自动调整。

缺点#

内存碎片：由于使用多个数据块，可能导致内存碎片，尤其是在大量插入和删除操作后。
较低的局部性：元素不连续存储，可能导致缓存未命中率较高，影响性能。
复杂性较高：内部实现相对复杂，不如vector直接高效。

双端队列与其他容器的比较#

特性	`vector`	`deque`	`list`
内存结构	单一连续内存块	多块连续内存，通过映射数组管理	双向链表
随机访问	是，常数时间（O(1)）	是，常数时间（O(1)）	否，需要线性时间（O(n)）
前端插入/删除	低效，线性时间（O(n)）	高效，常数时间（O(1)）	高效，常数时间（O(1)）
末端插入/删除	高效，常数时间（O(1)）	高效，常数时间（O(1)）	高效，常数时间（O(1)）
内存碎片	低，由于单一连续内存块	较高，由于多块内存管理	较高，由于节点分散在内存中
元素隔离	高，局部性较好	中等，分块存储提高了部分局部性	低，元素分散存储，缓存效率低
应用场景	需要频繁随机访问、末端操作的场景	需要频繁在两端插入/删除且偶尔随机访问的场景	需要频繁在中间插入/删除且不需要随机访问的场景

代码示例#

1
#include <iostream>
2
#include <deque>
3

4
int main() {
5
    // 创建一个空的deque
6
    std::deque<std::string> dq;
7

8
    // 在末尾添加元素
9
    dq.push_back("End1");
10
    dq.push_back("End2");
11

12
    // 在前端添加元素
13
    dq.push_front("Front1");
14
    dq.push_front("Front2");
15

16
    // 遍历deque
17
    std::cout << "deque中的元素: ";
18
    for(auto it = dq.begin(); it != dq.end(); ++it) {
19
        std::cout << *it << " ";
20
    }
21
    std::cout << std::endl;
22

23
    // 访问首尾元素
24
    std::cout << "首元素: " << dq.front() << std::endl;
25
    std::cout << "尾元素: " << dq.back() << std::endl;
26

27
    // 删除首元素
28
    dq.pop_front();
29

30
    // 删除尾元素
31
    dq.pop_back();
32

33
    // 打印删除后的deque
34
    std::cout << "删除首尾元素后: ";
35
    for(auto num : dq) {
36
        std::cout << num << " ";
37
    }
38
    std::cout << std::endl;
39

40
    return 0;
41
}

展开收起

输出#

1
deque中的元素: Front2 Front1 End1 End2
2
首元素: Front2
3
尾元素: End2
4
删除首尾元素后: Front1 End1

`map`和`unordered_map`：关联数组#

`map`用法与原理#

用法#

map是一个关联容器，用于存储键值对（key-value）。它基于键自动排序，且每个键都是唯一的。map提供了快速的查找、插入和删除操作。

内部实现原理#

map通常使用自平衡的二叉搜索树（如红黑树）实现。这确保了所有操作的时间复杂度为对数时间（O(log n)），且元素按照键的顺序排列。

`unordered_map`用法与原理#

用法#

unordered_map也是一种关联容器，用于存储键值对，但它不保证元素的顺序。unordered_map基于哈希表实现，提供了平均常数时间（O(1)）的查找、插入和删除操作。

内部实现原理#

unordered_map使用哈希表来存储元素。键通过哈希函数转换为哈希值，并映射到特定的桶中。如果多个键映射到同一桶，会通过链表或其他方法解决冲突。

性能对比#

操作	`map`	`unordered_map`
查找	`O(log n)`	平均 `O(1)`
插入	`O(log n)`	平均 `O(1)`
删除	`O(log n)`	平均 `O(1)`
内存使用	较高	较低
元素顺序	有序	无序

应用场景#

map：
- 需要按键的顺序遍历元素。
- 需要有序的关联数组。
- 需要高效的范围查找。
unordered_map：
- 对元素顺序没有要求。
- 需要极高效的查找、插入和删除操作。
- 不需要自定义的排序规则。

代码示例#

`map`示例#

1
#include <iostream>
2
#include <map>
3
#include <string>
4

5
int main() {
6
    // 创建一个空的map，键为string，值为int
7
    std::map<std::string, int> ageMap;
8

9
    // 插入键值对
10
    ageMap["Alice"] = 30;
11
    ageMap["Bob"] = 25;
12
    ageMap["Charlie"] = 35;
13

14
    // 查找元素
15
    std::string name = "Bob";
16
    if(ageMap.find(name) != ageMap.end()) {
17
        std::cout << name << " 的年龄是 " << ageMap[name] << std::endl;
18
    } else {
19
        std::cout << "未找到 " << name << std::endl;
20
    }
21

22
    // 遍历map
23
    std::cout << "所有人员和年龄: " << std::endl;
24
    for(auto it = ageMap.begin(); it != ageMap.end(); ++it) {
25
        std::cout << it->first << " : " << it->second << std::endl;
26
    }
27

28
    // 删除元素
29
    ageMap.erase("Alice");
30

31
    // 打印删除后的map
32
    std::cout << "删除Alice后: " << std::endl;
33
    for(auto &[key, value] : ageMap) {
34
        std::cout << key << " : " << value << std::endl;
35
    }
36

37
    return 0;
38
}

展开收起

`unordered_map`示例#

1
#include <iostream>
2
#include <unordered_map>
3
#include <string>
4

5
int main() {
6
    // 创建一个空的unordered_map，键为string，值为double
7
    std::unordered_map<std::string, double> priceMap;
8

9
    // 插入键值对
10
    priceMap["Apple"] = 1.2;
11
    priceMap["Banana"] = 0.5;
12
    priceMap["Orange"] = 0.8;
13

14
    // 查找元素
15
    std::string fruit = "Banana";
16
    if(priceMap.find(fruit) != priceMap.end()) {
17
        std::cout << fruit << " 的价格是 $" << priceMap[fruit] << std::endl;
18
    } else {
19
        std::cout << "未找到 " << fruit << std::endl;
20
    }
21

22
    // 遍历unordered_map
23
    std::cout << "所有水果和价格: " << std::endl;
24
    for(auto &[key, value] : priceMap) {
25
        std::cout << key << " : $" << value << std::endl;
26
    }
27

28
    // 删除元素
29
    priceMap.erase("Apple");
30

31
    // 打印删除后的unordered_map
32
    std::cout << "删除Apple后: " << std::endl;
33
    for(auto &[key, value] : priceMap) {
34
        std::cout << key << " : $" << value << std::endl;
35
    }
36

37
    return 0;
38
}

展开收起

输出#

`map`输出#

1
Bob 的年龄是 25
2
所有人员和年龄:
3
Alice : 30
4
Bob : 25
5
Charlie : 35
6
删除Alice后:
7
Bob : 25
8
Charlie : 35

`unordered_map`输出#

Terminal window

1
Banana 的价格是 $0.5
2
所有水果和价格:
3
Apple : $1.2
4
Banana : $0.5
5
Orange : $0.8
6
删除Apple后:
7
Banana : $0.5
8
Orange : $0.8

`set`和`unordered_set`：集合#

`set`用法与原理#

用法#

set是一个关联容器，用于存储唯一的、有序的元素。set基于键自动排序，且每个元素都是唯一的。

内部实现原理#

set通常使用自平衡的二叉搜索树（如红黑树）实现，保证元素按顺序排列。每次插入元素时，都会自动保持树的平衡，并确保元素的唯一性。

`unordered_set`用法与原理#

用法#

unordered_set也是一种集合容器，用于存储唯一的元素，但它不保证元素的顺序。unordered_set基于哈希表实现，提供了平均常数时间（O(1)）的查找、插入和删除操作。

内部实现原理#

unordered_set使用哈希表存储元素。每个元素通过哈希函数转换为哈希值，并映射到特定的桶中。冲突通过链表或其他方法解决。

性能对比#

操作	`set`	`unordered_set`
查找	`O(log n)`	平均 `O(1)`
插入	`O(log n)`	平均 `O(1)`
删除	`O(log n)`	平均 `O(1)`
内存使用	较高	较低
元素顺序	有序	无序

应用场景#

set：
- 需要有序的唯一元素集合。
- 需要按顺序遍历元素。
- 需要基于区间的操作（如查找、删除某范围的元素）。
unordered_set：
- 对元素顺序无要求。
- 需要极高效的查找、插入和删除操作。
- 不需要自定义的排序规则。

代码示例#

`set`示例#

1
#include <iostream>
2
#include <set>
3

4
int main() {
5
    // 创建一个空的整数set
6
    std::set<int> numbers;
7

8
    // 插入元素
9
    numbers.insert(10);
10
    numbers.insert(20);
11
    numbers.insert(30);
12
    numbers.insert(20); // 重复元素，不会被插入
13

14
    // 遍历set
15
    std::cout << "set中的元素: ";
16
    for(auto it = numbers.begin(); it != numbers.end(); ++it) {
17
        std::cout << *it << " ";
18
    }
19
    std::cout << std::endl;
20

21
    // 查找元素
22
    int key = 20;
23
    if(numbers.find(key) != numbers.end()) {
24
        std::cout << key << " 在set中存在。" << std::endl;
25
    } else {
26
        std::cout << key << " 不在set中。" << std::endl;
27
    }
28

29
    // 删除元素
30
    numbers.erase(10);
31

32
    // 打印删除后的set
33
    std::cout << "删除10后set中的元素: ";
34
    for(auto num : numbers) {
35
        std::cout << num << " ";
36
    }
37
    std::cout << std::endl;
38

39
    return 0;
40
}

展开收起

`unordered_set`示例#

1
#include <iostream>
2
#include <unordered_set>
3

4
int main() {
5
    // 创建一个空的unordered_set
6
    std::unordered_set<int> numbers;
7

8
    // 插入元素
9
    numbers.insert(10);
10
    numbers.insert(20);
11
    numbers.insert(30);
12
    numbers.insert(20); // 重复元素，不会被插入
13

14
    // 遍历unordered_set
15
    std::cout << "unordered_set中的元素: ";
16
    for(auto it = numbers.begin(); it != numbers.end(); ++it) {
17
        std::cout << *it << " ";
18
    }
19
    std::cout << std::endl;
20

21
    // 查找元素
22
    int key = 20;
23
    if(numbers.find(key) != numbers.end()) {
24
        std::cout << key << " 在unordered_set中存在。" << std::endl;
25
    } else {
26
        std::cout << key << " 不在unordered_set中。" << std::endl;
27
    }
28

29
    // 删除元素
30
    numbers.erase(10);
31

32
    // 打印删除后的unordered_set
33
    std::cout << "删除10后unordered_set中的元素: ";
34
    for(auto num : numbers) {
35
        std::cout << num << " ";
36
    }
37
    std::cout << std::endl;
38

39
    return 0;
40
}

展开收起

输出#

`set`输出#

Terminal window

1
set中的元素: 10 20 30
2
20 在set中存在。
3
删除10后set中的元素: 20 30

`unordered_set`输出（注意元素顺序可能不同）#

1
unordered_set中的元素: 10 20 30
2
20 在unordered_set中存在。
3
删除10后unordered_set中的元素: 20 30

`stack`、`queue`和`priority_queue`：容器适配器#

用法#

STL中的容器适配器（stack、queue、priority_queue）提供了特定的数据结构接口，这些适配器在内部使用其他容器来存储元素（默认使用deque或vector）。

内部实现原理#

stack：后进先出（LIFO）数据结构，通常使用deque或vector作为底层容器，通过限制操作接口来实现。
queue：先进先出（FIFO）数据结构，通常使用deque作为底层容器，通过限制操作接口来实现。
priority_queue：基于堆的数据结构，通常使用vector作为底层容器，并通过堆算法（如std::make_heap、std::push_heap、std::pop_heap）维护元素的优先级顺序。

性能特性#

stack：
- 访问顶部元素：O(1)
- 插入和删除：O(1)
queue：
- 访问前端和后端元素：O(1)
- 插入和删除：O(1)
priority_queue：
- 访问顶部（最大或最小元素）：O(1)
- 插入和删除：O(log n)

应用场景#

stack：
- 实现函数调用栈。
- 处理撤销操作。
- 深度优先搜索（DFS）。
queue：
- 实现任务调度。
- 广度优先搜索（BFS）。
- 数据流处理。
priority_queue：
- 实现优先级调度。
- 求解最短路径算法（如Dijkstra）。
- 任意需要按优先级处理元素的场景。

代码示例#

`stack`示例#

1
#include <iostream>
2
#include <stack>
3

4
int main() {
5
    // 创建一个空的stack，底层使用vector
6
    std::stack<int> s;
7

8
    // 压入元素
9
    s.push(1);
10
    s.push(2);
11
    s.push(3);
12

13
    // 访问栈顶元素
14
    std::cout << "栈顶元素: " << s.top() << std::endl;
15

16
    // 弹出元素
17
    s.pop();
18
    std::cout << "弹出一个元素后，新的栈顶: " << s.top() << std::endl;
19

20
    // 判断栈是否为空
21
    if(!s.empty()) {
22
        std::cout << "栈不为空，元素数量: " << s.size() << std::endl;
23
    }
24

25
    return 0;
26
}

展开收起

`queue`示例#

1
#include <iostream>
2
#include <queue>
3

4
int main() {
5
    // 创建一个空的queue，底层使用deque
6
    std::queue<std::string> q;
7

8
    // 入队元素
9
    q.push("First");
10
    q.push("Second");
11
    q.push("Third");
12

13
    // 访问队首元素
14
    std::cout << "队首元素: " << q.front() << std::endl;
15

16
    // 访问队尾元素
17
    std::cout << "队尾元素: " << q.back() << std::endl;
18

19
    // 出队元素
20
    q.pop();
21
    std::cout << "出队后新的队首: " << q.front() << std::endl;
22

23
    // 判断队列是否为空
24
    if(!q.empty()) {
25
        std::cout << "队列不为空，元素数量: " << q.size() << std::endl;
26
    }
27

28
    return 0;
29
}

展开收起

`priority_queue`示例#

1
#include <iostream>
2
#include <queue>
3
#include <vector>
4

5
int main() {
6
    // 创建一个空的priority_queue，默认是最大堆
7
    std::priority_queue<int> pq;
8

9
    // 插入元素
10
    pq.push(30);
11
    pq.push(10);
12
    pq.push(20);
13
    pq.push(40);
14

15
    // 访问堆顶元素
16
    std::cout << "优先级最高的元素: " << pq.top() << std::endl;
17

18
    // 弹出元素
19
    pq.pop();
20
    std::cout << "弹出一个元素后，新的堆顶: " << pq.top() << std::endl;
21

22
    // 遍历priority_queue（需要复制，因为无法直接遍历）
23
    std::priority_queue<int> copy = pq;
24
    std::cout << "剩余的元素: ";
25
    while(!copy.empty()) {
26
        std::cout << copy.top() << " ";
27
        copy.pop();
28
    }
29
    std::cout << std::endl;
30

31
    return 0;
32
}

展开收起

输出#

`stack`输出#

1
栈顶元素: 3
2
弹出一个元素后，新的栈顶: 2
3
栈不为空，元素数量: 2

`queue`输出#

1
队首元素: First
2
队尾元素: Third
3
出队后新的队首: Second
4
队列不为空，元素数量: 2

`priority_queue`输出#

1
优先级最高的元素: 40
2
弹出一个元素后，新的堆顶: 30
3
剩余的元素: 30 20 10

总结#

C++ STL提供了丰富多样的容器，适用于各种不同的数据存储和管理需求。理解每种容器的特点、内部实现原理以及性能特性，可以帮助开发者在实际应用中做出最佳的选择，从而编写出高效且可维护的代码。

序列容器：
- vector：适用于需要频繁随机访问和在末尾操作的场景。
- list：适用于需要在中间频繁插入和删除的场景。
- deque：适用于需要在两端频繁插入和删除的场景。
关联容器：
- map和__set：适用于需要有序存储和快速查找的场景。
- unordered_map和__unordered_set：适用于需要高效查找且对元素顺序无要求的场景。
容器适配器：
- stack：用于LIFO操作。
- queue：用于FIFO操作。
- priority_queue：用于优先级队列操作。

lambda和function

Fri, 22 May 2026 00:00:00 GMT

引言#

C++ 提供了多种方式来表示和操作可调用对象，包括传统的函数指针、仿函数（Functors）、Lambda表达式、std::function 和 std::bind 等。这些工具极大地增强了C++的灵活性和表达能力，尤其在处理回调、事件驱动编程和函数式编程时表现尤为出色。

函数指针#

函数指针是C++中最基本的可调用对象之一，用于指向普通函数和静态成员函数。

定义与使用#

函数指针的定义涉及到函数的返回类型和参数列表。例如，定义一个指向返回 int 且接受两个 int 参数的函数指针：

1
// 定义函数指针类型
2
int (*funcPtr)(int, int);
3

4
// 定义一个普通函数
5
int add(int a, int b) {
6
    return a + b;
7
}
8

9
int main() {
10
    // 给函数指针赋值
11
    funcPtr = &add;
12

13
    // 调用函数
14
    int result = funcPtr(3, 4);
15
    std::cout << "结果: " << result << std::endl; // 输出: 结果: 7
16

17
    return 0;
18
}

展开收起

优点与局限性#

优点:

简单直观，适用于简单的回调函数。

局限性:

不能捕获上下文（如lambda中的闭包）。
语法相对复杂，尤其是指针的声明和使用。

仿函数（Functors）#

仿函数（Functors），又称函数对象（Function Objects），是在C++中重载了 operator() 的类或结构体实例。仿函数不仅可以像普通函数一样被调用，还能携带状态，提供更大的灵活性和功能性。

定义与使用#

仿函数是通过定义一个类或结构体，并重载其调用运算符 operator() 来实现的。

1
#include <iostream>
2

3
// 定义一个仿函数类
4
struct Adder {
5
    int to_add;
6

7
    // 构造函数
8
    Adder(int value) : to_add(value) {}
9

10
    // 重载()运算符
11
    int operator()(int x) const {
12
        return x + to_add;
13
    }
14
};
15

16
int main() {
17
    Adder add5(5); // 创建一个添加5的仿函数
18

19
    std::cout << "10 + 5 = " << add5(10) << std::endl; // 输出: 10 + 5 = 15
20

21
    return 0;
22
}

展开收起

特点#

携带状态： 仿函数可以拥有内部状态，通过成员变量存储数据，使其在调用时具备上下文信息。
灵活性高： 可以根据需要添加更多的成员函数和变量，扩展功能。
性能优化： 编译器可以对仿函数进行优化，例如内联展开，提高执行效率。

高级示例#

仿函数不仅可以执行简单的计算，还可以进行复杂的操作。例如，实现一个可变的仿函数，用于累加多个值。

1
#include <iostream>
2

3
// 可变累加器仿函数
4
struct Accumulator {
5
    int sum;
6

7
    Accumulator() : sum(0) {}
8

9
    // 重载()运算符
10
    void operator()(int x) {
11
        sum += x;
12
    }
13
};
14

15
int main() {
16
    Accumulator acc;
17

18
    acc(10);
19
    acc(20);
20
    acc(30);
21

22
    std::cout << "总和: " << acc.sum << std::endl; // 输出: 总和: 60
23

24
    return 0;
25
}

展开收起

使用仿函数的标准库算法#

许多标准库算法可以接受仿函数作为参数，使得算法的行为更加灵活和可定制。

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
// 仿函数：判断一个数是否大于某个阈值
6
struct IsGreaterThan {
7
    int threshold;
8

9
    IsGreaterThan(int t) : threshold(t) {}
10

11
    bool operator()(int x) const {
12
        return x > threshold;
13
    }
14
};
15

16
int main() {
17
    std::vector<int> numbers = {1, 5, 10, 15, 20};
18

19
    // 使用仿函数进行筛选
20
    IsGreaterThan greaterThan10(10);
21
    auto it = std::find_if(numbers.begin(), numbers.end(), greaterThan10);
22

23
    if(it != numbers.end()) {
24
        std::cout << "第一个大于10的数是: " << *it << std::endl; // 输出: 第一个大于10的数是: 15
25
    } else {
26
        std::cout << "没有找到大于10的数。" << std::endl;
27
    }
28

29
    return 0;
30
}

展开收起

仿函数与模板#

仿函数与模板相结合，可以实现高度通用和可复用的代码。例如，编写一个通用的比较仿函数。

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
// 通用比较仿函数
6
template <typename T>
7
struct Compare {
8
    bool operator()(const T& a, const T& b) const {
9
        return a < b;
10
    }
11
};
12

13
int main() {
14
    std::vector<int> numbers = {5, 2, 8, 1, 9};
15

16
    // 使用仿函数进行排序
17
    std::sort(numbers.begin(), numbers.end(), Compare<int>());
18

19
    std::cout << "排序后的数字: ";
20
    for(auto num : numbers) {
21
        std::cout << num << " "; // 输出: 1 2 5 8 9
22
    }
23
    std::cout << std::endl;
24

25
    return 0;
26
}

展开收起

仿函数的优势#

可扩展性： 能够根据需要添加更多功能和状态。
与Lambda的互补性： 在需要携带复杂状态或多次调用时，仿函数比Lambda更适合。
类型安全： 仿函数是具体的类型，可以在编译期进行类型检查。

何时使用仿函数#

需要携带状态时： 当回调函数需要维护内部状态时，仿函数是理想选择。
复杂操作： 当简单的函数指针或Lambda难以表达复杂逻辑时。
性能关键场景： 由于仿函数可以被编译器优化，适用于性能敏感的代码。

Lambda表达式#

Lambda表达式是C++11引入的一种轻量级函数对象，允许在代码中定义匿名函数。它们可以捕获周围的变量，具有更强的表达能力。

基本语法#

1
[captures](parameters) -> return_type {
2
    // 函数体
3
}

captures: 捕获外部变量的方式，可以是值捕获、引用捕获或者混合捕获。
parameters: 参数列表。
return_type: 返回类型，可以省略，编译器会自动推导。
函数体: 实际执行的代码。

示例#

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
int main() {
6
    int threshold = 5;
7
    std::vector<int> numbers = {1, 6, 3, 8, 2, 7};
8

9
    // 使用lambda表达式进行过滤
10
    numbers.erase(std::remove_if(numbers.begin(), numbers.end(),
11
        [threshold](int n) -> bool {
12
            return n < threshold;
13
        }), numbers.end());
14

15
    // 输出结果
16
    for(auto n : numbers) {
17
        std::cout << n << " "; // 输出: 6 8 7
18
    }
19

20
    return 0;
21
}

展开收起

捕获方式#

值捕获 ([=]): 捕获所有外部变量的副本。
引用捕获 ([&]): 捕获所有外部变量的引用。
混合捕获: 指定部分变量按值捕获，部分按引用捕获，如 [=, &var] 或 [&, var]。
无捕获 ([]): 不捕获任何外部变量。

可变Lambda#

默认情况下，Lambda表达式是不可变的（const）。通过mutable关键字，可以允许修改捕获的变量副本。

1
#include <iostream>
2

3
int main() {
4
    int count = 0;
5

6
    auto increment = [count]() mutable {
7
        count++;
8
        std::cout << "Count inside Lambda: " << count << std::endl;
9
    };
10

11
    increment(); // 输出: Count inside Lambda: 1
12
    increment(); // 输出: Count inside Lambda: 2
13

14
    std::cout << "Count outside Lambda: " << count << std::endl; // 输出: Count outside Lambda: 0
15

16
    return 0;
17
}

展开收起

捕获成员函数和类变量#

Lambda表达式可以捕获类的成员变量和成员函数，使其在类的上下文中更加灵活。

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
class Processor {
6
public:
7
    Processor(int threshold) : threshold(threshold) {}
8

9
    void process(std::vector<int>& data) {
10
        std::cout << "处理前数据: ";
11
        for(auto num : data) std::cout << num << " ";
12
        std::cout << std::endl;
13

14
        // 使用Lambda表达式进行过滤
15
        data.erase(std::remove_if(data.begin(), data.end(),
16
            [this](int n) -> bool {
17
                return n < threshold;
18
            }), data.end());
19

20
        std::cout << "处理后数据: ";
21
        for(auto num : data) std::cout << num << " ";
22
        std::cout << std::endl;
23
    }
24

25
private:
26
    int threshold;
27
};
28

29
int main() {
30
    std::vector<int> numbers = {1, 6, 3, 8, 2, 7};
31
    Processor proc(5);
32
    proc.process(numbers);
33
    /*
34
    输出:
35
    处理前数据: 1 6 3 8 2 7
36
    处理后数据: 6 8 7
37
    */
38

39
    return 0;
40
}

展开收起

Lambda与标准库算法#

Lambda表达式与标准库算法紧密结合，提供了更简洁和直观的代码书写方式。

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

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

8
    // 使用Lambda表达式进行排序
9
    std::sort(numbers.begin(), numbers.end(),
10
        [](int a, int b) -> bool {
11
            return a < b;
12
        });
13

14
    std::cout << "排序后的数字: ";
15
    for(auto num : numbers) {
16
        std::cout << num << " "; // 输出: 1 2 3 4 5
17
    }
18
    std::cout << std::endl;
19

20
    return 0;
21
}

展开收起

Lambda表达式的优势#

简洁性： 代码更加紧凑，易于理解。
灵活性： 能够捕获外部变量，适应更多场景。
性能优化： 编译器可以对Lambda进行优化，如内联展开。
与标准库的良好集成： 与STL算法无缝结合，简化代码逻辑。

`std::function` 对象#

std::function 是C++11提供的一个通用的可调用包装器，能够封装任何可调用对象，包括普通函数、Lambda表达式、函数对象以及绑定表达式。它实现了类型擦除，使得不同类型的可调用对象可以通过统一的接口进行操作。

定义与使用#

1
#include <iostream>
2
#include <functional>
3

4
// 普通函数
5
int add(int a, int b) {
6
    return a + b;
7
}
8

9
// 函数对象
10
struct Multiply {
11
    int operator()(int a, int b) const {
12
        return a * b;
13
    }
14
};
15

16
int main() {
17
    // 封装普通函数
18
    std::function<int(int, int)> func1 = add;
19
    std::cout << "Add: " << func1(3, 4) << std::endl; // 输出: Add: 7
20

21
    // 封装Lambda表达式
22
    std::function<int(int, int)> func2 = [](int a, int b) -> int {
23
        return a - b;
24
    };
25
    std::cout << "Subtract: " << func2(10, 4) << std::endl; // 输出: Subtract: 6
26

27
    // 封装函数对象
28
    Multiply multiply;
29
    std::function<int(int, int)> func3 = multiply;
30
    std::cout << "Multiply: " << func3(3, 4) << std::endl; // 输出: Multiply: 12
31

32
    return 0;
33
}

展开收起

特点#

类型擦除： 可以存储任何符合签名的可调用对象。
灵活性： 支持动态改变存储的可调用对象。
性能开销： 相比于直接使用函数指针或Lambda，std::function 可能带来一定的性能开销，尤其是在频繁调用时。

用法场景#

回调函数的传递。
事件处理系统。
策略模式的实现。

示例：回调机制#

1
#include <iostream>
2
#include <functional>
3

4
// 定义回调类型
5
using Callback = std::function<void(int)>;
6

7
// 触发事件的函数
8
void triggerEvent(Callback cb, int value) {
9
    // 事件发生，调用回调
10
    cb(value);
11
}
12

13
int main() {
14
    // 使用Lambda作为回调
15
    triggerEvent([](int x) {
16
        std::cout << "事件触发，值为: " << x << std::endl;
17
    }, 42); // 输出: 事件触发，值为: 42
18

19
    // 使用仿函数作为回调
20
    struct Printer {
21
        void operator()(int x) const {
22
            std::cout << "Printer打印值: " << x << std::endl;
23
        }
24
    } printer;
25

26
    triggerEvent(printer, 100); // 输出: Printer打印值: 100
27

28
    return 0;
29
}

展开收起

存储和调用不同类型的可调用对象#

std::function 可以在容器中存储各种不同类型的可调用对象，只要它们符合指定的签名。

1
#include <iostream>
2
#include <functional>
3
#include <vector>
4

5
int add(int a, int b) {
6
    return a + b;
7
}
8

9
struct Multiply {
10
    int operator()(int a, int b) const {
11
        return a * b;
12
    }
13
};
14

15
int main() {
16
    std::vector<std::function<int(int, int)>> operations;
17

18
    // 添加不同类型的可调用对象
19
    operations.emplace_back(add); // 普通函数
20
    operations.emplace_back(Multiply()); // 仿函数
21
    operations.emplace_back([](int a, int b) -> int { return a - b; }); // Lambda
22

23
    // 执行所有操作
24
    for(auto& op : operations) {
25
        std::cout << op(10, 5) << " "; // 输出: 15 50 5
26
    }
27
    std::cout << std::endl;
28

29
    return 0;
30
}

展开收起

`std::bind` 操作#

std::bind 是C++11中提供的一个函数适配器，用于绑定函数或可调用对象的部分参数，生成一个新的可调用对象。它允许提前固定某些参数，简化函数调用或适应接口需求。

基本用法#

1
#include <iostream>
2
#include <functional>
3

4
// 普通函数
5
int add(int a, int b) {
6
    return a + b;
7
}
8

9
int main() {
10
    // 绑定第一个参数为10，生成新的函数对象
11
    auto add10 = std::bind(add, 10, std::placeholders::_1);
12

13
    std::cout << "10 + 5 = " << add10(5) << std::endl; // 输出: 10 + 5 = 15
14

15
    return 0;
16
}

展开收起

占位符 (`std::placeholders`)#

std::bind 使用占位符来表示未绑定的参数，这些占位符决定了在生成的新函数对象中如何传递参数。

常用的占位符包括：

std::placeholders::_1
std::placeholders::_2
std::placeholders::_3
等等，根据需要传递的参数数量。

示例#

1
#include <iostream>
2
#include <functional>
3

4
void display(const std::string& msg, int count) {
5
    for(int i = 0; i < count; ++i) {
6
        std::cout << msg << std::endl;
7
    }
8
}
9

10
int main() {
11
    // 绑定消息为"Hello"，生成新的函数对象，只需要传递次数
12
    auto sayHello = std::bind(display, "Hello", std::placeholders::_1);
13

14
    sayHello(3);
15
    /*
16
    输出:
17
    Hello
18
    Hello
19
    Hello
20
    */
21

22
    // 绑定次数为2，生成新的函数对象，只需要传递消息
23
    auto sayTwice = std::bind(display, std::placeholders::_1, 2);
24
    sayTwice("Hi");
25
    /*
26
    输出:
27
    Hi
28
    Hi
29
    */
30

31
    return 0;
32
}

展开收起

与Lambda表达式的对比#

std::bind 曾在C++11中广泛使用，但随着Lambda表达式的普及，很多情况下Lambda更为直观和高效。不过，在某些复杂的参数绑定场景下，std::bind 依然有其独特优势。

使用 std::bind:

1
#include <iostream>
2
#include <functional>
3

4
int multiply(int a, int b) {
5
    return a * b;
6
}
7

8
int main() {
9
    // 绑定第一个参数为2，生成新的函数对象
10
    auto multiplyBy2 = std::bind(multiply, 2, std::placeholders::_1);
11

12
    std::cout << "2 * 5 = " << multiplyBy2(5) << std::endl; // 输出: 2 * 5 = 10
13

14
    return 0;
15
}

展开收起

使用 Lambda 表达式:

1
#include <iostream>
2
#include <functional>
3

4
int multiply(int a, int b) {
5
    return a * b;
6
}
7

8
int main() {
9
    // 使用Lambda表达式绑定第一个参数为2
10
    auto multiplyBy2 = [](int b) -> int {
11
        return multiply(2, b);
12
    };
13

14
    std::cout << "2 * 5 = " << multiplyBy2(5) << std::endl; // 输出: 2 * 5 = 10
15

16
    return 0;
17
}

展开收起

总结：

可读性： Lambda表达式通常更具可读性，语法更直观。
灵活性： Lambda更易于捕获和使用外部变量。
性能： Lambda通常比std::bind更高效，因为std::bind可能引入额外的间接层。

绑定类的成员函数#

在C++中，成员函数与普通函数不同，因为它们需要一个对象实例来调用。使用 std::bind 或Lambda表达式，可以方便地绑定类的成员函数，生成可调用对象。

使用 `std::bind` 绑定成员函数#

1
#include <iostream>
2
#include <functional>
3

4
class Calculator {
5
public:
6
    int multiply(int a, int b) const {
7
        return a * b;
8
    }
9
};
10

11
int main() {
12
    Calculator calc;
13

14
    // 绑定成员函数multiply，固定第一个参数为5
15
    auto multiplyBy5 = std::bind(&Calculator::multiply, &calc, 5, std::placeholders::_1);
16

17
    std::cout << "5 * 3 = " << multiplyBy5(3) << std::endl; // 输出: 5 * 3 = 15
18

19
    return 0;
20
}

展开收起

使用Lambda表达式绑定成员函数#

1
#include <iostream>
2
#include <functional>
3

4
class Greeter {
5
public:
6
    void greet(const std::string& name) const {
7
        std::cout << "Hello, " << name << "!" << std::endl;
8
    }
9
};
10

11
int main() {
12
    Greeter greeter;
13

14
    // 使用Lambda表达式绑定成员函数
15
    auto greetFunc = [&greeter](const std::string& name) {
16
        greeter.greet(name);
17
    };
18

19
    greetFunc("Alice"); // 输出: Hello, Alice!
20

21
    return 0;
22
}

展开收起

绑定静态成员函数#

静态成员函数不依赖于类的实例，可以像普通函数一样使用 std::bind 和 std::function。

1
#include <iostream>
2
#include <functional>
3

4
class Logger {
5
public:
6
    static void log(const std::string& message) {
7
        std::cout << "Log: " << message << std::endl;
8
    }
9
};
10

11
int main() {
12
    // 使用std::bind绑定静态成员函数
13
    auto logFunc = std::bind(&Logger::log, std::placeholders::_1);
14

15
    logFunc("This is a static log message."); // 输出: Log: This is a static log message.
16

17
    return 0;
18
}

展开收起

绑定带有返回值的成员函数#

1
#include <iostream>
2
#include <functional>
3

4
class Math {
5
public:
6
    double power(double base, double exponent) const {
7
        double result = 1.0;
8
        for(int i = 0; i < static_cast<int>(exponent); ++i) {
9
            result *= base;
10
        }
11
        return result;
12
    }
13
};
14

15
int main() {
16
    Math mathObj;
17

18
    // 绑定成员函数power，固定基数为2
19
    auto powerOf2 = std::bind(&Math::power, &mathObj, 2.0, std::placeholders::_1);
20

21
    std::cout << "2^3 = " << powerOf2(3) << std::endl; // 输出: 2^3 = 8
22

23
    return 0;
24
}

展开收起

注意事项#

对象生命周期： 绑定成员函数时，确保对象在可调用对象使用期间依然存在，以避免悬空指针问题。
指针与引用： 可以通过指针或引用传递对象实例给 std::bind 或Lambda表达式。
捕获方式： 在使用Lambda表达式时，选择合适的捕获方式（值捕获或引用捕获）以确保对象的正确访问。

C++ 可调用对象的总结#

C++ 提供了多种方式来定义和操作可调用对象，每种方式有其独特的特点和适用场景。

可调用对象	描述	示例用法
函数指针	指向普通函数或静态成员函数的指针	`int (*func)(int) = &funcName;`
仿函数（Functors）	重载了 `operator()` 的类实例，可以携带状态	`struct Foo { void operator()(); };`
Lambda表达式	定义在表达式中的匿名函数，支持捕获上下文变量	`[capture](params) { /* code */ }`
`std::function`	通用的可调用对象包装器，能够封装任何符合签名的可调用对象	`std::function<void(int)> func;`
`std::bind`	绑定函数或可调用对象的部分参数，生成新的可调用对象	`auto newFunc = std::bind(func, _1);`

选择建议#

简单回调： 使用函数指针或Lambda表达式。
需要携带状态或更复杂逻辑： 使用Lambda表达式或仿函数（Functors）。
接口要求 std::function： 使用 std::function，不过要注意可能的性能开销。
参数预绑定： 使用 std::bind，但在现代C++中，许多情况下Lambda表达式能达到相同效果且更直观。

智能指针

Fri, 22 May 2026 00:00:00 GMT

1. 引言#

C++ 引入智能指针的主要目的是为了自动化内存管理，减少手动 new 和 delete 带来的复杂性和错误。智能指针通过 RAII（资源获取即初始化）机制，在对象生命周期结束时自动释放资源，从而有效防止内存泄漏和资源管理错误。

2. 原生指针 vs 智能指针#

原生指针#

原生指针是 C++ 最基本的指针类型，允许程序员直接管理内存。然而，原生指针存在以下问题：

内存泄漏：未释放动态分配的内存。
悬挂指针：指针指向已释放或未初始化的内存。
双重释放：多次释放同一内存区域。

智能指针的优势#

智能指针通过封装原生指针，自动管理内存，解决上述问题。主要优势包括：

自动销毁：在智能指针生命周期结束时自动释放资源。
引用计数：共享智能指针能够跟踪引用数量，确保资源在最后一个引用结束时释放。
避免内存泄漏：通过 RAII 机制自动管理资源生命周期。
类型安全：提供更严格的类型检查，减少错误。

3. `std::unique_ptr`#

3.1 定义与用法#

std::unique_ptr 是一种独占所有权的智能指针，任何时刻只能有一个 unique_ptr 实例拥有对某个对象的所有权。不能被拷贝，只能被移动。

主要特性：

独占所有权：确保资源在一个所有者下。
轻量级：没有引用计数，开销小。
自动释放：在指针销毁时自动释放资源。

3.2 构造函数与赋值#

unique_ptr 提供多种构造函数和赋值操作，以支持不同的使用场景。

默认构造函数：创建一个空的 unique_ptr。
指针构造函数：接受一个裸指针，拥有其所有权。
移动构造函数：将一个 unique_ptr 的所有权转移到另一个 unique_ptr。
移动赋值操作符：将一个 unique_ptr 的所有权转移到另一个 unique_ptr。

3.3 移动语义#

由于 unique_ptr 不能被拷贝，必须通过移动语义转移所有权。这保证了资源的独占性。

3.4 代码案例#

1
#include <iostream>
2
#include <memory>
3

4
class Test {
5
public:
6
    Test(int val) : value(val) {
7
        std::cout << "Test Constructor: " << value << std::endl;
8
    }
9
    ~Test() {
10
        std::cout << "Test Destructor: " << value << std::endl;
11
    }
12
    void show() const {
13
        std::cout << "Value: " << value << std::endl;
14
    }
15

16
private:
17
    int value;
18
};
19

20
int main() {
21
    // 创建一个 unique_ptr
22
    std::unique_ptr<Test> ptr1(new Test(100));
23
    ptr1->show();
24

25
    // 使用 make_unique（C++14 引入）
26
    auto ptr2 = std::make_unique<Test>(200);
27
    ptr2->show();
28

29
    // 移动 unique_ptr
30
    std::unique_ptr<Test> ptr3 = std::move(ptr1);
31
    if (!ptr1) {
32
        std::cout << "ptr1 is now nullptr after move." << std::endl;
33
    }
34
    ptr3->show();
35

36
    // 重置 unique_ptr
37
    ptr2.reset(new Test(300));
38
    ptr2->show();
39

40
    // unique_ptr 自动释放资源
41
    return 0;
42
}

展开收起

输出：

1
Test Constructor: 100
2
Value: 100
3
Test Constructor: 200
4
Value: 200
5
ptr1 is now nullptr after move.
6
Value: 100
7
Test Destructor: 100
8
Test Constructor: 300
9
Value: 300
10
Test Destructor: 300
11
Test Destructor: 200

解析：

ptr1 拥有 Test(100)，ptr2 拥有 Test(200)。
通过 std::move 将 ptr1 的所有权转移到 ptr3，ptr1 变为空。
ptr2.reset(new Test(300)) 释放了原有的 Test(200)，并拥有新的 Test(300)。
程序结束时，ptr3 和 ptr2 自动释放各自拥有的资源。

4. `std::shared_ptr`#

4.1 定义与用法#

std::shared_ptr 是一种共享所有权的智能指针，允许多个 shared_ptr 实例共享对同一个对象的所有权。通过引用计数机制，管理资源的生命周期。

主要特性：

共享所有权：多个 shared_ptr 可以指向同一个对象。
引用计数：跟踪有多少 shared_ptr 实例指向同一对象。
自动释放：当引用计数为0时，自动释放资源。

4.2 引用计数与控制块#

shared_ptr 背后依赖一个控制块（Control Block），用于存储引用计数和指向实际对象的指针。控制块的主要内容包括：

强引用计数（use_count）：表示有多少个 shared_ptr 指向对象。
弱引用计数（weak_count）：表示有多少个 weak_ptr 指向对象（不增加强引用计数）。

4.3 构造函数与赋值#

shared_ptr 提供多种构造函数和赋值操作，以支持不同的使用场景。

默认构造函数：创建一个空的 shared_ptr。
指针构造函数：接受一个裸指针，拥有其所有权。
拷贝构造函数：增加引用计数，共享对象所有权。
移动构造函数：转移所有权，源 shared_ptr 变为空。
拷贝赋值操作符：释放当前资源，增加引用计数，指向新对象。
移动赋值操作符：释放当前资源，转移所有权，源 shared_ptr 变为空。

4.4 代码案例#

1
#include <iostream>
2
#include <memory>
3

4
class Test {
5
public:
6
    Test(int val) : value(val) {
7
        std::cout << "Test Constructor: " << value << std::endl;
8
    }
9
    ~Test() {
10
        std::cout << "Test Destructor: " << value << std::endl;
11
    }
12
    void show() const {
13
        std::cout << "Value: " << value << std::endl;
14
    }
15

16
private:
17
    int value;
18
};
19

20
int main() {
21
    // 创建一个 shared_ptr
22
    std::shared_ptr<Test> sp1(new Test(100));
23
    std::cout << "sp1 use_count: " << sp1.use_count() << std::endl;
24
    sp1->show();
25

26
    // 通过拷贝构造共享所有权
27
    std::shared_ptr<Test> sp2 = sp1;
28
    std::cout << "After sp2 = sp1:" << std::endl;
29
    std::cout << "sp1 use_count: " << sp1.use_count() << std::endl;
30
    std::cout << "sp2 use_count: " << sp2.use_count() << std::endl;
31

32
    // 通过拷贝赋值共享所有权
33
    std::shared_ptr<Test> sp3;
34
    sp3 = sp2;
35
    std::cout << "After sp3 = sp2:" << std::endl;
36
    std::cout << "sp1 use_count: " << sp1.use_count() << std::endl;
37
    std::cout << "sp2 use_count: " << sp2.use_count() << std::endl;
38
    std::cout << "sp3 use_count: " << sp3.use_count() << std::endl;
39

40
    // 重置 shared_ptr
41
    sp2.reset(new Test(200));
42
    std::cout << "After sp2.reset(new Test(200)):" << std::endl;
43
    std::cout << "sp1 use_count: " << sp1.use_count() << std::endl;
44
    std::cout << "sp2 use_count: " << sp2.use_count() << std::endl;
45
    std::cout << "sp3 use_count: " << sp3.use_count() << std::endl;
46
    sp2->show();
47

48
    // 自动释放资源
49
    std::cout << "Exiting main..." << std::endl;
50
    return 0;
51
}

展开收起

输出：

1
Test Constructor: 100
2
sp1 use_count: 1
3
Value: 100
4
After sp2 = sp1:
5
sp1 use_count: 2
6
sp2 use_count: 2
7
After sp3 = sp2:
8
sp1 use_count: 3
9
sp2 use_count: 3
10
sp3 use_count: 3
11
Test Constructor: 200
12
After sp2.reset(new Test(200)):
13
sp1 use_count: 2
14
sp2 use_count: 1
15
sp3 use_count: 2
16
Value: 200
17
Exiting main...
18
Test Destructor: 200
19
Test Destructor: 100

展开收起

解析：

创建 sp1，引用计数为1。
拷贝构造 sp2，引用计数增加到2。
拷贝赋值 sp3，引用计数增加到3。

1
sp2.reset(new Test(200))

：

1
- 原 `Test(100)` 的引用计数减少到2。
2
- 分配新的 `Test(200)`，`sp2` 拥有它，引用计数为1。

程序结束时：
- sp1 和 sp3 释放 Test(100)，引用计数降到0，资源被销毁。
- sp2 释放 Test(200)，引用计数为0，资源被销毁。

5. `std::weak_ptr`#

5.1 定义与用法#

std::weak_ptr 是一种不拥有对象所有权的智能指针，用于观察但不影响对象的生命周期。主要用于解决 shared_ptr 之间的循环引用问题。

主要特性：

非拥有所有权：不增加引用计数。
可从 shared_ptr 生成：通过 std::weak_ptr 可以访问 shared_ptr 管理的对象。
避免循环引用：适用于双向关联或观察者模式。

5.2 避免循环引用#

在存在双向关联（如父子关系）时，使用多个 shared_ptr 可能导致循环引用，导致内存泄漏。此时，可以使用 weak_ptr 来打破循环。

5.3 代码案例#

场景：双向关联导致循环引用#

1
#include <iostream>
2
#include <memory>
3

4
class B; // 前向声明
5

6
class A {
7
public:
8
    std::shared_ptr<B> ptrB;
9

10
    A() { std::cout << "A Constructor" << std::endl; }
11
    ~A() { std::cout << "A Destructor" << std::endl; }
12
};
13

14
class B {
15
public:
16
    std::shared_ptr<A> ptrA;
17

18
    B() { std::cout << "B Constructor" << std::endl; }
19
    ~B() { std::cout << "B Destructor" << std::endl; }
20
};
21

22
int main() {
23
    {
24
        std::shared_ptr<A> a = std::make_shared<A>();
25
        std::shared_ptr<B> b = std::make_shared<B>();
26
        a->ptrB = b;
27
        b->ptrA = a;
28
    }
29
    std::cout << "Exiting main..." << std::endl;
30
    return 0;
31
}

展开收起

输出：

1
A Constructor
2
B Constructor
3
Exiting main...
4
A Destructor
5
B Destructor

问题：

虽然 a 和 b 离开作用域，但 A Destructor 和 B Destructor 并未被调用，因为 a 和 b 相互引用，引用计数无法降到0，导致内存泄漏。

解决方案：使用 `weak_ptr`#

改用 weak_ptr 其中一方（如 B 的 ptrA），打破循环引用。

1
#include <iostream>
2
#include <memory>
3

4
class B; // 前向声明
5

6
class A {
7
public:
8
    std::shared_ptr<B> ptrB;
9

10
    A() { std::cout << "A Constructor" << std::endl; }
11
    ~A() { std::cout << "A Destructor" << std::endl; }
12
};
13

14
class B {
15
public:
16
    std::weak_ptr<A> ptrA; // 使用 weak_ptr
17

18
    B() { std::cout << "B Constructor" << std::endl; }
19
    ~B() { std::cout << "B Destructor" << std::endl; }
20
};
21

22
int main() {
23
    {
24
        std::shared_ptr<A> a = std::make_shared<A>();
25
        std::shared_ptr<B> b = std::make_shared<B>();
26
        a->ptrB = b;
27
        b->ptrA = a;
28
    }
29
    std::cout << "Exiting main..." << std::endl;
30
    return 0;
31
}

展开收起

输出：

1
A Constructor
2
B Constructor
3
A Destructor
4
B Destructor
5
Exiting main...

解析：

B 使用 weak_ptr 指向 A，不增加引用计数。
a 和 b 离开作用域，引用计数降为0，资源被正确释放。
防止了循环引用，避免了内存泄漏。

5.4 访问 `weak_ptr` 指向的对象#

weak_ptr 不能直接访问对象，需要通过 lock() 方法转换为 shared_ptr，并检查对象是否仍然存在。

1
#include <iostream>
2
#include <memory>
3

4
int main() {
5
    std::shared_ptr<int> sp = std::make_shared<int>(42);
6
    std::weak_ptr<int> wp = sp;
7

8
    if (auto locked = wp.lock()) { // 尝试获取 shared_ptr
9
        std::cout << "Value: " << *locked << std::endl;
10
    } else {
11
        std::cout << "Object no longer exists." << std::endl;
12
    }
13

14
    sp.reset(); // 释放资源
15

16
    if (auto locked = wp.lock()) { // 再次尝试获取 shared_ptr
17
        std::cout << "Value: " << *locked << std::endl;
18
    } else {
19
        std::cout << "Object no longer exists." << std::endl;
20
    }
21

22
    return 0;
23
}

展开收起

输出：

1
Value: 42
2
Object no longer exists.

解析：

wp.lock() 返回一个 shared_ptr，如果对象依然存在，则有效。
sp.reset() 释放资源后，wp.lock() 无法获取有效的 shared_ptr。

6. 自定义删除器#

6.1 用例与实现#

有时，默认的 delete 操作不适用于所有资源管理场景。此时，可以使用自定义删除器来指定资源释放的方式。例如，管理文件句柄、网络资源或自定义清理逻辑。

6.2 代码案例#

用例：管理 FILE* 资源#

1
#include <iostream>
2
#include <memory>
3
#include <cstdio>
4

5
struct FileDeleter {
6
    void operator()(FILE* fp) const {
7
        if (fp) {
8
            std::cout << "Closing file." << std::endl;
9
            fclose(fp);
10
        }
11
    }
12
};
13

14
int main() {
15
    {
16
        std::shared_ptr<FILE> filePtr(fopen("example.txt", "w"), FileDeleter());
17
        if (filePtr) {
18
            std::cout << "File opened successfully." << std::endl;
19
            // 使用 filePtr 进行文件操作
20
            fprintf(filePtr.get(), "Hello, World!\n");
21
        }
22
    } // 自动关闭文件
23

24
    std::cout << "Exiting main..." << std::endl;
25
    return 0;
26
}

展开收起

输出：

1
File opened successfully.
2
Closing file.
3
Exiting main...

解析：

自定义删除器 FileDeleter 用于在 shared_ptr 被销毁时关闭文件。
使用 filePtr.get() 获取原生 FILE* 指针进行文件操作。
离开作用域时，自动调用 FileDeleter 关闭文件。

6.3 使用 Lambda 表达式作为删除器#

C++11 允许使用 lambda 表达式作为删除器，简化代码。

1
#include <iostream>
2
#include <memory>
3
#include <cstdio>
4

5
int main() {
6
    {
7
        auto fileDeleter = [](FILE* fp) {
8
            if (fp) {
9
                std::cout << "Closing file via lambda." << std::endl;
10
                fclose(fp);
11
            }
12
        };
13

14
        std::unique_ptr<FILE, decltype(fileDeleter)> filePtr(fopen("example.txt", "w"), fileDeleter);
15
        if (filePtr) {
16
            std::cout << "File opened successfully." << std::endl;
17
            fprintf(filePtr.get(), "Hello, Lambda!\n");
18
        }
19
    } // 自动关闭文件
20

21
    std::cout << "Exiting main..." << std::endl;
22
    return 0;
23
}

展开收起

输出：

1
File opened successfully.
2
Closing file via lambda.
3
Exiting main...

解析：

使用 std::unique_ptr 搭配 lambda 删除器管理 FILE*。
提供了更灵活和简洁的删除器实现。

7. 最佳实践与常见陷阱#

7.1 选择合适的智能指针#

std::unique_ptr：
- 用于明确的独占所有权场景。
- 适用于资源的单一管理者或需要所有权转移的情况。
- 更轻量，性能更优。
std::shared_ptr：
- 用于共享所有权的场景。
- 需要多个指针共同管理同一资源时使用。
- 引用计数带来一定的性能开销。
std::weak_ptr：
- 用于观察不拥有资源的场景。
- 适用于需要避免循环引用或只需临时访问资源的情况。

7.2 避免循环引用#

在使用 shared_ptr 时，特别是在对象间存在双向引用时，容易导致循环引用，内存泄漏。使用 weak_ptr 打破循环引用。

7.3 使用 `make_shared` 与 `make_unique`#

优先使用 make_shared 和 make_unique 来创建智能指针，避免直接使用 new，提高效率和异常安全性。

1
auto sp = std::make_shared<Test>(100);
2
auto up = std::make_unique<Test>(200);

7.4 不要混用原生指针与智能指针#

避免在智能指针管理的对象上同时使用原生指针进行管理，防止重复释放或不安全访问。

7.5 理解智能指针的所有权语义#

深入理解不同智能指针的所有权规则，避免误用导致资源管理错误。

8. 总结#

智能指针是 C++ 中强大的资源管理工具，通过封装原生指针，提供自动化的内存管理，极大地减少了内存泄漏和资源管理错误。std::unique_ptr、std::shared_ptr 和 std::weak_ptr 各有其应用场景，理解它们的差异和使用方法对于编写安全、高效的 C++ 代码至关重要。此外，通过实现自己的智能指针（如 SimpleSharedPtr），可以更深入地理解智能指针的工作原理，为高级 C++ 编程打下坚实基础。

内存管理

Thu, 21 May 2026 00:00:00 GMT

内存管理简介#

C++ 提供了多种内存管理方式，包括传统的 C 风格的 malloc 和 free，以及 C++ 专用的 new 和 delete。

理解这些内存管理方法对于编写高效、安全的 C++ 程序至关重要。

本文将详细介绍这些内存管理方法，包含基本用法、复杂操作（如 realloc），并配以实际案例和代码示例。

内存管理基础#

在 C++ 程序中，内存主要分为以下几个区域：

栈（Stack）：自动管理内存，存储局部变量和函数调用信息。内存分配和释放速度快，但空间有限。
堆（Heap）：手动管理内存，用于动态分配内存。内存分配和释放由程序员控制，灵活但易出错（如内存泄漏、悬挂指针）。
全局/静态区（Data/BSS Segment）：存储全局变量和静态变量。

了解栈和堆的区别，以及如何有效地在堆上分配和管理内存，是编写高效且安全的 C++ 程序的基础。

C 风格内存管理#

`malloc` 函数#

malloc（memory allocation）用于在堆上分配指定字节数的内存。其原型如下：

1
#include <cstdlib>
2

3
void* malloc(size_t size);

参数：size - 要分配的内存字节数。
返回值：指向分配内存的指针，如果分配失败则返回 nullptr。

`free` 函数#

free 用于释放之前由 malloc、calloc 或 realloc 分配的内存。其原型如下：

1
void free(void* ptr);

参数：ptr - 要释放的内存指针。

示例代码#

1
#include <iostream>
2
#include <cstdlib> // 包含 malloc 和 free
3

4
int main() {
5
    // 分配一个整数的内存
6
    int* p = (int*)malloc(sizeof(int));
7
    if (p == nullptr) {
8
        std::cerr << "Memory allocation failed" << std::endl;
9
        return 1;
10
    }
11

12
    *p = 42;
13
    std::cout << "Value: " << *p << std::endl;
14

15
    // 释放内存
16
    free(p);
17
    return 0;
18
}

展开收起

注意事项#

类型转换：malloc 返回 void*，需要显式转换为所需类型的指针。
初始化：malloc 分配的内存未初始化，内容不确定。
释放对应性：由 malloc 分配的内存必须使用 free 释放，避免使用 delete。

C++ 内存管理#

C++ 提供了更高层次的内存管理操作符：new 和 delete，它们不仅分配和释放内存，还调用构造函数和析构函数，提供类型安全。

`new` 操作符#

用于在堆上分配对象，并调用其构造函数。

单个对象

1
Type* ptr = new Type(parameters);

例子：

1
#include <iostream>
2

3
class MyClass {
4
public:
5
    MyClass(int val) : value(val) {
6
        std::cout << "Constructor called with value: " << value << std::endl;
7
    }
8
    ~MyClass() {
9
        std::cout << "Destructor called for value: " << value << std::endl;
10
    }
11
    int value;
12
};
13

14
int main() {
15
    MyClass* obj = new MyClass(10);
16
    std::cout << "Object value: " << obj->value << std::endl;
17
    delete obj; // 调用析构函数并释放内存
18
    return 0;
19
}

展开收起

输出：

1
Constructor called with value: 10
2
Object value: 10
3
Destructor called for value: 10

数组

1
Type* array = new Type[size];

例子：

1
#include <iostream>
2

3
int main() {
4
    int* arr = new int[5]; // 分配5个整数
5
    for (int i = 0; i < 5; ++i) {
6
        arr[i] = i * 10;
7
    }
8
    for (int i = 0; i < 5; ++i) {
9
        std::cout << "arr[" << i << "] = " << arr[i] << std::endl;
10
    }
11
    delete[] arr; // 释放数组内存
12
    return 0;
13
}

输出：

1
arr[0] = 0
2
arr[1] = 10
3
arr[2] = 20
4
arr[3] = 30
5
arr[4] = 40

delete** 操作符**

用于释放由 new 分配的内存，并调用析构函数。

释放单个对象#

1
delete ptr;

释放数组#

1
delete[] ptr;

区别于 `malloc` 和 `free`#

类型安全：new 返回正确类型的指针，免去了强制类型转换。
构造/析构：new 和 delete 自动调用构造函数和析构函数。
异常处理：在分配失败时，new 默认抛出 std::bad_alloc 异常，而 malloc 返回 nullptr。

异常安全的 `new`#

可以通过 nothrow 参数防止 new 抛出异常，改为返回 nullptr。

1
#include <iostream>
2
#include <new> // 包含 std::nothrow
3

4
int main() {
5
    int* p = new(std::nothrow) int;
6
    if (p == nullptr) {
7
        std::cerr << "Memory allocation failed" << std::endl;
8
        return 1;
9
    }
10
    *p = 100;
11
    std::cout << "Value: " << *p << std::endl;
12
    delete p;
13
    return 0;
14
}

总结和对比#

了解 malloc/free 与 new/delete 的区别，有助于在编写 C++ 程序时正确选择内存管理方法。

特性	malloc/free	new/delete
类型安全	需要显式类型转换	自动类型转换，无需显式转换
构造/析构函数	不调用对象的构造/析构函数	调用对象的构造/析构函数
返回值	`void*`，需要转换为目标类型	返回目标类型指针，类型安全
错误处理	分配失败返回 `nullptr`	分配失败抛出 `std::bad_alloc` 异常
多态行为	无	支持多态，通过虚函数正确调用析构函数
内存分配与释放对应性	必须使用 `free` 释放由 `malloc` 分配的内存	必须使用 `delete` 释放由 `new` 分配的内存

示例对比#

**使用 malloc 和 **free

1
#include <iostream>
2
#include <cstdlib>
3

4
class MyClass {
5
public:
6
    MyClass(int val) : value(val) { std::cout << "Constructor called" << std::endl; }
7
    ~MyClass() { std::cout << "Destructor called" << std::endl; }
8
    int value;
9
};
10

11
int main() {
12
    // 使用 malloc 分配内存
13
    MyClass* obj = (MyClass*)malloc(sizeof(MyClass));
14
    if (obj == nullptr) {
15
        std::cerr << "malloc failed" << std::endl;
16
        return 1;
17
    }
18

19
    // 手动调用构造函数（不推荐）
20
    new(obj) MyClass(20); // 通过“定位 new”调用构造函数
21

22
    std::cout << "Value: " << obj->value << std::endl;
23

24
    // 手动调用析构函数
25
    obj->~MyClass();
26

27
    // 释放内存
28
    free(obj);
29
    return 0;
30
}

展开收起

注意：使用 malloc 分配 C++ 对象时，需要手动调用构造函数和析构函数，这非常不便且易出错。因此，推荐使用 new 和 delete。

**使用 new 和 **delete

1
#include <iostream>
2

3
class MyClass {
4
public:
5
    MyClass(int val) : value(val) { std::cout << "Constructor called" << std::endl; }
6
    ~MyClass() { std::cout << "Destructor called" << std::endl; }
7
    int value;
8
};
9

10
int main() {
11
    // 使用 new 分配内存并调用构造函数
12
    MyClass* obj = new MyClass(30);
13
    std::cout << "Value: " << obj->value << std::endl;
14

15
    // 使用 delete 释放内存并调用析构函数
16
    delete obj;
17
    return 0;
18
}

展开收起

输出：

1
Constructor called
2
Value: 30
3
Destructor called

兼容性#

C++ 类型特性：new 和 delete 支持 C++ 的类型特性，包括构造函数、析构函数、多态等。
C 兼容性：在需要兼容 C 代码或通过 C 接口分配内存时，仍可能需要使用 malloc 和 free。

高级内存管理#

使用 realloc 进行内存重分配#

realloc 用于调整之前分配的内存块大小。这在动态数组等数据结构中非常有用。

原型

1
#include <cstdlib>
2

3
void* realloc(void* ptr, size_t new_size);

参数：
- ptr：指向之前分配的内存块。
- new_size：新的内存大小（以字节为单位）。
返回值：指向重新分配后的内存块的新指针。如果重新分配失败，返回 nullptr，原内存块保持不变。

示例代码

1
#include <iostream>
2
#include <cstdlib>
3
#include <cstring> // 包含 memcpy
4

5
int main() {
6
    // 初始分配 3 个整数
7
    int* arr = (int*)malloc(3 * sizeof(int));
8
    if (arr == nullptr) {
9
        std::cerr << "Initial malloc failed" << std::endl;
10
        return 1;
11
    }
12

13
    // 初始化数组
14
    for (int i = 0; i < 3; ++i) {
15
        arr[i] = i + 1;
16
    }
17

18
    std::cout << "Initial array: ";
19
    for (int i = 0; i < 3; ++i) {
20
        std::cout << arr[i] << " ";
21
    }
22
    std::cout << std::endl;
23

24
    // 重新分配为 5 个整数
25
    int* temp = (int*)realloc(arr, 5 * sizeof(int));
26
    if (temp == nullptr) {
27
        std::cerr << "Realloc failed" << std::endl;
28
        free(arr); // 释放原内存
29
        return 1;
30
    }
31
    arr = temp;
32

33
    // 初始化新元素
34
    for (int i = 3; i < 5; ++i) {
35
        arr[i] = (i + 1) * 10;
36
    }
37

38
    std::cout << "Reallocated array: ";
39
    for (int i = 0; i < 5; ++i) {
40
        std::cout << arr[i] << " ";
41
    }
42
    std::cout << std::endl;
43

44
    // 释放内存
45
    free(arr);
46
    return 0;
47
}

展开收起

输出：

1
Initial array: 1 2 3
2
Reallocated array: 1 2 3 40 50

动态数组管理#

使用 malloc 和 realloc 来手动管理动态数组可以实现可变大小的数组，但需要处理内存分配、释放和数据复制。

封装动态数组

1
#include <iostream>
2
#include <cstdlib>
3
#include <cstring>
4

5
class DynamicArray {
6
public:
7
    DynamicArray(size_t initial_size = 1)
8
        : size(initial_size), data((int*)malloc(size * sizeof(int))) {
9
        if (data == nullptr) {
10
            throw std::bad_alloc();
11
        }
12
    }
13

14
    ~DynamicArray() {
15
        free(data);
16
    }
17

18
    void resize(size_t new_size) {
19
        int* temp = (int*)realloc(data, new_size * sizeof(int));
20
        if (temp == nullptr) {
21
            throw std::bad_alloc();
22
        }
23
        data = temp;
24
        size = new_size;
25
    }
26

27
    int& operator[](size_t index) {
28
        return data[index];
29
    }
30

31
    size_t getSize() const { return size; }
32

33
private:
34
    size_t size;
35
    int* data;
36
};
37

38
int main() {
39
    try {
40
        DynamicArray arr(3);
41
        // 初始化
42
        for (size_t i = 0; i < arr.getSize(); ++i) {
43
            arr[i] = i + 1;
44
        }
45

46
        std::cout << "Initial array: ";
47
        for (size_t i = 0; i < arr.getSize(); ++i) {
48
            std::cout << arr[i] << " ";
49
        }
50
        std::cout << std::endl;
51

52
        // 调整大小
53
        arr.resize(5);
54
        arr[3] = 40;
55
        arr[4] = 50;
56

57
        std::cout << "Resized array: ";
58
        for (size_t i = 0; i < arr.getSize(); ++i) {
59
            std::cout << arr[i] << " ";
60
        }
61
        std::cout << std::endl;
62

63
    }
64
    catch (const std::bad_alloc& e) {
65
        std::cerr << "Memory allocation error: " << e.what() << std::endl;
66
        return 1;
67
    }
68

69
    return 0;
70
}

展开收起

输出：

1
Initial array: 1 2 3
2
Resized array: 1 2 3 40 50

注意：这种方式需要手动管理内存和数组大小，且缺乏类型安全性和自动化。推荐使用 C++ 标准容器如 std::vector 来代替。

实际案例#

案例一：动态数组实现#

实现一个简单的动态数组类，支持添加元素、访问元素和自动扩展。

代码示例

1
#include <iostream>
2
#include <cstdlib>
3
#include <stdexcept>
4

5
class DynamicArray {
6
public:
7
    DynamicArray()
8
        : capacity(2), size(0), data((int*)malloc(capacity * sizeof(int))) {
9
        if (data == nullptr) {
10
            throw std::bad_alloc();
11
        }
12
    }
13

14
    ~DynamicArray() {
15
        free(data);
16
    }
17

18
    void add(int value) {
19
        if (size == capacity) {
20
            resize(capacity * 2);
21
        }
22
        data[size++] = value;
23
    }
24

25
    int get(size_t index) const {
26
        if (index >= size) {
27
            throw std::out_of_range("Index out of range");
28
        }
29
        return data[index];
30
    }
31

32
    size_t getSize() const { return size; }
33

34
private:
35
    void resize(size_t new_capacity) {
36
        int* temp = (int*)realloc(data, new_capacity * sizeof(int));
37
        if (temp == nullptr) {
38
            throw std::bad_alloc();
39
        }
40
        data = temp;
41
        capacity = new_capacity;
42
    }
43

44
    size_t capacity;
45
    size_t size;
46
    int* data;
47
};
48

49
int main() {
50
    try {
51
        DynamicArray arr;
52
        arr.add(10);
53
        arr.add(20);
54
        arr.add(30); // 触发扩展
55

56
        std::cout << "Dynamic Array Contents:" << std::endl;
57
        for (size_t i = 0; i < arr.getSize(); ++i) {
58
            std::cout << arr.get(i) << " ";
59
        }
60
        std::cout << std::endl;
61
    }
62
    catch (const std::bad_alloc& e) {
63
        std::cerr << "Memory allocation error: " << e.what() << std::endl;
64
        return 1;
65
    }
66
    catch (const std::out_of_range& e) {
67
        std::cerr << "Array access error: " << e.what() << std::endl;
68
        return 1;
69
    }
70

71
    return 0;
72
}

展开收起

输出：

1
Dynamic Array Contents:
2
10 20 30

案例二：自定义内存管理器#

实现一个简单的内存池，用于高效分配和释放固定大小的对象。

代码示例

1
#include <iostream>
2
#include <cstdlib>
3
#include <stack>
4

5
class MemoryPool {
6
public:
7
    MemoryPool(size_t objectSize, size_t poolSize)
8
        : objSize(objectSize), totalSize(poolSize), pool((char*)malloc(objectSize * poolSize)) {
9
        if (pool == nullptr) {
10
            throw std::bad_alloc();
11
        }
12
        // 初始化 free list
13
        for (size_t i = 0; i < poolSize; ++i) {
14
            freeList.push(pool + i * objectSize);
15
        }
16
    }
17

18
    ~MemoryPool() {
19
        free(pool);
20
    }
21

22
    void* allocate() {
23
        if (freeList.empty()) {
24
            throw std::bad_alloc();
25
        }
26
        void* ptr = freeList.top();
27
        freeList.pop();
28
        return ptr;
29
    }
30

31
    void deallocate(void* ptr) {
32
        freeList.push((char*)ptr);
33
    }
34

35
private:
36
    size_t objSize;
37
    size_t totalSize;
38
    char* pool;
39
    std::stack<void*> freeList;
40
};
41

42
class MyClass {
43
public:
44
    MyClass(int val) : value(val) {
45
        std::cout << "MyClass constructor: " << value << std::endl;
46
    }
47
    ~MyClass() {
48
        std::cout << "MyClass destructor: " << value << std::endl;
49
    }
50
    int value;
51
};
52

53
int main() {
54
    try {
55
        // 创建一个能容纳 3 个 MyClass 对象的内存池
56
        MemoryPool pool(sizeof(MyClass), 3);
57

58
        // 分配对象内存
59
        void* mem1 = pool.allocate();
60
        void* mem2 = pool.allocate();
61

62
        // 使用“定位 new”构造对象
63
        MyClass* obj1 = new(mem1) MyClass(100);
64
        MyClass* obj2 = new(mem2) MyClass(200);
65

66
        // 使用对象
67
        std::cout << "obj1 value: " << obj1->value << std::endl;
68
        std::cout << "obj2 value: " << obj2->value << std::endl;
69

70
        // 显式调用析构函数
71
        obj1->~MyClass();
72
        obj2->~MyClass();
73

74
        // 释放内存
75
        pool.deallocate(mem1);
76
        pool.deallocate(mem2);
77

78
    }
79
    catch (const std::bad_alloc& e) {
80
        std::cerr << "Memory pool allocation error: " << e.what() << std::endl;
81
        return 1;
82
    }
83

84
    return 0;
85
}

展开收起

输出：

1
MyClass constructor: 100
2
MyClass constructor: 200
3
obj1 value: 100
4
obj2 value: 200
5
MyClass destructor: 100
6
MyClass destructor: 200

说明：

MemoryPool 管理固定大小的内存块，避免频繁调用 malloc 和 free。
使用“定位 new”在预分配的内存上构造对象。
需要手动调用析构函数和将内存返回给内存池。

注意：这种方法适用于大量小对象的高效管理，但需要确保正确使用构造和析构函数。

避免内存泄漏#

内存泄漏是指程序分配的内存未被释放，导致内存被浪费，甚至耗尽。避免内存泄漏的策略包括：

**确保每个 new 有对应的 **delete。
使用 RAII 和智能指针：自动管理资源，避免手动管理内存。
工具辅助：使用工具如 Valgrind 检测内存泄漏。

示例：内存泄漏

1
#include <iostream>
2

3
int main() {
4
    int* p = new int(10);
5
    // 忘记 delete p; 导致内存泄漏
6
    return 0;
7
}

解决方法：

1
#include <iostream>
2

3
int main() {
4
    int* p = new int(10);
5
    // 正确释放内存
6
    delete p;
7
    return 0;
8
}

`RAII`（资源获取即初始化）#

RAII 是 C++ 中的一种编程惯用法，通过对象的生命周期管理资源，确保资源在对象构造时获取，析构时释放，避免泄漏。

示例：RAII** 实现类似于**shared_ptr智能指针

std::shared_ptr 是 C++ 标准库中功能强大的智能指针之一，提供了共享所有权的能力，使得多个指针可以共同管理同一个动态分配的对象。通过引用计数机制，shared_ptr 确保了对象在最后一个指针被销毁时自动释放，极大地简化了内存管理，防止了内存泄漏和悬挂指针问题。

`SimpleSharedPtr` 的基本概念#

SimpleSharedPtr 是一个简化版的 shared_ptr 实现，旨在帮助理解其核心机制。其基本功能包括：

共享所有权：多个 SimpleSharedPtr 实例可以指向同一个对象，共享对该对象的所有权。
自动管理生命周期：当最后一个 SimpleSharedPtr 被销毁或指向其他对象时，管理的对象被自动释放。
引用计数：内部维护一个引用计数，记录有多少个 SimpleSharedPtr 实例指向同一个对象。

引用计数控制块的设计#

为了实现引用计数机制，SimpleSharedPtr 需要一个控制块（Control Block），它包含：

引用计数（ref_count）：记录有多少个 SimpleSharedPtr 指向同一个对象。
指向对象的指针（ptr）：指向实际管理的对象。

控制块通常与被管理对象一起被分配，但为了简化实现，本示例将它们独立管理。

1
struct ControlBlock {
2
    int ref_count;    // 引用计数
3
    // 可以扩展为包含自定义删除器等
4

5
    ControlBlock() : ref_count(1) {}
6
};

`SimpleSharedPtr` 的实现#

类结构

SimpleSharedPtr 是一个模板类，模板参数 T 表示它所管理的对象类型。

1
template <typename T>
2
class SimpleSharedPtr {
3
private:
4
    T* ptr;                // 指向管理的对象
5
    ControlBlock* control; // 指向控制块
6

7
public:
8
    // 构造函数、析构函数、拷贝与移动操作、操作符重载等
9
};

构造函数与析构函数

默认构造函数：初始化指针和控制块为空。
参数化构造函数：接受一个裸指针，初始化控制块，并引用计数为1。
析构函数：减少引用计数，若引用计数为0，则释放对象和控制块。

1
// 默认构造函数
2
SimpleSharedPtr() : ptr(nullptr), control(nullptr) {}
3

4
// 参数化构造函数
5
explicit SimpleSharedPtr(T* p) : ptr(p) {
6
    if (p) {
7
        control = new ControlBlock();
8
    } else {
9
        control = nullptr;
10
    }
11
}
12

13
// 析构函数
14
~SimpleSharedPtr() {
15
    release();
16
}

展开收起

**辅助函数 **release：

1
private:
2
void release() {
3
    if (control) {
4
        control->ref_count--;
5
        if (control->ref_count == 0) {
6
            delete ptr;
7
            delete control;
8
        }
9
    }
10
    ptr = nullptr;
11
    control = nullptr;
12
}

拷贝构造与拷贝赋值#

拷贝构造函数和拷贝赋值操作符允许多个 SimpleSharedPtr 实例共享同一个对象，共享相同的控制块。

1
// 拷贝构造函数
2
SimpleSharedPtr(const SimpleSharedPtr& other) : ptr(other.ptr), control(other.control) {
3
    if (control) {
4
        control->ref_count++;
5
    }
6
}
7

8
// 拷贝赋值操作符
9
SimpleSharedPtr& operator=(const SimpleSharedPtr& other) {
10
    if (this != &other) {
11
        // 释放当前资源
12
        release();
13

14
        // 复制新的资源和控制块
15
        ptr = other.ptr;
16
        control = other.control;
17
        if (control) {
18
            control->ref_count++;
19
        }
20
    }
21
    return *this;
22
}

展开收起

移动构造与移动赋值#

移动语义允许资源所有权从一个 SimpleSharedPtr 转移到另一个，而不增加引用计数。

1
// 移动构造函数
2
SimpleSharedPtr(SimpleSharedPtr&& other) noexcept : ptr(other.ptr), control(other.control) {
3
    other.ptr = nullptr;
4
    other.control = nullptr;
5
}
6

7
// 移动赋值操作符
8
SimpleSharedPtr& operator=(SimpleSharedPtr&& other) noexcept {
9
    if (this != &other) {
10
        // 释放当前资源
11
        release();
12

13
        // 接管 `other` 的资源
14
        ptr = other.ptr;
15
        control = other.control;
16

17
        // 置 `other` 为空
18
        other.ptr = nullptr;
19
        other.control = nullptr;
20
    }
21
    return *this;
22
}

展开收起

操作符重载#

重载 * 和 -> 操作符，以便像使用原生指针一样使用 SimpleSharedPtr。

1
// 解引用操作符
2
T& operator*() const {
3
    return *ptr;
4
}
5

6
// 箭头操作符
7
T* operator->() const {
8
    return ptr;
9
}

其他成员函数#

use_count：返回当前引用计数。
get：返回裸指针。
reset：重置指针，指向新对象或 nullptr。

1
// 获取引用计数
2
int use_count() const {
3
    return control ? control->ref_count : 0;
4
}
5

6
// 获取裸指针
7
T* get() const {
8
    return ptr;
9
}
10

11
// 重置指针
12
void reset(T* p = nullptr) {
13
    // 释放当前资源
14
    release();
15

16
    // 指向新资源
17
    ptr = p;
18
    if (p) {
19
        control = new ControlBlock();
20
    } else {
21
        control = nullptr;
22
    }
23
}

展开收起

完整代码示例#

以下是 SimpleSharedPtr 的完整实现及其使用示例。

1
#include <iostream>
2

3
// 控制块结构
4
struct ControlBlock {
5
    int ref_count;
6

7
    ControlBlock() : ref_count(1) {}
8
};
9

10
// 简化版的 shared_ptr 实现
11
template <typename T>
12
class SimpleSharedPtr {
13
private:
14
    T* ptr;                // 指向管理的对象
15
    ControlBlock* control; // 指向控制块
16

17
    // 释放当前资源
18
    void release() {
19
        if (control) {
20
            control->ref_count--;
21
            std::cout << "Decremented ref_count to " << control->ref_count << std::endl;
22
            if (control->ref_count == 0) {
23
                delete ptr;
24
                delete control;
25
                std::cout << "Resource and ControlBlock destroyed." << std::endl;
26
            }
27
        }
28
        ptr = nullptr;
29
        control = nullptr;
30
    }
31

32
public:
33
    // 默认构造函数
34
    SimpleSharedPtr() : ptr(nullptr), control(nullptr) {
35
        std::cout << "Default constructed SimpleSharedPtr (nullptr)." << std::endl;
36
    }
37

38
    // 参数化构造函数
39
    explicit SimpleSharedPtr(T* p) : ptr(p) {
40
        if (p) {
41
            control = new ControlBlock();
42
            std::cout << "Constructed SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;
43
        } else {
44
            control = nullptr;
45
        }
46
    }
47

48
    // 拷贝构造函数
49
    SimpleSharedPtr(const SimpleSharedPtr& other) : ptr(other.ptr), control(other.control) {
50
        if (control) {
51
            control->ref_count++;
52
            std::cout << "Copied SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;
53
        }
54
    }
55

56
    // 拷贝赋值操作符
57
    SimpleSharedPtr& operator=(const SimpleSharedPtr& other) {
58
        if (this != &other) {
59
            release();
60
            ptr = other.ptr;
61
            control = other.control;
62
            if (control) {
63
                control->ref_count++;
64
                std::cout << "Assigned SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;
65
            }
66
        }
67
        return *this;
68
    }
69

70
    // 移动构造函数
71
    SimpleSharedPtr(SimpleSharedPtr&& other) noexcept : ptr(other.ptr), control(other.control) {
72
        other.ptr = nullptr;
73
        other.control = nullptr;
74
        std::cout << "Moved SimpleSharedPtr." << std::endl;
75
    }
76

77
    // 移动赋值操作符
78
    SimpleSharedPtr& operator=(SimpleSharedPtr&& other) noexcept {
79
        if (this != &other) {
80
            release();
81
            ptr = other.ptr;
82
            control = other.control;
83
            other.ptr = nullptr;
84
            other.control = nullptr;
85
            std::cout << "Move-assigned SimpleSharedPtr." << std::endl;
86
        }
87
        return *this;
88
    }
89

90
    // 析构函数
91
    ~SimpleSharedPtr() {
92
        release();
93
    }
94

95
    // 解引用操作符
96
    T& operator*() const {
97
        return *ptr;
98
    }
99

100
    // 箭头操作符
101
    T* operator->() const {
102
        return ptr;
103
    }
104

105
    // 获取引用计数
106
    int use_count() const {
107
        return control ? control->ref_count : 0;
108
    }
109

110
    // 获取裸指针
111
    T* get() const {
112
        return ptr;
113
    }
114

115
    // 重置指针
116
    void reset(T* p = nullptr) {
117
        release();
118
        ptr = p;
119
        if (p) {
120
            control = new ControlBlock();
121
            std::cout << "Reset SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;
122
        } else {
123
            control = nullptr;
124
        }
125
    }
126
};
127

128
// 测试类
129
class Test {
130
public:
131
    Test(int val) : value(val) {
132
        std::cout << "Test Constructor: " << value << std::endl;
133
    }
134
    ~Test() {
135
        std::cout << "Test Destructor: " << value << std::endl;
136
    }
137
    void show() const {
138
        std::cout << "Value: " << value << std::endl;
139
    }
140

141
private:
142
    int value;
143
};
144

145
int main() {
146
    std::cout << "Creating default constructed shared_ptr..." << std::endl;
147
    SimpleSharedPtr<Test> ptr1; // 默认构造
148
    std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl;
149

150
    std::cout << "\nCreating shared_ptr with resource..." << std::endl;
151
    SimpleSharedPtr<Test> ptr2(new Test(100)); // 非默认构造
152
    std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;
153
    ptr2->show();
154

155
    std::cout << "\nCopying ptr2 to ptr3..." << std::endl;
156
    SimpleSharedPtr<Test> ptr3 = ptr2; // 拷贝构造
157
    std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;
158
    std::cout << "ptr3 use_count: " << ptr3.use_count() << std::endl;
159
    ptr3->show();
160

161
    std::cout << "\nAssigning ptr3 to ptr1..." << std::endl;
162
    ptr1 = ptr3; // 拷贝赋值
163
    std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl;
164
    std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;
165
    std::cout << "ptr3 use_count: " << ptr3.use_count() << std::endl;
166

167
    std::cout << "\nResetting ptr2..." << std::endl;
168
    ptr2.reset(new Test(200)); // 重新指向新的对象
169
    std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;
170
    ptr2->show();
171
    std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl;
172
    std::cout << "ptr3 use_count: " << ptr3.use_count() << std::endl;
173

174
    std::cout << "\nExiting scope..." << std::endl;
175
    } // ptr2, ptr1, ptr3 离开作用域
176

177
    std::cout << "End of main." << std::endl;
178
    return 0;
179
}

展开收起

`SimpleUniquePtr` 的实现#

std::unique_ptr 是一种独占所有权的智能指针，确保在任意时刻，只有一个 unique_ptr 实例指向特定资源。它不支持拷贝操作，只支持移动操作。

基本结构#

首先，定义一个模板类 SimpleUniquePtr，它持有一个指向资源的裸指针：

1
template <typename T>
2
class SimpleUniquePtr {
3
private:
4
    T* ptr; // 指向管理对象的裸指针
5

6
public:
7
    // 构造函数、析构函数、删除拷贝构造与拷贝赋值
8
    // 实现移动构造与移动赋值
9
    // 重载操作符
10
};

构造函数与析构函数#

默认构造函数：初始化指针为空。
参数化构造函数：接受一个指向资源的裸指针。
析构函数：当 SimpleUniquePtr 被销毁时，释放所管理的资源。

1
// 默认构造函数
2
SimpleUniquePtr() : ptr(nullptr) {}
3

4
// 参数化构造函数
5
explicit SimpleUniquePtr(T* p) : ptr(p) {}
6

7
// 析构函数
8
~SimpleUniquePtr() {
9
    delete ptr;
10
}

删除拷贝构造与拷贝赋值#

为了确保唯一性，禁止拷贝构造和拷贝赋值：

1
// 删除拷贝构造
2
SimpleUniquePtr(const SimpleUniquePtr&) = delete;
3

4
// 删除拷贝赋值
5
SimpleUniquePtr& operator=(const SimpleUniquePtr&) = delete;

移动语义#

支持移动构造和移动赋值，以转移所有权：

1
// 移动构造
2
SimpleUniquePtr(SimpleUniquePtr&& other) noexcept : ptr(other.ptr) {
3
    other.ptr = nullptr;
4
}
5

6
// 移动赋值
7
SimpleUniquePtr& operator=(SimpleUniquePtr&& other) noexcept {
8
    if (this != &other) {
9
        delete ptr;     // 释放当前资源
10
        ptr = other.ptr; // 转移所有权
11
        other.ptr = nullptr;
12
    }
13
    return *this;
14
}

操作符重载#

重载 * 和 -> 操作符，以模拟指针的行为：

1
// 解引用操作符
2
T& operator*() const {
3
    return *ptr;
4
}
5

6
// 箭头操作符
7
T* operator->() const {
8
    return ptr;
9
}
10

11
// 获取裸指针
12
T* get() const {
13
    return ptr;
14
}
15

16
// 释放所有权，返回裸指针并设为 nullptr
17
T* release() {
18
    T* temp = ptr;
19
    ptr = nullptr;
20
    return temp;
21
}
22

23
// 重新设定指针
24
void reset(T* p = nullptr) {
25
    delete ptr;
26
    ptr = p;
27
}

展开收起

示例代码#

以下示例展示了如何使用 SimpleUniquePtr：

1
#include <iostream>
2

3
// SimpleUniquePtr 实现
4
template <typename T>
5
class SimpleUniquePtr {
6
private:
7
    T* ptr;
8

9
public:
10
    // 默认构造函数
11
    SimpleUniquePtr() : ptr(nullptr) {}
12

13
    // 参数化构造函数
14
    explicit SimpleUniquePtr(T* p) : ptr(p) {}
15

16
    // 析构函数
17
    ~SimpleUniquePtr() {
18
        delete ptr;
19
    }
20

21
    // 删除拷贝构造和拷贝赋值
22
    SimpleUniquePtr(const SimpleUniquePtr&) = delete;
23
    SimpleUniquePtr& operator=(const SimpleUniquePtr&) = delete;
24

25
    // 移动构造
26
    SimpleUniquePtr(SimpleUniquePtr&& other) noexcept : ptr(other.ptr) {
27
        other.ptr = nullptr;
28
    }
29

30
    // 移动赋值
31
    SimpleUniquePtr& operator=(SimpleUniquePtr&& other) noexcept {
32
        if (this != &other) {
33
            delete ptr;
34
            ptr = other.ptr;
35
            other.ptr = nullptr;
36
        }
37
        return *this;
38
    }
39

40
    // 解引用操作符
41
    T& operator*() const {
42
        return *ptr;
43
    }
44

45
    // 箭头操作符
46
    T* operator->() const {
47
        return ptr;
48
    }
49

50
    // 获取裸指针
51
    T* get() const {
52
        return ptr;
53
    }
54

55
    // 释放所有权
56
    T* release() {
57
        T* temp = ptr;
58
        ptr = nullptr;
59
        return temp;
60
    }
61

62
    // 重新设定指针
63
    void reset(T* p = nullptr) {
64
        delete ptr;
65
        ptr = p;
66
    }
67
};
68

69
// 测试类
70
class Test {
71
public:
72
    Test(int val) : value(val) {
73
        std::cout << "Test Constructor: " << value << std::endl;
74
    }
75
    ~Test() {
76
        std::cout << "Test Destructor: " << value << std::endl;
77
    }
78
    void show() const {
79
        std::cout << "Value: " << value << std::endl;
80
    }
81

82
private:
83
    int value;
84
};
85

86
int main() {
87
    // 创建一个 SimpleUniquePtr
88
    SimpleUniquePtr<Test> ptr1(new Test(1));
89
    ptr1->show();
90
    (*ptr1).show();
91

92
    // 移动所有权到 ptr2
93
    SimpleUniquePtr<Test> ptr2 = std::move(ptr1);
94
    if (ptr1.get() == nullptr) {
95
        std::cout << "ptr1 is now nullptr after move." << std::endl;
96
    }
97
    ptr2->show();
98

99
    // 释放所有权
100
    Test* rawPtr = ptr2.release();
101
    if (ptr2.get() == nullptr) {
102
        std::cout << "ptr2 is now nullptr after release." << std::endl;
103
    }
104
    rawPtr->show();
105
    delete rawPtr; // 手动删除
106

107
    // 使用 reset
108
    ptr2.reset(new Test(2));
109
    ptr2->show();
110

111
    ptr2.reset(); // 自动删除
112
    if (ptr2.get() == nullptr) {
113
        std::cout << "ptr2 is now nullptr after reset." << std::endl;
114
    }
115

116
    return 0;
117
}

展开收起

输出：

1
Test Constructor: 1
2
Value: 1
3
Value: 1
4
ptr1 is now nullptr after move.
5
Value: 1
6
ptr2 is now nullptr after release.
7
Value: 1
8
Test Destructor: 1
9
Test Constructor: 2
10
Value: 2
11
Test Destructor: 2
12
ptr2 is now nullptr after reset.

解释：

创建 ptr1 并指向一个 Test 对象。
使用 std::move 将所有权转移到 ptr2，ptr1 变为 nullptr。
使用 release() 释放 ptr2 的所有权，获取裸指针后需要手动 delete。
使用 reset() 重新指向一个新的 Test 对象，自动释放之前的资源。

类相关面试题

Wed, 20 May 2026 00:00:00 GMT

什么是默认构造#

默认构造就是不带参数的构造函数，如果我们不实现任何构造函数，系统会为我们生成一个默认的构造函数

比如下面

1
#include <thread>
2
class JoiningThread {
3
public:
4
    int GetIndex() const { return _i; }
5
private:
6
    std::thread _t;
7
    int _i;
8
};

所以我们可以直接使用默认构造函数构造一个对象，并且打印成员_i

1
//测试默认合成
2
JoiningThread jt;
3
std::cout << "member _i is " << jt.GetIndex() << std::endl;

输出

Terminal window

1
member _i is -1284874240

可以看到默认构造函数并不会帮我们初始化类成员变量。

什么是有参构造#

有参构造就是传递参数的构造函数，可以根据参数构造对象

1
#include <thread>
2
class JoiningThread {
3
public:
4
    JoiningThread(int i) : _i{i} {}
5
    int GetIndex() const { return _i; }
6
private:
7
    std::thread _t;
8
    int _i;
9
};

我们可以通过如下方式构造

1
JoiningThread jt(1);
2
std::cout << "member _i is " << jt.GetIndex() << std::endl;

当我们执行程序，会输出

Terminal window

1
member _i is 1

但如果这样构造会产生问题

1
JoiningThread jt;
2
std::cout << "member _i is " << jt.GetIndex() << std::endl;

注意

如果我们实现了参数构造而不实现无参构造，系统将不会为我们实现默认构造，导致无法使用默认构造生成对象。

所以稳妥一点，我们基本都会实现无参构造

1
#include <thread>
2
class JoiningThread {
3
public:
4
    JoiningThread() :_i(0){}
5
    JoiningThread(int i) : _i{i} {}
6
    int GetIndex() const { return _i; }
7
private:
8
    std::thread _t;
9
    int _i;
10
};

拷贝构造函数是什么#

回答要点：

定义：拷贝构造函数用于创建一个对象，该对象是通过复制另一个同类型对象来初始化的。
调用时机：
- 使用现有对象初始化新对象。
- 按值传递对象作为函数参数。
- 按值返回对象。
默认拷贝构造函数：成员逐个拷贝。

示例：

1
class MyClass {
2
public:
3
    MyClass(const MyClass& other) { // 拷贝构造函数
4
        // 复制代码
5
    }
6
};

是否会默认生成拷贝构造#

在 C++ 中，如果你没有为一个类显式定义拷贝构造函数，编译器会自动生成一个默认的拷贝构造函数。这个默认拷贝构造函数会按成员的逐个拷贝（member-wise copy）方式来复制对象的每个成员变量。

默认拷贝构造函数的行为#

逐个拷贝：默认拷贝构造函数会逐个拷贝所有的非静态成员变量。
指针成员：如果类中有指针成员，默认拷贝构造函数只会拷贝指针的值（地址），而不会拷贝指针所指向的对象。这可能会导致多个对象指向同一块内存，进而引发问题（如双重释放、内存泄漏等）。
const** 和**引用成员：如果类中有 const 成员或引用成员，编译器不会生成默认的拷贝构造函数，因为这些成员不能被复制。
类中包含不可拷贝对象时，无法合成默认拷贝构造函数

拷贝构造是否必须实现#

当一个类A中有成员变量是另一个类类型B的时候，有时候拷贝构造会失效。

比如一个类JoiningThread中有成员变量std::thread，std::thread没有构造函数，所以A类的拷贝构造无法合成，需要显示编写。

比如我们这样调用

1
JoiningThread jt(1);
2
JoiningThread jt2(jt);
3
std::cout << "member _i is " << jt.GetIndex() << std::endl;

上面代码报错

1
error: use of deleted function 'std::thread::thread(const std::thread&)'

所以我们要显示实现拷贝构造，指定一个拷贝规则

1
JoiningThread(const JoiningThread & other): _i(other._i){}

什么是浅拷贝和深拷贝#

类在拷贝构造或者拷贝赋值的时候，将被拷贝的类中的成员值拷贝到目的类，如果被拷贝的类中包含指针成员，只是简单的拷贝指针的值。

同样析构也要显示编写，等待线程完成。

除此之外我们可以自己实现拷贝构造，进而实现浅拷贝和深拷贝的不同效果

浅拷贝是指对象复制时，仅复制指针的值（地址），而不复制指针所指向的实际数据。结果是两个对象的指针成员指向同一块堆内存。

深拷贝是指对象复制时，为指针成员重新分配内存，并将原对象指向的数据内容逐字节复制到新分配的内存中。结果是两个对象的指针成员指向各自独立的两块内存，数据内容相同但互不影响。

构造顺序和析构顺序#

类A中包含成员变量是类B的类型，如果是先调用A的构造还是B的构造呢？

如果析构的时候是A先析构还是B先析构呢？

1
class InnerB {
2
public:
3
    InnerB() {
4
        std::cout << "InnerB()" << std::endl;
5
    }
6

7
    ~InnerB(){
8
        std::cout << "~InnerB()" << std::endl;
9
    }
10
};
11

12
class WrapperC {
13
public:
14
    WrapperC(){
15
        std::cout << "WrapperC()" << std::endl;
16
    }
17
    ~WrapperC(){
18
        std::cout << "~WrapperC()" << std::endl;
19
    }
20
    InnerB _inner;
21
};

展开收起

执行结果，先调用B的构造，在调用C的构造。

析构时，先析构C再析构B

1
InnerB()
2
WrapperC()
3
~WrapperC()
4
~InnerB()

类默认构造是否必须实现#

如果类中有继承关系或者其他类型的成员，默认构造函数是很有必要实现的。

系统提供的合成的默认构造函数不会对成员做初始化操作。

比如我们之后要学到的继承

1
class DerivedA: public BaseA {
2
public:
3
    DerivedA(std::string name,std::string num) :
4
    BaseA(name), _num(num) {
5
        std::cout << "DerivedA()" << std::endl;
6
    }
7
private:
8
   std::string _num;
9
};

调用

1
 DerivedA a("zack","1001");

`this` 指针的特性和用途#

指向当前对象：
- this 指针是一个隐式参数，指向调用成员函数的对象。通过 this，你可以访问当前对象的属性和方法。
区分成员变量和参数：
- 在构造函数或成员函数中，参数名和成员变量可能同名。使用

1
this

可以明确指代成员变量。例如：

1
class MyClass {
2
private:
3
    int value;
4
public:
5
    MyClass(int value) {
6
        this->value = value; // 使用 this 指针区分成员变量和参数
7
    }
8
};

返回当前对象：

1
this

可以用于返回当前对象的引用，以支持链式调用。例如：

1
class MyClass {
2
private:
3
    int value;
4
public:
5
    MyClass& setValue(int value) {
6
        this->value = value;
7
        return *this; // 返回当前对象的引用
8
    }
9
};
10

11
MyClass obj;
12
obj.setValue(10).setValue(20); // 链式调用

在 const 成员函数中的使用：
- 在 const 成员函数中，this 的类型为 const MyClass*，这意味着你不能通过 this 修改成员变量。这有助于确保对象的状态不被改变。
在静态成员函数中的不可用性：
- 静态成员函数没有 this 指针，因为它们不属于任何特定对象，而是属于类本身。因此，静态成员函数不能访问非静态成员变量和成员函数。

示例代码

以下是一个简单的示例，展示了 this 指针的用法：

1
#include <iostream>
2

3
class MyClass {
4
private:
5
    int value;
6

7
public:
8
    // 构造函数
9
    MyClass(int value) {
10
        this->value = value; // 使用 this 指针区分成员变量和参数
11
    }
12

13
    // 成员函数
14
    MyClass& setValue(int value) {
15
        this->value = value; // 使用 this 指针
16
        return *this; // 返回当前对象的引用
17
    }
18

19
    // 输出值
20
    void printValue() const {
21
        std::cout << "Value: " << this->value << std::endl; // 使用 this 指针
22
    }
23
};
24

25
int main() {
26
    MyClass obj(10);
27
    obj.printValue(); // 输出: Value: 10
28

29
    obj.setValue(20).printValue(); // 链式调用，输出: Value: 20
30

31
    return 0;
32
}

展开收起

delete和default#

C++11用法：

delete可以删除指定的构造函数。

default可以指定某个构造函数为系统默认合成。

1
class DefaultClass {
2
public:
3
    DefaultClass() = default;
4
    ~DefaultClass() = default;
5
    DefaultClass(const DefaultClass &) = delete;
6
    DefaultClass &operator=(const DefaultClass &) = delete;
7
    friend std::ostream& operator << (std::ostream &out, const DefaultClass &defaultClass);
8
private:
9
    int _num ;
10
};

主函数中调用

1
DefaultClass b;
2
std::cout << b << std::endl;

输出num是一个随机数

Terminal window

1
DefaultClass num is 331

什么是移动构造函数？与拷贝构造函数有何不同？#

回答要点：

定义：移动构造函数用于通过“移动”资源来初始化对象，而不是复制资源。
语法：使用右值引用作为参数 (MyClass(MyClass&& other)).
优势：
- 性能更高，避免不必要的深拷贝。
- 适用于临时对象。
区别：
- 拷贝构造函数复制资源，移动构造函数转移资源所有权。

示例：

1
class MyClass {
2
public:
3
    MyClass(MyClass&& other) noexcept { // 移动构造函数
4
        // 移动资源
5
    }
6
};

默认构造函数和用户定义的构造函数有什么区别？#

回答要点：

默认构造函数：
- 无参数的构造函数。
- 如果没有用户定义的构造函数，编译器会自动生成一个默认构造函数。
用户定义的构造函数：
- 开发者自定义的构造函数，可以有参数。
- 一旦定义了任何构造函数，编译器不会再生成默认构造函数

示例：

1
class MyClass {
2
public:
3
    MyClass() { // 默认构造函数
4
        // 初始化代码
5
    }
6

7
    MyClass(int x) { // 有参数的构造函数
8
        // 初始化代码
9
    }
10
};

什么是初始化列表？为什么在构造函数中使用它？#

回答要点：

定义：初始化列表是在构造函数的参数列表之后，函数体之前，用于初始化成员变量的语法。
优点：
- 提高性能，特别是对于常量成员或引用成员。
- 必须用于初始化常量成员、引用成员以及基类。
- 避免对象先默认构造再赋值，减少不必要的操作。

示例：

1
class MyClass {
2
    string x;
3
    string y;
4
public:
5
    MyClass(string  a, string b):x(a),y(b)  { // 初始化列表
6
        // 其他初始化代码
7
    }
8
};

什么是虚析构函数？为什么需要它？#

回答要点：

定义：在基类中将析构函数声明为virtual，以确保通过基类指针删除派生类对象时，能正确调用派生类的析构函数。
用途：
- 防止内存泄漏。
- 确保派生类的资源被正确释放。
不使用虚析构函数的风险：
- 仅调用基类析构函数，导致派生类资源未释放。

示例：

如果BaseA的析构不写成虚析构，则主函数开辟子类对象赋值给基类指针，以后delete基类指针的时候会发现没有析构子类

1
class BaseA{
2
public:
3
    BaseA(std::string name):_name(name){
4
        std::cout << "BaseA()" << std::endl;
5
    }
6

7
    ~BaseA(){
8
        std::cout << "~BaseA()" << std::endl;
9
    }
10

11
private:
12
    std::string _name;
13
};
14

15
class DerivedA: public BaseA {
16
public:
17
    DerivedA(std::string name,std::string num) :
18
    BaseA(name), _num(num) {
19
        std::cout << "DerivedA()" << std::endl;
20
    }
21

22
    ~DerivedA(){
23
        std::cout << "~DerivedA()" << std::endl;
24
    }
25
private:
26
   std::string _num;
27
};

展开收起

主函数回收内存

1
BaseA* base = new DerivedA("zack","1002");
2
delete base;

会看到只调用了基类BaseA的析构函数。

当BaseA的析构改为虚析构的时候，才会回收子类DerivedA

1
class BaseA{
2
public:
3
    BaseA(std::string name):_name(name){
4
        std::cout << "BaseA()" << std::endl;
5
    }
6

7
    virtual ~BaseA(){
8
        std::cout << "~BaseA()" << std::endl;
9
    }
10

11
private:
12
    std::string _name;
13
};

什么是委托构造函数？它是如何工作的？（C++11引入的特性）#

回答要点：

定义：一个构造函数可以调用同一类中的另一个构造函数，从而委托初始化任务。
优点：
- 避免代码重复，提升代码可维护性。
语法：使用构造函数初始化列表中的类名和参数。

示例：

1
class MyClass {
2
    int x;
3
    int y;
4
public:
5
    MyClass() : MyClass(0, 0) { } // 委托构造函数
6

7
    MyClass(int a, int b) : x(a), y(b) { }
8
};

什么是析构函数的顺序？#

回答要点：

成员变量的析构顺序：按照声明的逆序析构。
继承关系的析构顺序：先析构派生类的成员和资源，再析构基类。
全局/静态对象：按照创建的逆序析构。

示例说明：

1
class Base {
2
public:
3
    ~Base() { cout << "Base析构\n"; }
4
};
5

6
class Derived : public Base {
7
public:
8
    ~Derived() { cout << "Derived析构\n"; }
9
};
10

11
int main() {
12
    Derived obj;
13
    // 当obj被销毁时，首先调用Derived的析构函数，然后调用Base的析构函数。
14
}

输出：

1
Derived析构
2
Base析构

如何防止对象被复制？#

回答要点：

C++11及以上：使用delete关键字显式删除拷贝构造函数和拷贝赋值运算符。
C++11之前：将拷贝构造函数和拷贝赋值运算符声明为私有且不实现。

示例（C++11及以上）：

1
class NonCopyable {
2
public:
3
    NonCopyable() = default;
4
    NonCopyable(const NonCopyable&) = delete; // 禁止拷贝构造
5
    NonCopyable& operator=(const NonCopyable&) = delete; // 禁止拷贝赋值
6
};

构造函数中抛出异常会发生什么？#

回答要点：

对象未完全构造：如果构造函数中抛出异常，析构函数不会被调用，因为对象尚未完全构造。
资源泄漏风险：如果在构造函数中分配了资源，需使用RAII（资源获取即初始化）类或智能指针来确保资源被正确释放。
异常安全：确保在构造函数抛出异常时，任何已经初始化的成员都会被正确析构。

示例：

1
class MyClass {
2
    std::vector<int> data;
3
public:
4
    MyClass() {
5
        data.reserve(100);
6
        if (/* some condition */) {
7
            throw std::runtime_error("构造函数异常");
8
        }
9
    }
10
};

解释`RAII`及其与构造函数、析构函数的关系#

回答要点：

RAII（资源获取即初始化）：
- 编程范式，通过对象的生命周期管理资源。
- 资源在对象构造时获取，在对象析构时释放。
关系：
- 构造函数负责获取资源。
- 析构函数负责释放资源。
优点：
- 自动管理资源，防止内存泄漏。
- 异常安全，确保资源在异常发生时被释放。

示例：

1
class FileHandler {
2
    FILE* file;
3
public:
4
    FileHandler(const char* filename) {
5
        file = fopen(filename, "r");
6
        if (!file) throw std::runtime_error("打开文件失败");
7
    }
8
    ~FileHandler() {
9
        if (file) fclose(file);
10
    }
11
    // 禁止拷贝和移动
12
    FileHandler(const FileHandler&) = delete;
13
    FileHandler& operator=(const FileHandler&) = delete;
14
};

解释什么是赋值运算符重载？与拷贝构造函数有何不同？#

回答要点：

赋值运算符重载：通过重载operator=，定义对象之间的赋值行为。
区别与拷贝构造函数：
- 拷贝构造函数用于初始化新对象。
- 赋值运算符用于将一个已存在的对象赋值给另一个已存在的对象。
常规实现：
- 检查自赋值。
- 释放已有资源。
- 复制资源。
- 返回*this。

示例：

1
class MyClass {
2
    int* data;
3
public:
4
    MyClass& operator=(const MyClass& other) { // 赋值运算符重载
5
        if (this == &other) return *this; // 自赋值检查
6
        delete data; // 释放已有资源
7
        data = new int(*other.data); // 复制资源
8
        return *this;
9
    }
10
};

解释静态成员变量在构造和析构中的处理#

回答要点：

静态成员变量：
- 属于类本身，而非任何对象实例。
- 在程序开始时初始化，在程序结束时析构。
构造顺序：
- 单例模式中，静态成员在第一次使用时构造。
析构顺序：
- 按逆序构造顺序析构，确保依赖关系被正确处理。

示例：

1
class MyClass {
2
public:
3
    static MyClass instance;
4
    MyClass() { cout << "构造\n"; }
5
    ~MyClass() { cout << "析构\n"; }
6
};
7
//放在cpp中
8
MyClass MyClass::instance; // 静态成员变量定义

输出：

1
构造
2
析构

虚函数原理#

核心机制：虚函数表（vtable）+ 虚表指针（vptr）

C++ 通过虚函数表（Virtual Table）和虚表指针（Virtual Pointer）实现运行时多态。

虚继承与菱形继承问题#

1
#include <iostream>
2
#include <string>
3

4
// 基类 Device
5
class Device {
6
public:
7
    std::string brand;
8

9
    Device(const std::string& brand_) : brand(brand_) {}
10

11
    void showBrand() const {
12
        std::cout << "Brand: " << brand << std::endl;
13
    }
14
};
15

16
// 派生类 Laptop，虚继承 Device
17
class Laptop : virtual public Device {
18
public:
19
    Laptop(const std::string& brand_) : Device(brand_) {}
20
};
21

22
// 派生类 Tablet，虚继承 Device
23
class Tablet : virtual public Device {
24
public:
25
    Tablet(const std::string& brand_) : Device(brand_) {}
26
};
27

28
// 派生类 Convertible
29
class Convertible : public Laptop, public Tablet {
30
public:
31
    Convertible(const std::string& brand_) : Device(brand_), Laptop(brand_), Tablet(brand_) {}
32
};
33

34
int main() {
35
    Convertible c("TechBrand");
36
    c.showBrand();
37
    return 0;
38
}

展开收起

输出：

1
Brand: TechBrand

解析：

在无虚继承的情况下，Convertible 类将拥有两份 Device 的成员变量，这会导致二义性问题。
通过使用虚继承（virtual public），确保 Convertible 类只有一份 Device 的成员。
在 Convertible 的构造函数中，需要明确调用基类 Device 的构造函数，避免二义性。
在 main 函数中，创建一个 Convertible 对象，并调用 showBrand() 函数，正确显示品牌名称。

注意事项：

菱形继承（多重继承导致的重复基类）可以通过虚继承来解决，确保共享同一份基类成员。
虚继承会增加一定的开销，需根据具体需求权衡使用。

协变返回类型#

概念定义

在 C++ 中，协变返回类型（Covariant Return Types）是一个与函数重写（Override）相关的概念。当一个派生类重写基类的虚函数时，协变返回类型允许派生类的函数返回一个从基类函数返回类型派生而来的类型。

1
#include <iostream>
2

3
// 基类
4
class Base {
5
public:
6
    virtual Base* clone() const {
7
        std::cout << "Base cloned." << std::endl;
8
        return new Base(*this);
9
    }
10

11
    virtual ~Base() {}
12
};
13

14
// 派生类
15
class Derived : public Base {
16
public:
17
    Derived* clone() const override { // 协变返回类型
18
        std::cout << "Derived cloned." << std::endl;
19
        return new Derived(*this);
20
    }
21
};
22

23
int main() {
24
    Base* b = new Base();
25
    Base* d = new Derived();
26

27
    Base* bClone = b->clone(); // 输出: Base cloned.
28
    Base* dClone = d->clone(); // 输出: Derived cloned.
29

30
    delete b;
31
    delete d;
32
    delete bClone;
33
    delete dClone;
34

35
    return 0;
36
}

展开收起

输出：

1
Base cloned.
2
Derived cloned.

解析：

基类 Base 定义了一个虚函数 clone()，返回 Base* 类型的指针。
派生类 Derived 重写了 clone() 函数，返回类型为 Derived*，这是一种协变返回类型。
在

1
main

函数中，通过基类指针调用

1
clone()

函数：

1
- 对于 `Base` 对象，调用 `Base::clone()`。
2
- 对于 `Derived` 对象，由于虚函数机制，调用 `Derived::clone()`。

协变返回类型允许派生类的重写函数返回更具体的类型，增强类型安全性和代码可读性。

注意事项：

协变返回类型必须满足派生类返回类型是基类返回类型的派生类。
编译器会检查协变返回类型的正确性，确保类型安全。

几种标准对话框

Wed, 20 May 2026 00:00:00 GMT

颜色对话框#

颜色对话框用来选择颜色，创建后会显示各种颜色和透明度信息

1
void MainWindow::on_pushButton_clicked()
2
{
3
//    QColorDialog colorDlg(Qt::blue, this);
4
//    colorDlg.setOption(QColorDialog::ShowAlphaChannel);
5
//    colorDlg.exec();
6
//    QColor color = colorDlg.currentColor();
7
//    qDebug() << "color is " << color;
8

9
   QColor color = QColorDialog::getColor(Qt::blue, this,tr("选择颜色"), QColorDialog::ShowAlphaChannel );
10
    qDebug() << "color is " << color;
11
}

注释中也是创建颜色对话框的一种方式，两种方式都可以。

文本对话框#

创建一个选择文件的对话框，选择后，可以根据返回值打印选择的文件的路径信息

1
void MainWindow::on_pushButton_2_clicked()
2
{
3
    QString path = QDir::currentPath();
4
    QString title = tr("文件对话框");
5
    QString filter = tr("文本文件(*.txt);;图片文件(*.jpg *.gif *.png);;所有文件(*.*)");
6
    QString aFileName=QFileDialog::getOpenFileName(this,title,path,filter);
7

8
    qDebug() << aFileName << endl;
9
}

输入对话框#

输入对话框分几种，包括文本输入对话框，整数输入对话框，浮点数输入对话框，条目输入对话框。
先看看文本输入对话框

1
void MainWindow::on_pushButton_3_clicked()
2
{
3
    bool ok = false;
4
    auto text = QInputDialog::getText(this, tr("文字输入对话框"), tr("请输入用户的姓名"), QLineEdit::Normal, tr("admin"), &ok);
5
    if(ok){
6
        qDebug() << text << endl;
7
    }
8
}

整形输入对话框

1
void MainWindow::on_pushButton_4_clicked()
2
{
3
     bool ok = false;
4
    auto intdata = QInputDialog::getInt(this,tr("数字输入对话框"),tr("请输入数字"),200,-200,400,10,&ok);
5
    if(ok){
6
        qDebug() << intdata << endl;
7
    }
8
}

浮点输入对话框

1
void MainWindow::on_pushButton_5_clicked()
2
{
3
    bool ok = false;
4
    auto floatdata = QInputDialog::getDouble(this,tr("浮点数输入对话框"),tr("输入浮点数"),0.1,-1,1,2,&ok);
5
    if(ok){
6
        qDebug() << floatdata << endl;
7
    }
8
}

条目输入对话框

1
void MainWindow::on_pushButton_6_clicked()
2
{
3
    QStringList items;
4
    items << tr("条目1") << tr("条目2");
5
    bool ok = false;
6
    auto itemData = QInputDialog::getItem(this,tr("条目输入对话框"),tr("输入或选择条目"),items,0,true, &ok);
7
    if(ok){
8
        qDebug() << "item is " << itemData << endl;
9
    }
10
}

提示对话框

1
void MainWindow::on_pushButton_7_clicked()
2
{
3
    auto ret = QMessageBox::question(this,tr("提问对话框"),tr("你是单身吗"),QMessageBox::Yes, QMessageBox::No);
4
    if(ret == QMessageBox::Yes || ret == QMessageBox::No){
5
        qDebug() << "ret is " << ret << endl;
6
    }
7

8
    auto ret2 = QMessageBox::information(this,tr("通知对话框"),tr("你好单身狗"),QMessageBox::Ok);
9
    if(ret2 == QMessageBox::Ok){
10
        qDebug() << "ret2 is " << ret2 << endl;
11
    }
12

13
    auto ret3 = QMessageBox::warning(this,tr("警告对话框"),tr("你最好找个地方发泄一下"),QMessageBox::Ok);
14
    if(ret3 == QMessageBox::Ok){
15
        qDebug() << "ret3 is " << ret3 << endl;
16
    }
17

18
    auto ret4 = QMessageBox::critical(this,tr("关键提示对话框"), tr("我梦寐以求是真爱和自由"),QMessageBox::Ok);
19
    if(ret4 == QMessageBox::Ok){
20
        qDebug() << "ret4 is " << ret4 << endl;
21
    }
22
}

展开收起

进度对话框#

当我们复制或进行文件传输时，会显示一个进度条的对话框，我们可以使用QProcessDialog来操作。

1
void MainWindow::on_pushButton_8_clicked()
2
{
3
    // 进度提示框一闪而逝，不是逻辑问题，是5000量级太小了
4
    QProgressDialog progressDialog(tr("正在复制"),tr("取消复制"),0,5000,this);
5
    progressDialog.setWindowTitle(tr("文件复制进度对话框"));
6
    progressDialog.setWindowModality(Qt::ApplicationModal);
7
    progressDialog.show();
8

9
    for(int i = 0; i < 5000; i++){
10
        progressDialog.setValue(i);
11
        QApplication::processEvents();
12
        if(progressDialog.wasCanceled()){
13
            break;
14
        }
15
    }
16
    progressDialog.setValue(5000);
17
}

展开收起

因为循环很快完成，所以进度条一闪而逝，那么我们可以通过定时器的方式定时更新进度，这样就可以更清楚的看到进度条对话框更新情况了

1
void MainWindow::on_pushButton_8_clicked()
2
{
3
    //改用定时器
4
    _progressDialog = new QProgressDialog(tr("正在复制"),tr("取消复制"),0,5000,this);
5
    _progressDialog->setWindowTitle(tr("文件复制进度对话框"));
6
    _progressDialog->setWindowModality(Qt::ApplicationModal);
7
    _timer = new QTimer(this);
8
    connect(_timer, &QTimer::timeout, this, &MainWindow::on_updateProgressDialog);
9
    connect(_progressDialog, &QProgressDialog::canceled, this, &MainWindow::on_cancelProgressDialog);
10
    _timer->start(2);
11
    qDebug("复制结束");
12
}

上面代码连接了定时器的timeout信号和主窗口的on_updateProgressDialog函数, 该函数的主要作用就是定时更新进度条，逻辑如下

1
void MainWindow::on_updateProgressDialog()
2
{
3
    _count++;
4
    if(_count > 5000){
5
        _timer->stop();
6
        delete  _timer;
7
        _timer = nullptr;
8
        delete _progressDialog;
9
        _progressDialog = nullptr;
10
        _count = 0;
11
        return;
12
    }
13

14
    _progressDialog->setValue(_count);
15
}

展开收起

另外我们需要在进度条满了的时候发消息通知主窗口关闭

1
void MainWindow::on_cancelProgressDialog(){
2
    _timer->stop();
3
    delete  _timer;
4
    _timer = nullptr;
5
    delete _progressDialog;
6
    _progressDialog = nullptr;
7
    _count = 0;
8
    return;
9
}yi

这样进度条满了之后我们就可以回收定时器资源了。

向导对话框#

当我们想引导用户操作时可以采用向导对话框，比如安装软件时就会根据向导对话框一步一步操作，我们也实现一个向导对话框

1
void MainWindow::on_pushButton_10_clicked()
2
{
3
    QWizard wizard(this);
4
    wizard.setWindowTitle(tr("全城热恋"));
5
    QWizardPage* page1 = new QWizardPage();
6
    page1->setTitle(tr("婚恋介绍引导程序"));
7
    auto label1 = new QLabel();
8
    label1->setText(tr("该程序帮助您找到人生伴侣"));
9
    QVBoxLayout *layout = new QVBoxLayout();
10
    layout->addWidget(label1);
11
    page1->setLayout(layout);
12
    wizard.addPage(page1);
13
    QWizardPage* page2 = new QWizardPage();
14
    page2->setTitle("选择心动类型");
15

16
    QButtonGroup *group = new QButtonGroup(page2);
17
    QRadioButton * btn1 = new QRadioButton();
18
    btn1->setText("白富美");
19
    group->addButton(btn1);
20
    QRadioButton * btn2 = new QRadioButton();
21
    btn2->setText("萝莉");
22
    group->addButton(btn2);
23
    QRadioButton * btn3 = new QRadioButton();
24
    btn3->setText("御姐");
25
    group->addButton(btn3);
26
    QRadioButton * btn4 = new QRadioButton();
27
    btn4->setText("小家碧玉");
28
    group->addButton(btn4);
29
    QRadioButton * btn5 = new QRadioButton();
30
    btn5->setText("女汉子");
31
    group->addButton(btn5);
32

33
    QRadioButton * btn6 = new QRadioButton();
34
    btn6->setText("成年人不做选择，全选!");
35
    group->addButton(btn6);
36
    QVBoxLayout *vboxLayout2 = new QVBoxLayout();
37
    for(int i = 0; i < group->buttons().size(); i++){
38
        vboxLayout2->addWidget(group->buttons()[i]);
39
    }
40

41
    page2->setLayout(vboxLayout2);
42
    wizard.addPage(page2);
43

44
    QWizardPage* page3 = new QWizardPage();
45
    page3->setTitle(tr("你的缘分即将到来"));
46
    auto label3 = new QLabel();
47
    label3->setText(tr("感谢您的参与，接下来的一个月会遇到对的人"));
48
    QVBoxLayout *layout3 = new QVBoxLayout();
49
    layout3->addWidget(label3);
50
    page3->setLayout(layout3);
51
    wizard.addPage(page3);
52
    wizard.show();
53
    wizard.exec();
54
}

展开收起

继承和多态

Tue, 19 May 2026 00:00:00 GMT

1. 类继承（Class Inheritance）#

1.1 概述#

类继承 是面向对象编程（OOP）中的一个核心概念，允许一个类（派生类）从另一个类（基类）继承属性和行为。通过继承，派生类可以重用基类的代码，并根据需要添加新的成员或重写现有成员。

1.2 语法#

1
class Base {
2
public:
3
    void baseFunction();
4
protected:
5
    int protectedMember;
6
private:
7
    int privateMember;
8
};
9

10
class Derived : public Base { // 公有继承
11
public:
12
    void derivedFunction();
13
};

1.3 代码示例#

1
#include <iostream>
2

3
// 基类
4
class Animal {
5
public:
6
    void eat() const {
7
        std::cout << "Animal eats." << std::endl;
8
    }
9

10
protected:
11
    int age;
12
};
13

14
// 派生类
15
class Dog : public Animal {
16
public:
17
    void bark() const {
18
        std::cout << "Dog barks." << std::endl;
19
    }
20

21
    void setAge(int a) {
22
        age = a; // 访问受保护成员
23
    }
24

25
    int getAge() const {
26
        return age;
27
    }
28
};
29

30
int main() {
31
    Dog myDog;
32
    myDog.eat();    // 继承自Animal
33
    myDog.bark();   // Dog特有
34

35
    myDog.setAge(5);
36
    std::cout << "Dog's age: " << myDog.getAge() << std::endl;
37

38
    return 0;
39
}

展开收起

1.4 执行结果#

1
Animal eats.
2
Dog barks.
3
Dog's age: 5

2. 虚函数（Virtual Functions）#

2.1 概述#

虚函数 允许派生类重新定义基类中的函数，以实现多态性。在运行时，根据对象的实际类型调用相应的函数版本。

2.2 语法#

1
class Base {
2
public:
3
    virtual void display();
4
};

2.3 代码示例#

1
#include <iostream>
2

3
class Shape {
4
public:
5
    virtual void draw() const { // 虚函数
6
        std::cout << "Drawing a shape." << std::endl;
7
    }
8

9
    virtual ~Shape() {} // 虚析构函数
10
};
11

12
class Circle : public Shape {
13
public:
14
    void draw() const override { // 重写虚函数
15
        std::cout << "Drawing a circle." << std::endl;
16
    }
17
};
18

19
class Square : public Shape {
20
public:
21
    void draw() const override { // 重写虚函数
22
        std::cout << "Drawing a square." << std::endl;
23
    }
24
};
25

26
void render(const Shape& shape) {
27
    shape.draw(); // 动态绑定，根据实际对象类型调用对应的draw()
28
}
29

30
int main() {
31
    Circle c;
32
    Square s;
33
    Shape genericShape;
34

35
    render(c);           // 输出: Drawing a circle.
36
    render(s);           // 输出: Drawing a square.
37
    render(genericShape); // 输出: Drawing a shape.
38

39
    return 0;
40
}

展开收起

2.4 执行结果#

1
Drawing a circle.
2
Drawing a square.
3
Drawing a shape.

3. 纯虚类与抽象基类（Pure Virtual Classes and Abstract Base Classes）#

3.1 概述#

纯虚函数 是在基类中声明但不提供实现的虚函数。包含至少一个纯虚函数的类称为 抽象基类（Abstract Base Class，ABC）。抽象基类不能被实例化，要求派生类必须实现所有纯虚函数才能被实例化。

3.2 语法#

1
class Base {
2
public:
3
    virtual void pureVirtualFunction() = 0; // 纯虚函数
4
    virtual void printm() = 0;
5
};

3.3 代码示例#

1
#include <iostream>
2

3
// 抽象基类
4
class Vehicle {
5
public:
6
    virtual void startEngine() = 0; // 纯虚函数
7

8
    virtual ~Vehicle() {} // 虚析构函数
9
};
10

11
class Car : public Vehicle {
12
public:
13
    void startEngine() override {
14
        std::cout << "Car engine started." << std::endl;
15
    }
16
};
17

18
class Motorcycle : public Vehicle {
19
public:
20
    void startEngine() override {
21
        std::cout << "Motorcycle engine started." << std::endl;
22
    }
23
};
24

25
int main() {
26
    // Vehicle v; // 错误: 不能实例化抽象类
27

28
    Car car;
29
    Motorcycle bike;
30

31
    car.startEngine();     // 输出: Car engine started.
32
    bike.startEngine();    // 输出: Motorcycle engine started.
33

34
    Vehicle* v1 = &car;
35
    Vehicle* v2 = &bike;
36

37
    v1->startEngine(); // 动态绑定，输出: Car engine started.
38
    v2->startEngine(); // 动态绑定，输出: Motorcycle engine started.
39

40
    return 0;
41
}

展开收起

3.4 执行结果#

1
Car engine started.
2
Motorcycle engine started.
3
Car engine started.
4
Motorcycle engine started.

4. 继承后的访问控制（Access Control in Inheritance）#

4.1 概述#

继承时的 访问控制 决定了基类成员在派生类中的可访问性。继承方式主要有三种：public、protected 和 private。它们影响继承成员的访问级别。

4.2 语法与影响#

公有继承（public inheritance）：
- 基类的 public 成员在派生类中保持 public。
- 基类的 protected 成员在派生类中保持 protected。
- 基类的 private 成员在派生类中不可访问。
保护继承（protected inheritance）：
- 基类的 public 和 protected 成员在派生类中都变为 protected。
私有继承（private inheritance）：
- 基类的 public 和 protected 成员在派生类中都变为 private。

4.3 代码示例#

1
#include <iostream>
2

3
class Base {
4
public:
5
    int publicMember;
6
protected:
7
    int protectedMember;
8
private:
9
    int privateMember;
10
};
11

12
class PublicDerived : public Base {
13
public:
14
    void accessMembers() {
15
        publicMember = 1;      // 可访问
16
        protectedMember = 2;   // 可访问
17
        // privateMember = 3;  // 错误：privateMember 在派生类中不可访问
18
    }
19
};
20

21
class ProtectedDerived : protected Base {
22
public:
23
    void accessMembers() {
24
        publicMember = 1;      // 转为 protected
25
        protectedMember = 2;   // 转为 protected
26
        // privateMember = 3;  // 错误
27
    }
28
};
29

30
class PrivateDerived : private Base {
31
public:
32
    void accessMembers() {
33
        publicMember = 1;      // 转为 private
34
        protectedMember = 2;   // 转为 private
35
        // privateMember = 3;  // 错误
36
    }
37
};
38

39
int main() {
40
    PublicDerived pubDer;
41
    pubDer.publicMember = 10; // 可访问
42

43
    // ProtectedDerived protDer;
44
    // protDer.publicMember = 10; // 错误：publicMember 在 ProtectedDerived 中为 protected
45

46
    // PrivateDerived privDer;
47
    // privDer.publicMember = 10; // 错误：publicMember 在 PrivateDerived 中为 private
48

49
    return 0;
50
}

展开收起

5. 继承中类的作用域（Scope of Classes in Inheritance）#

5.1 概述#

在继承关系中，类的作用域决定了成员名称的可见性和访问方式。派生类可以访问基类的成员，根据访问控制的不同，还可能需要使用 作用域解析符 来访问隐藏的成员。

5.2 代码示例#

1
#include <iostream>
2

3
class Base {
4
public:
5
    void display() const {
6
        std::cout << "Display from Base" << std::endl;
7
    }
8

9
    virtual void show() const {
10
        std::cout << "Show from Base" << std::endl;
11
    }
12
};
13

14
class Derived : public Base {
15
public:
16
    void display() const { // 隐藏基类的 display
17
        std::cout << "Display from Derived" << std::endl;
18
    }
19

20
    void callBaseDisplay() const {
21
        Base::display(); // 使用作用域解析符调用基类的 display
22
    }
23

24
    void show() const { // 重写 show， show 是虚函数可实现多态
25
        std::cout << "Show from Derived" << std::endl;
26
    }
27
};
28

29
int main() {
30
    Derived d;
31
    d.display();          // 调用 Derived::display
32
    d.callBaseDisplay();  // 调用 Base::display
33
    d.show();             // 调用 Derived::show
34

35
    Base* bPtr = &d;
36
    bPtr->display(); // 调用 Base::display，因为 display 不是虚函数
37
    bPtr->show();    // show 是虚函数，调用 Derived::show；否则调用 Base::show
38

39
    return 0;
40
}

展开收起

5.3 执行结果#

1
Display from Derived
2
Display from Base
3
Show from Derived
4
Display from Base
5
Show from Base // show 是虚函数则输出: Show from Derived

6. 构造函数与拷贝控制（Constructors and Copy Control in Inheritance）#

6.1 概述#

在继承体系中，类的构造函数和拷贝控制函数（拷贝构造函数、拷贝赋值运算符、析构函数）的调用顺序和行为需要注意。基类的构造函数在派生类之前调用，析构函数则在派生类之后调用。

6.2 构造函数的调用顺序#

基类的 默认构造函数 首先被调用，除非派生类在初始化列表中显式调用其他基类构造函数。
派生类的成员按照声明顺序被构造。
派生类的构造函数体被执行。

6.3 代码示例#

1
#include <iostream>
2
#include <string>
3

4
class Base {
5
public:
6
    Base() {
7
        std::cout << "Base default constructor" << std::endl;
8
    }
9

10
    Base(const std::string& name) : name_(name) {
11
        std::cout << "Base parameterized constructor: " << name_ << std::endl;
12
    }
13

14
    Base(const Base& other) : name_(other.name_) {
15
        std::cout << "Base copy constructor" << std::endl;
16
    }
17

18
    Base& operator=(const Base& other) {
19
        std::cout << "Base copy assignment" << std::endl;
20
        if (this != &other) {
21
            name_ = other.name_;
22
        }
23
        return *this;
24
    }
25

26
    virtual ~Base() {
27
        std::cout << "Base destructor" << std::endl;
28
    }
29

30
protected:
31
    std::string name_;
32
};
33

34
class Derived : public Base {
35
public:
36
    Derived() : Base("Default Derived") {
37
        std::cout << "Derived default constructor" << std::endl;
38
    }
39

40
    Derived(const std::string& name, int value) : Base(name), value_(value) {
41
        std::cout << "Derived parameterized constructor: " << value_ << std::endl;
42
    }
43

44
    Derived(const Derived& other) : Base(other), value_(other.value_) {
45
        std::cout << "Derived copy constructor" << std::endl;
46
    }
47

48
    Derived& operator=(const Derived& other) {
49
        std::cout << "Derived copy assignment" << std::endl;
50
        if (this != &other) {
51
            Base::operator=(other);
52
            value_ = other.value_;
53
        }
54
        return *this;
55
    }
56

57
    ~Derived() override {
58
        std::cout << "Derived destructor" << std::endl;
59
    }
60

61
private:
62
    int value_;
63
};
64

65
int main() {
66
    std::cout << "Creating d1:" << std::endl;
67
    Derived d1;
68

69
    std::cout << "\nCreating d2:" << std::endl;
70
    Derived d2("Custom Derived", 42);
71

72
    std::cout << "\nCopy constructing d3 from d2:" << std::endl;
73
    Derived d3 = d2;
74

75
    std::cout << "\nAssigning d1 = d2:" << std::endl;
76
    d1 = d2;
77

78
    std::cout << "\nExiting main..." << std::endl;
79
    return 0;
80
}

展开收起

6.4 执行结果#

1
Creating d1:
2
Base parameterized constructor: Default Derived
3
Derived default constructor
4

5
Creating d2:
6
Base parameterized constructor: Custom Derived
7
Derived parameterized constructor: 42
8

9
Copy constructing d3 from d2:
10
Base copy constructor
11
Derived copy constructor
12

13
Assigning d1 = d2:
14
Derived copy assignment
15
Base copy assignment
16

17
Exiting main...
18
Derived destructor
19
Base destructor
20
Derived destructor
21
Base destructor
22
Derived destructor
23
Base destructor

展开收起

7. 容器与继承（Containers and Inheritance）#

7.1 概述#

C++ 容器（如 std::vector、std::list** 等）** 通常存储对象的副本，而非指向对象的指针。因此，当与继承结合使用时，可能导致 切片（Object Slicing） 问题，即仅存储基类部分，丢失派生类特有的信息。为了实现多态性，推荐使用指针或智能指针存储对象。

7.2 切片问题示例#

1
#include <iostream>
2
#include <vector>
3

4
class Base {
5
public:
6
    virtual void show() const { std::cout << "Base show" << std::endl; }
7
    virtual ~Base() {}
8
};
9

10
class Derived : public Base {
11
public:
12
    void show() const override { std::cout << "Derived show" << std::endl; }
13
};
14

15
int main() {
16
    std::vector<Base> vec;
17
    Derived d;
18
    vec.push_back(d); // 切片发生，派生类特有部分被丢弃
19

20
    vec[0].show(); // 输出: Base show
21

22
    return 0;
23
}

展开收起

7.3 使用指针避免切片#

1
#include <iostream>
2
#include <vector>
3
#include <memory>
4

5
class Base {
6
public:
7
    virtual void show() const { std::cout << "Base show" << std::endl; }
8
    virtual ~Base() {}
9
};
10

11
class Derived : public Base {
12
public:
13
    void show() const override { std::cout << "Derived show" << std::endl; }
14
};
15

16
int main() {
17
    std::vector<std::unique_ptr<Base>> vec;
18
    vec.emplace_back(std::make_unique<Derived>());
19

20
    vec[0]->show(); // 输出: Derived show
21

22
    return 0;
23
}

展开收起

7.5 智能指针选择#

std::unique_ptr：
- 独占所有权，不可复制，只能移动。
- 适用于明确的单一所有权场景。
std::shared_ptr：
- 共享所有权，可以被多个指针共享和引用计数。
- 适用于需要多个所有者的场景。

模态对话框消息传递

Tue, 19 May 2026 00:00:00 GMT

模态对话框接受和拒绝消息#

我们创建一个模态对话框，调用exec函数后可以根据其返回值进行不同的处理，exec的返回值有两种，Qt的官方文档记录的为

1
QDialog::Accepted
2
QDialog::Rejected

Accepted 表示接受消息， Rejected表示拒绝消息。
还是按照之前的操作，选择新建QT Application项目，然后创建类名为MainWindow, 基类选择QDialog, 点击创建生成Qt项目。然后我们添加设计师界面类，类名MyDialog, 基类选择QDialog。然后在这个mydialog.ui中添加两个按钮，一个是进入主界面，一个是退出程序。

在设计师界面点击Edit Signal/Slots 信号槽的按钮，进入信号槽编辑界面, 鼠标按住退出程序按钮不松开拖动，将另一端连接到MyDialog对话框，QPushbutton这边信号选择clicked()， MyDialog信号选择reject，这样就将两个信号连接起来了，我们点击退出程序按钮，会触发MyDialog发送reject信号，因为MyDialog调用exec后等待信号返回，此时收到reject信号，exec就会返回Rjected值。
同样道理，MyDialog发送accetp()信号后, exec返回值为Accepted。

我们点击Edit Widget 按钮，然后右键点击键入主界面按钮，点击进入槽，在Qt 为我们生成的槽函数里添加accetp()信号发送逻辑

1
void MyDialog::on_pushButton_clicked()
2
{
3
    accept();
4
}

我们在main函数里调用对话框，然后根据返回值为Accepted，调用主窗口显示，否则直接退出

1
int main(int argc, char *argv[])
2
{
3
    QApplication a(argc, argv);
4
    MainWindow w;
5
    MyDialog dialog;
6
    if(dialog.exec() == QDialog::Accepted){
7
        w.show();
8
         return a.exec();
9
    }else{
10
        return 0;
11
    }
12
}

运行后，我们点击进入主界面按钮，界面跳转至主界面，点击退出按钮程序退出。

主界面和登录界面切换#

现在我们要实现主界面和登录界面的互相切换，我们刚才创建的对话框界面MyDialog界面是登录界面，主界面是MainWindow类。
我们在mainwindow.ui添加两个按钮，返回登录按钮和退出程序按钮, 再添加一个label表示这是主界面.
然后点击Edit Signal/Slot 进入信号编辑界面，点击退出程序按钮不松开拖动到尾部连接MainWindow的主界面上，选择退出程序的clicked()信号，MainWindow选择reject信号,将两个信号连接起来。

然后右击登录按钮转到槽，在槽函数里添加这个逻辑

1
void MainWindow::on_pushButton_clicked()
2
{
3
    close();
4
    MyDialog mydialog;
5
    if(mydialog.exec() == QDialog::Accepted ){
6
        this->show();
7
    }else{
8
        return;
9
    }
10
}

点击返回登陆按钮就会close主窗口，但是并不是真的关闭，只是将主窗口隐藏，Qt回收机制是所有窗口都关闭后才回收。
再次运行程序，点击进入主界面按钮就可以进入主界面，点击返回登录按钮就可以返回登录界面，可以实现两个界面的切换了。

类基础用法

Mon, 18 May 2026 00:00:00 GMT

1. 类与对象简介#

1.1 什么是类和对象#

**类（Class）**是C++中创建用户自定义类型的一种方式，它将数据（成员变量）和操作数据的函数（成员函数）封装在一起。
**对象（Object）**是类的实例化，拥有类定义的所有属性和行为。
类更像是汽车图纸，对象更像是造出来的汽车。

1.2 类的作用#

封装（Encapsulation）：将数据和操作数据的代码绑定在一起，保护数据不被外界直接访问。
抽象（Abstraction）：通过类定义抽象出具有共同特性的对象，提高代码的可重用性和可维护性。
继承（Inheritance）和多态（Polymorphism）：实现代码的复用与动态绑定。

2. 类的定义#

2.1 基本语法#

1
class ClassName {
2
public:
3
    // 公有成员
4
private:
5
    // 私有成员
6
protected:
7
    // 受保护成员
8
};

2.2 示例#

创建一个表示学生的类：

1
#include <string>
2

3
class Student {
4
public:
5
    // 公有构造函数
6
    Student(const std::string& name, int age);
7

8
    // 公有成员函数
9
    void setName(const std::string& name);
10
    std::string getName() const;
11

12
    void setAge(int age);
13
    int getAge() const;
14

15
private:
16
    // 私有成员变量
17
    std::string name_;
18
    int age_;
19
};

展开收起

3. 成员变量与成员函数#

3.1 成员变量#

成员变量（Member Variables）：用于存储对象的状态信息。
命名约定：常用下划线结尾（例如 name_）表示成员变量，避免与局部变量混淆。

3.2 成员函数#

成员函数（Member Functions）：定义对象的行为，可以访问和修改成员变量。
常成员函数（Const Member Functions）：保证函数不会修改对象的状态。

3.3 示例实现#

Student.cpp展开收起

1
#include "Student.h"
2

3
Student::Student(const std::string& name, int age)
4
    : name_(name), age_(age) {}
5

6
void Student::setName(const std::string& name) {
7
    name_ = name;
8
}
9

10
std::string Student::getName() const {
11
    return name_;
12
}
13

14
void Student::setAge(int age) {
15
    if (age > 0)
16
        age_ = age;
17
}
18

19
int Student::getAge() const {
20
    return age_;
21
}

展开收起

4. 访问控制#

4.1 访问修饰符#

public：公有成员，可以被所有代码访问。
private：私有成员，仅能被类的成员函数和友元访问。
protected：受保护成员，仅能被类的成员函数、友元和派生类访问。

4.2 例子#

1
class Sample {
2
public:
3
    void publicFunction();
4

5
private:
6
    int privateVar_;
7
    void privateFunction();
8

9
protected:
10
    int protectedVar_;
11
};

5. 构造函数与析构函数#

5.1 构造函数#

默认构造函数：没有参数的构造函数。
参数化构造函数：接受参数以初始化对象。
拷贝构造函数：用一个对象初始化另一个对象。
移动构造函数（C++11）：从临时对象“移动”资源。

5.2 析构函数#

析构函数（Destructor）：在对象生命周期结束时调用，用于释放资源。

5.3 示例#

1
#include <iostream>
2

3
class Example {
4
public:
5
    // 默认构造函数
6
    Example() : data_(0) {
7
        std::cout << "Default constructor called.\n";
8
    }
9

10
    // 参数化构造函数
11
    Example(int data) : data_(data) {
12
        std::cout << "Parameterized constructor called with data = " << data_ << ".\n";
13
    }
14

15
    // 拷贝构造函数
16
    Example(const Example& other) : data_(other.data_) {
17
        std::cout << "Copy constructor called.\n";
18
    }
19

20
    // 移动构造函数
21
    Example(Example&& other) noexcept : data_(other.data_) {
22
        other.data_ = 0;
23
        std::cout << "Move constructor called.\n";
24
    }
25

26
    // 析构函数
27
    ~Example() {
28
        std::cout << "Destructor called for data = " << data_ << ".\n";
29
    }
30

31
private:
32
    int data_;
33
};

展开收起

5.4 使用示例#

1
int main() {
2
    Example ex1;               // 调用默认构造函数
3
    Example ex2(42);           // 调用参数化构造函数
4
    Example ex3 = ex2;         // 调用拷贝构造函数
5
    Example ex4 = std::move(ex2); // 调用移动构造函数
6
    return 0;
7
}

输出示例：

1
Default constructor called.
2
Parameterized constructor called with data = 42.
3
Copy constructor called.
4
Move constructor called.
5
Destructor called for data = 0.
6
Destructor called for data = 42.
7
Destructor called for data = 42.

6. 拷贝控制#

拷贝构造函数与拷贝赋值运算符

6.1 拷贝构造函数#

定义：用于创建一个新对象，并复制现有对象的成员。
语法：ClassName(const ClassName& other);

6.2 拷贝赋值运算符#

定义：用于将一个已有对象的值赋给另一个已有对象。
语法：ClassName& operator=(const ClassName& other);

6.3 示例#

1
#include <iostream>
2
#include <cstring>
3

4
class MyString {
5
public:
6
    // 构造函数
7
    MyString(const char* str = nullptr) {
8
        if (str) {
9
            size_ = std::strlen(str);
10
            data_ = new char[size_ + 1];
11
            std::strcpy(data_, str);
12
        } else {
13
            size_ = 0;
14
            data_ = new char[1];
15
            data_[0] = '\0';
16
        }
17
        std::cout << "Constructor called.\n";
18
    }
19

20
    // 拷贝构造函数
21
    MyString(const MyString& other) : size_(other.size_) {
22
        data_ = new char[size_ + 1];
23
        std::strcpy(data_, other.data_);
24
        std::cout << "Copy constructor called.\n";
25
    }
26

27
    // 拷贝赋值运算符
28
    MyString& operator=(const MyString& other) {
29
        std::cout << "Copy assignment operator called.\n";
30
        if (this == &other)
31
            return *this; // 自赋值检查
32

33
        delete[] data_; // 释放现有资源
34

35
        size_ = other.size_;
36
        data_ = new char[size_ + 1];
37
        std::strcpy(data_, other.data_);
38
        return *this;
39
    }
40

41
    // 析构函数
42
    ~MyString() {
43
        delete[] data_;
44
        std::cout << "Destructor called.\n";
45
    }
46

47
    void print() const {
48
        std::cout << data_ << "\n";
49
    }
50

51
private:
52
    char* data_;
53
    std::size_t size_;
54
};

展开收起

6.4 使用示例#

1
int main() {
2
    MyString s1("Hello");
3
    MyString s2 = s1;        // 调用拷贝构造函数
4
    MyString s3;
5
    s3 = s1;                  // 调用拷贝赋值运算符
6

7
    s1.print();
8
    s2.print();
9
    s3.print();
10
    return 0;
11
}

输出示例：

1
Constructor called.
2
Copy constructor called.
3
Constructor called.
4
Copy assignment operator called.
5
Hello
6
Hello
7
Hello
8
Destructor called.
9
Destructor called.
10
Destructor called.

7. 移动语义#

7.1 什么是移动语义#

移动语义（Move Semantics）：允许资源的所有权从一个对象转移到另一个对象，避免不必要的拷贝，提高性能。

7.2 移动构造函数与移动赋值运算符#

移动构造函数：ClassName(ClassName&& other) noexcept;
移动赋值运算符：ClassName& operator=(ClassName&& other) noexcept;

7.3 示例#

1
#include <iostream>
2
#include <utility>
3

4
class MoveExample {
5
public:
6
    // 构造函数
7
    MoveExample(int size) : size_(size), data_(new int[size]) {
8
        std::cout << "Constructor called.\n";
9
    }
10

11
    // 拷贝构造函数
12
    MoveExample(const MoveExample& other) : size_(other.size_), data_(new int[other.size_]) {
13
        std::copy(other.data_, other.data_ + size_, data_);
14
        std::cout << "Copy constructor called.\n";
15
    }
16

17
    // 移动构造函数
18
    MoveExample(MoveExample&& other) noexcept : size_(other.size_), data_(other.data_) {
19
        other.size_ = 0;
20
        other.data_ = nullptr;
21
        std::cout << "Move constructor called.\n";
22
    }
23

24
    // 拷贝赋值运算符
25
    MoveExample& operator=(const MoveExample& other) {
26
        std::cout << "Copy assignment operator called.\n";
27
        if (this == &other)
28
            return *this;
29

30
        delete[] data_;
31
        size_ = other.size_;
32
        data_ = new int[size_];
33
        std::copy(other.data_, other.data_ + size_, data_);
34
        return *this;
35
    }
36

37
    // 移动赋值运算符
38
    MoveExample& operator=(MoveExample&& other) noexcept {
39
        std::cout << "Move assignment operator called.\n";
40
        if (this == &other)
41
            return *this;
42

43
        delete[] data_;
44
        size_ = other.size_;
45
        data_ = other.data_;
46

47
        other.size_ = 0;
48
        other.data_ = nullptr;
49
        return *this;
50
    }
51

52
    // 析构函数
53
    ~MoveExample() {
54
        delete[] data_;
55
        std::cout << "Destructor called.\n";
56
    }
57

58
private:
59
    int size_;
60
    int* data_;
61
};

展开收起

7.4 使用示例#

1
int main() {
2
    MoveExample ex1(100);                 // Constructor
3
    MoveExample ex2 = ex1;                // Copy Constructor
4
    MoveExample ex3 = MoveExample(200);   // Move Constructor
5

6
    MoveExample ex4(300);
7
    ex4 = ex1;                             // Copy Assignment
8
    ex4 = MoveExample(400);                // Move Assignment
9

10
    return 0;
11
}

输出示例：

1
Constructor called.
2
Copy constructor called.
3
Constructor called.
4
Move constructor called.
5
Destructor called.
6
Constructor called.
7
Copy assignment operator called.
8
Move constructor called.
9
Move assignment operator called.
10
Destructor called.
11
Destructor called.
12
Destructor called.
13
Destructor called.

8. 类的友元#

8.1 什么是友元#

友元（Friend）：可以访问类的私有和保护成员的非成员函数或另一个类。

8.2 类型#

友元函数：单个函数可以被声明为友元。
友元类：整个类可以被声明为友元。

8.3 使用示例#

1
#include <iostream>
2

3
class Box {
4
public:
5
    Box(double length, double width, double height)
6
        : length_(length), width_(width), height_(height) {}
7

8
    // 声明友元函数
9
    friend double calculateVolume(const Box& b);
10

11
private:
12
    double length_;
13
    double width_;
14
    double height_;
15
};
16

17
// 友元函数定义
18
double calculateVolume(const Box& b) {
19
    return b.length_ * b.width_ * b.height_;
20
}

展开收起

8.4 使用友元类#

1
class Rectangle {
2
public:
3
    Rectangle(double width, double height) : width_(width), height_(height) {}
4

5
private:
6
    double width_;
7
    double height_;
8

9
    // 声明友元类
10
    friend class AreaCalculator;
11
};
12

13
class AreaCalculator {
14
public:
15
    double calculateArea(const Rectangle& rect) {
16
        return rect.width_ * rect.height_;
17
    }
18
};

展开收起

9. 运算符重载#

9.1 什么是运算符重载#

运算符重载（Operator Overloading）：允许对自定义类型使用C++运算符，如 +, -, << 等。

9.2 重载运算符的规则#

只能对已有运算符进行重载，不能创建新运算符。
至少有一个操作数必须是用户定义的类型。
不能改变运算符的优先级或结合性。

9.3 示例：重载 `+` 运算符#

1
#include <iostream>
2
#include <string>
3

4
class Point {
5
public:
6
    Point(double x, double y) : x_(x), y_(y) {}
7

8
    // 成员函数重载 +
9
    Point operator+(const Point& other) const {
10
        return Point(x_ + other.x_, y_ + other.y_);
11
    }
12

13
    void print() const {
14
        std::cout << "(" << x_ << ", " << y_ << ")\n";
15
    }
16

17
private:
18
    double x_;
19
    double y_;
20
};
21

22
// 也可以使用友元函数重载 +
23

24
Point operator-(const Point& a, const Point& b) {
25
    return Point(a.x_ - b.x_, a.y_ - b.y_);
26
}
27

28
int main() {
29
    Point p1(1.5, 2.5);
30
    Point p2(3.0, 4.0);
31

32
    Point p3 = p1 + p2;
33
    p3.print(); // 输出： (4.5, 6.5)
34

35
    Point p4 = p2 - p1;
36
    p4.print(); // 输出： (1.5, 1.5)
37

38
    return 0;
39
}

展开收起

9.4 示例：重载 `<<` 运算符（输出流）#

1
#include <iostream>
2
#include <string>
3

4
class Employee {
5
public:
6
    Employee(const std::string& name, double salary)
7
        : name_(name), salary_(salary) {}
8

9
    // 声明友元函数以重载 <<
10
    friend std::ostream& operator<<(std::ostream& os, const Employee& emp);
11

12
private:
13
    std::string name_;
14
    double salary_;
15
};
16

17
// 定义重载的 <<
18
std::ostream& operator<<(std::ostream& os, const Employee& emp) {
19
    os << "Employee Name: " << emp.name_ << ", Salary: $" << emp.salary_;
20
    return os;
21
}
22

23
int main() {
24
    Employee emp("John Doe", 75000);
25
    std::cout << emp << std::endl;
26
    return 0;
27
}

展开收起

输出示例：

1
Employee Name: John Doe, Salary: $75000

Qt 信号和槽

Mon, 18 May 2026 00:00:00 GMT

信号和槽#

需要一个界面通知另一个界面时，可以采用信号和槽机制。通过链接信号和槽，当一个界面发送信号时，链接该信号的槽会被响应，从而达到消息传递的目的。
所以我们先创建一个Qapplication Widgets 应用。Creator会为我们生成mainwindow类和其界面。我们在界面添加一个按钮，按钮的名字叫showChildButton, 按钮显示的文字改为“显示子界面”。
同时为该界面添加一个label，显示的文字修改为“这是主界面”

现在实现点击按钮，在控制台打印一条日志 “show child dialog “
我们先在MainWindow的构造函数中添加信号和槽的链接逻辑

1
connect(ui->showChildButton, SIGNAL(clicked(bool)), this, SLOT(showChildDialog()));

然后我们为MainWindow添加showChildDialog槽函数，槽函数需要用slots声明，我们这里在mainwindow.h里用public slots的方式声明槽函数。

1
public slots:
2
    void showChildDialog();

接下来去mainwindow.cpp中完成该函数的实现，可以在头文件中右键该函数，在弹出菜单里选择Refactor, 再选择在mainwindow.cpp中添加实现。

1
void MainWindow::showChildDialog()
2
{
3
    qDebug() << "show child dialog " << endl;
4
}

运行项目后点击按钮，就可以看到控制台弹出show child dialog日志。

不同的连接方式#

我们上边用来连接信号和槽的方式是qt4提供的方式，用SIGNAL和SLOT将信号和槽转化为字符串。
但是这种方式会存在一定问题，Qt要求槽函数的参数不能超过信号定义的参数，比如我们用到的信号clicked(bool)参数就是bool，我们定义的槽函数showChildDialog()是不带参数的，可以连接成功，如果我们在连接的时候将showChildDialog的参数写为3个，也可以连接成功

1
 //qt4 风格的Slot和Signal 只是宏转换，字符串定义不能检测编译错误
2
 connect(ui->showChildButton, SIGNAL(clicked(bool)), this, SLOT(showChildDialog(1,2,3)));

但是点击会没有反应，说明qt4 这种连接信号和槽的方式不做编译检查，只是将信号和槽函数转译成字符串。
所以我推荐使用qt5以上版本的连接方式

1
 //推荐qt5 风格
2
connect(ui->showChildButton, &QPushButton::clicked, this, &MainWindow::showChildDialog);

这种方式也可以实现信号和槽函数的连接。

实现界面的切换#

我们现在实现这样一个demo，程序启动后弹出主界面，点击主界面的按钮弹出子窗口，隐藏主界面，点击子窗口界面的按钮，隐藏子界面，显示主窗口。
所以我们右击项目弹出菜单选择创建Qt设计师界面类，选择Dialog without Buttons,

名字选择ChildDialog

我们进入子界面的ui设计界面，添加一个label 描述为这是子界面，添加一个PushButton，文字修改为显示主窗口，并且将按钮的名字修改为showMainWindow

Qt会为我们创建一个界面类名字叫ChildDialog，我们可以将其作为MainWindow类的成员

1
class MainWindow : public QMainWindow
2
{
3
    Q_OBJECT
4

5
public:
6
    explicit MainWindow(QWidget *parent = nullptr);
7
    ~MainWindow();
8

9
private:
10
    Ui::MainWindow *ui;
11
public slots:
12
    void showChildDialog();
13
private:
14
    ChildDialog *_child_dialog;
15
};

展开收起

然后重新改写槽函数，使点击按钮后弹出对话框

1
void MainWindow::showChildDialog()
2
{
3
    qDebug() << "show child dialog " << endl;
4
    auto _child_dialog = new ChildDialog(this);
5
    _child_dialog->show();
6
}

再次运行程序点击显示子界面的按钮，就会弹出子界面了。关闭子界面，再次点击主窗口的显示子窗口按钮，子窗口又显示出来。
这么做有一个问题就是可能会重复创建子窗口，但是Qt的对象树机制会保证父窗口回收时才回收子窗口，所以关闭子窗口只是隐藏了。
那么随着点击，久而久之窗口会越来越多。
我们想到的一个避免重复创建的办法就是在MainWindow的构造函数里创建好子界面，在槽函数中只控制子界面的显示即可。
但同时要注意在MainWindow的析构函数里回收子界面类对象。

1
MainWindow::MainWindow(QWidget *parent) :
2
    QMainWindow(parent),
3
    ui(new Ui::MainWindow)
4
{
5
    ui->setupUi(this);
6
    _child_dialog = new ChildDialog(this);
7
    connect(ui->showChildButton, &QPushButton::clicked, this, &MainWindow::showChildDialog);
8
}
9

10
MainWindow::~MainWindow()
11
{
12
    delete ui;
13
    if(_child_dialog){
14
        delete  _child_dialog;
15
        _child_dialog = nullptr;
16
    }
17
}
18

19
void MainWindow::showChildDialog()
20
{
21
    qDebug() << "show child dialog " << endl;
22
    _child_dialog->show();
23
}

展开收起

这样我们频繁点击显示子界面按钮就不会重复创建窗口了。
那接下来实现点击主界面的按钮，显示子界面，并隐藏主窗口。
实现点击子界面的按钮，显示主窗口，并隐藏子界面。
先实现点击子界面按钮显示主窗口，我们可以在ChildDialog类修改下构造函数，使其接受一个QWidget指针，这个指针指向父窗口也就是MainWindow.
我们新增成员_parent用来存储MainWindow。
新增槽函数showMainWindow用来显示主窗口。

1
class ChildDialog : public QDialog
2
{
3
    Q_OBJECT
4
public:
5
    explicit ChildDialog(QWidget *parent = nullptr);
6
    ~ChildDialog();
7

8
private:
9
    Ui::ChildDialog *ui;
10
    QWidget *_parent;
11
public slots:
12
    void showMainWindow();
13

14
};

在ChildDialog的实现文件里连接槽函数，并且实现子界面隐藏，主界面显示

1
ChildDialog::ChildDialog(QWidget *parent) :
2
    QDialog(parent),
3
    ui(new Ui::ChildDialog),_parent(parent)
4
{
5
    ui->setupUi(this);
6
    connect(ui->showMainWindow, &QPushButton::clicked, this, &ChildDialog::showMainWindow);
7
}
8

9
void ChildDialog::showMainWindow()
10
{
11
    qDebug() << "show main window" << endl;
12
    _parent->show();
13
    this->hide();
14
}

修改主界面的槽函数,让主界面隐藏，子界面显示

1
void MainWindow::showChildDialog()
2
{
3
    qDebug() << "show child dialog " << endl;
4
    _child_dialog->show();
5
    this->hide();
6
}

运行程序后，点击按钮就可以实现界面的切换。
这么做有一个不好的地方就是在ChildDialog类里保存了MainWindow的指针，如果我们ChildDialog类里要实现和多个其他界面的交互，就需要保存多个指针，这样代码的耦合性太大了。所以我们引入信号和槽机制，当我们点击子界面按钮时发送一个信号给主界面，这样主界面收到该信号后就显示主界面隐藏子界面。
那我们先为ChildDialog类声明一个信号，用来通知主界面显示

1
class ChildDialog : public QDialog
2
{
3
    Q_OBJECT
4
signals:
5
   void showMainSig();
6
public:
7
    explicit ChildDialog(QWidget *parent = nullptr);
8
    ~ChildDialog();
9

10
private:
11
    Ui::ChildDialog *ui;
12
    QWidget *_parent;
13
public slots:
14
    void showMainWindow();
15
};

展开收起

showMainSig是一个信号，用来通知主界面，所以主界面MainWindow类要连接这个信号，我们先在主界面类中声明这个函数

1
class MainWindow : public QMainWindow
2
{
3
    Q_OBJECT
4

5
public:
6
    explicit MainWindow(QWidget *parent = nullptr);
7
    ~MainWindow();
8

9
private:
10
    Ui::MainWindow *ui;
11
public slots:
12
    void showChildDialog();
13
    void showMainDialog();
14
private:
15
    ChildDialog *_child_dialog;
16
};

展开收起

showMainDialog 是新增的槽函数，用来连接ChildDialog的showMainSig信号。
我们修改ChildDialog的showMainWindow函数

1
void ChildDialog::showMainWindow()
2
{
3
    qDebug() << "show main window" << endl;
4
    this->hide();
5
    //可以再次发送信号通知主窗口显示
6
    emit showMainSig();
7
}

然后在MainWindow连接这个信号

1
MainWindow::MainWindow(QWidget *parent) :
2
    QMainWindow(parent),
3
    ui(new Ui::MainWindow)
4
{
5
    ui->setupUi(this);
6
    _child_dialog = new ChildDialog(this);
7

8
    //推荐qt5 风格
9
    connect(ui->showChildButton, &QPushButton::clicked, this, &MainWindow::showChildDialog);
10

11
    connect(_child_dialog, &ChildDialog::showMainSig, this, &MainWindow::showMainDialog);
12
}
13

14
void MainWindow::showChildDialog()
15
{
16
    qDebug() << "show child dialog " << endl;
17
    _child_dialog->show();
18
    this->hide();
19
}

展开收起

再次运行程序，点击按钮实现了界面的切换。

连接信号#

上面的程序还可以进一步优化，因为Qt提供了信号连接信号的方式，也就是说我们可以把子界面的按钮点击信号和showMainSig信号连接起来。

1
ChildDialog::ChildDialog(QWidget *parent) :
2
    QDialog(parent),
3
    ui(new Ui::ChildDialog),_parent(parent)
4
{
5
    ui->setupUi(this);
6
    connect(ui->showMainWindow, &QPushButton::clicked, this, &ChildDialog::showMainSig);
7
}

将clicked和showMainSig两个信号连接起来，也可以实现消息的传递，让代码更简洁了。

beast网络库实现websocket服务器

Sun, 17 May 2026 00:00:00 GMT

构造websocket#

在开始前我们先准备几个变量

1
#include <boost/beast.hpp>
2
#include <boost/beast/ssl.hpp>
3
#include <boost/asio.hpp>
4
#include <boost/asio/ssl.hpp>
5
namespace net = boost::asio;
6
namespace beast = boost::beast;
7
using namespace boost::beast;
8
using namespace boost::beast::websocket;
9

10
net::io_context ioc;
11
tcp_stream sock(ioc);
12
net::ssl::context ctx(net::ssl::context::tlsv12);

WebSocket连接需要一个有状态对象，由Beast中的一个类模板websocket::stream表示。该接口使用分层流模型。一个websocket stream对象包含另一个流对象，称为“下一层”，它用于执行I/O操作。以下是每个模板参数的描述：

1
namespace boost {
2
namespace beast {
3
namespace websocket {
4

5
template<
6
    class NextLayer,
7
    bool deflateSupported = true>
8
class stream;
9

10
} // websocket
11
} // beast
12
} // boost

这段代码定义了Beast库中WebSocket实现的命名空间。其中，websocket命名空间下包含一个模板类stream，用于表示WebSocket连接。

stream类有两个模板参数：NextLayer和deflateSupported。其中，NextLayer表示WebSocket连接使用的下一层流类型，例如TCP套接字或TLS握手后的数据流；而deflateSupported则是一个bool值，表示是否支持WebSocket协议内置的压缩功能。

这些代码所在的三个命名空间分别是boost、beast和websocket，是为了防止与其他库或用户代码发生名称冲突而创建的。将Beast库放在beast命名空间下是为了与Boost库本身分离，方便管理和维护。
当创建一个WebSocket流对象时，构造函数提供的任何参数都会被传递给下一层对象的构造函数。以下示例代码声明了一个基于TCP/IP套接字和I/O上下文的WebSocket流对象：

1
stream<tcp_stream> ws(ioc);

上述代码创建了一个基于TCP流的WebSocket流对象，使用了指定的I/O上下文，该代码中的stream是Beast库中WebSocket流类模板的别名，其下一层流类型为tcp_stream。

需要注意的是，WebSocket流使用自己特定的超时功能来管理连接。如果使用tcp_stream或basic_stream类模板与WebSocket流一起使用，那么在连接建立后应该禁用TCP或basic流上的超时设置，否则流的行为将是不确定的。

这是因为WebSocket协议本身包含了超时机制，当流上发生超时时，WebSocket库会优先处理超时并关闭连接，而不会将超时事件传递给下层TCP或basic流。如果同时在WebSocket和TCP或basic流上启用超时设置，就可能出现冲突和未定义的行为。

因此，当使用WebSocket流时，应该避免在底层的TCP或basic流上设置超时，而是可以通过WebSocket流对象的set_option函数来设置WebSocket连接的超时时间。这样可以确保WebSocket连接中的超时机制正常工作，并且不会干扰底层流的超时设置。

与大多数I/O对象一样，WebSocket流对象也不是线程安全的。如果两个不同的线程同时访问该对象，则会产生未定义行为。

对于多线程程序，可以通过在构造tcp_stream对象时使用executor（如strand）来保证线程安全。下面的代码声明了一个使用strand来调用所有完成处理程序的WebSocket流：

1
stream<tcp_stream> ws(net::make_strand(ioc));

如果下一层流支持移动构造，那么WebSocket流对象可以从一个已移动的对象中构造。

这意味着，在创建WebSocket流对象时，可以将下一层流对象的所有权转移到WebSocket流对象中，而不需要进行复制或重新分配。这种方式可以避免额外的内存开销和数据拷贝操作，提高程序运行效率。

例如，可以使用std::move函数将一个已存在的TCP套接字对象移动到WebSocket流中：

1
stream<tcp_stream> ws(std::move(sock));

可以通过调用WebSocket流对象的next_layer函数来访问下一层流对象。

1
ws.next_layer().close();

使用SSL#

使用”net::ssl::stream”类模板作为流的模板类型，并且将”net::io_context”和”net::ssl::context”参数传递给包装流的构造函数。

1
stream<ssl_stream<tcp_stream>> wss(net::make_strand(ioc), ctx);

当然如果websocket stream 使用SSL类型需要包含<boost/beast/websocket/ssl.hpp>
next_layer() 函数用于访问底层的 SSL 流。ssl::stream 类中的 next_layer() 函数返回对底层 ssl_stream 的引用，它代表了建立在 SSL/TLS 层之上的网络流。

1
wss.next_layer().handshake(net::ssl::stream_base::client);

在上述声明的多层流（如 SSL 流）中，使用 next_layer 进行链式调用访问每个层可能会很麻烦。为了简化这个过程，Boost.Beast 提供了 get_lowest_layer() 函数，用于获取多层流中的最底层流。

通过调用 get_lowest_layer() 函数，您可以直接获取多层流中的最底层流，而无需逐层调用 next_layer()。这对于取消所有未完成的 I/O 操作非常有用，例如在关闭连接之前取消所有挂起的异步操作。

1
get_lowest_layer(wss).cancel();

连接#

在进行 WebSocket 通信之前，需要首先连接 WebSocket 流，然后执行 WebSocket 握手。WebSocket 流将建立连接的任务委托给下一层流。例如，如果下一层是可连接的流或套接字对象，则可以访问它以调用必要的连接函数。以下是作为客户端执行的示例代码

1
stream<tcp_stream> ws(ioc);
2
net::ip::tcp::resolver resolver(ioc);
3
get_lowest_layer(ws).connect(resolver.resolve("example.com", "ws"));

对于服务器接收连接，在WebSocket服务器中使用一个acceptor来接受传入的连接。当建立了一个传入连接时，可以从acceptor返回的socket构造WebSocket流。

1
net::ip::tcp::acceptor acceptor(ioc);
2
acceptor.bind(net::ip::tcp::endpoint(net::ip::tcp::v4(), 0));
3
acceptor.listen();
4
stream<tcp_stream> ws(acceptor.accept());

也可以通过使用acceptor成员函数的另一个重载，将传入连接直接接受到WebSocket流拥有的socket中

1
stream<tcp_stream> ws(net::make_strand(ioc));
2
acceptor.accept(get_lowest_layer(ws).socket());

握手#

websocket通过握手将http升级为websocket协议，一个websocket协议如下

1
GET / HTTP/1.1
2
Host: www.example.com
3
Upgrade: websocket
4
Connection: upgrade
5
Sec-WebSocket-Key: 2pGeTR0DsE4dfZs2pH+8MA==
6
Sec-WebSocket-Version: 13
7
User-Agent: Boost.Beast/216

先说客户端如何升级
这段代码使用websocket::stream的成员函数handshake和async_handshake，用于使用所需的主机名和目标字符串发送请求。该代码连接到从主机名查找返回的IP地址，然后在客户端角色中执行WebSocket握手

1
stream<tcp_stream> ws(ioc);
2
net::ip::tcp::resolver resolver(ioc);
3
get_lowest_layer(ws).connect(resolver.resolve("www.example.com", "ws"));
4
ws.handshake(
5
    "www.example.com",  // The Host field
6
    "/"                 // The request-target
7
);

在客户端收到来自服务器的HTTP Upgrade响应并指示成功升级时，调用者可能希望对接收到的HTTP响应消息进行额外的验证。例如，检查对基本身份验证挑战的响应是否有效。为了实现这一目的，handshake成员函数提供了重载形式，允许调用者将接收到的HTTP消息存储在类型为response_type的输出引用参数中。

1
response_type res;
2
ws.handshake(
3
    res,                // Receives the HTTP response
4
    "www.example.com",  // The Host field
5
    "/"                 // The request-target
6
);

所以上述握手函数根据自己的需求调用一个即可。

再说服务器如何升级

对于接受传入连接的服务器，websocket::stream可以读取传入的升级请求并自动回复。如果握手符合要求，流将发送带有101切换协议状态码的升级响应。如果握手不符合要求，或者超出了调用者之前设置的流选项允许的参数范围，流将发送一个带有表示错误的状态码的HTTP响应。根据保持活动设置，连接可能保持打开状态，以进行后续握手尝试。在接收到升级请求握手后，由实现创建和发送的典型HTTP升级响应如下所示：

1
HTTP/1.1 101 Switching Protocols
2
Upgrade: websocket
3
Connection: upgrade
4
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
5
Server: Boost.Beast

stream的accept和async_accept成员函数用于从已连接到传入对等方的流中读取WebSocket HTTP升级请求握手，然后发送WebSocket HTTP升级响应。示例如下

1
ws.accept();

在某些情况下，服务器可能需要从流中读取数据，并在稍后决定将缓冲的字节解释为WebSocket升级请求。为了满足这种需求，accept和async_accept提供了接受额外缓冲区参数的重载版本。

以下是一个示例，展示了服务器如何将初始的HTTP请求头部读取到一个动态缓冲区中，然后稍后使用缓冲的数据尝试进行WebSocket升级：

1
std::string s;
2
net::read_until(sock, net::dynamic_buffer(s), "\r\n\r\n");
3
ws.accept(net::buffer(s));

在实现同时支持WebSocket的HTTP服务器时，服务器通常需要从客户端读取HTTP请求。为了检测传入的HTTP请求是否是WebSocket升级请求，可以使用函数is_upgrade。

一旦调用者确定HTTP请求是WebSocket升级请求，就会提供额外的accept和async_accept重载版本，这些版本接收整个HTTP请求头作为一个对象，以进行握手处理。通过手动读取请求，程序可以处理普通的HTTP请求以及升级请求。程序还可以根据HTTP字段强制执行策略，例如基本身份验证。在这个示例中，首先使用HTTP算法读取请求，然后将其传递给新构建的流：

1
flat_buffer buffer;
2
http::request<http::string_body> req;
3
http::read(sock, buffer, req);
4
if(websocket::is_upgrade(req))
5
{
6
    stream<tcp_stream> ws(std::move(sock));
7

8
    BOOST_ASSERT(buffer.size() == 0);
9

10
    ws.accept(req);
11
}
12
else
13
{
14

15
}

展开收起

所以综上所述，在构建websocket升级时，可以用两种方式，一种是websocket来accept，另一种是在处理http的请求时将请求升级为websocket。
而这两种我们在实战的代码中都有实现，可以下载源码查看。

收发数据#

当我们建立好websocket的握手后，就可以通过读写操作收发数据了。

1
flat_buffer buffer;
2
ws.read(buffer);
3
ws.text(ws.got_text());
4
ws.write(buffer.data());
5
buffer.consume(buffer.size());

上面的代码片段采用同步读和同步写的方式，根据接收消息的类型设置 WebSocket 连接的模式。
回显接收到的消息给对等端。
清空缓冲区，以便下一次读取可以开始构建新的消息。

但有些场景我们不能通过buffer一次性的读出数据

这是一些使用场景，这些场景中无法预先缓冲整个消息：

向终端流式传输多媒体：在流式传输多媒体到终端时，通常不适合或不可能预先缓冲整个消息。例如，在实时视频流或音频流的传输过程中，数据可能以非常大的速率产生，并且需要立即传输给接收端进行实时播放。由于数据量巨大且需即时传输，预先缓冲整个消息可能会导致延迟或资源耗尽。
发送超出内存容量的消息：有时候需要发送的消息太大，无法一次性完全存储在内存中。这可能发生在需要传输大型文件或大量数据的情况下。如果尝试将整个消息加载到内存中，可能会导致内存溢出或系统性能下降。在这种情况下，需要通过分块或逐步读取的方式来发送消息，以便逐步加载和传输数据。
提供增量结果：在某些情况下，需要在处理过程中提供增量的结果，而不是等待整个处理完成后再返回结果。这可以在长时间运行的计算、搜索或处理任务中发生。通过逐步提供部分结果，可以让用户或应用程序更早地获得一些数据，并可以在处理过程中进行进一步的操作或显示。这种方式可以改善用户体验，并减少等待时间。

在这些特定的使用场景中，需要采用逐步处理、流式传输或增量输出的方式，而不是依赖于预先缓冲整个消息。这样可以提高性能、降低内存消耗，并满足特定需求。

如下是asio提供的官方案例，通过流式读取的方式获取对端信息

1
multi_buffer buffer;
2

3
do
4
{
5
    ws.read_some(buffer, 512);
6
}
7
while(! ws.is_message_done());
8

9

10
ws.binary(ws.got_binary());
11

12

13
buffers_suffix<multi_buffer::const_buffers_type> cb{buffer.data()};
14

15
for(;;)
16
{
17
    if(buffer_bytes(cb) > 512)
18
    {
19
        ws.write_some(false, buffers_prefix(512, cb));
20
        cb.consume(512);
21
    }
22
    else
23
    {
24
        ws.write_some(true, cb);
25
        break;
26
    }
27
}
28

29
buffer.consume(buffer.size());

展开收起

这段代码涉及 WebSocket 数据的读取和写入操作。以下是对每个部分的解释：

1 multi_buffer buffer;
这行代码定义了一个名为 buffer 的 multi_buffer 对象，用于存储读取的 WebSocket 数据。

2 do { ... } while(! ws.is_message_done());
这部分代码使用一个循环，连续调用 ws.read_some 方法从 WebSocket 连接中读取数据，并将其存储到 buffer 中，直到 WebSocket 消息全部接收完成。

3 ws.binary(ws.got_binary());
此行代码将 WebSocket 连接设置为二进制模式，以便在后续的写入操作中正确处理二进制数据。

4 buffers_suffix<multi_buffer::const_buffers_type> cb{buffer.data()};
这行代码创建了一个 cb 对象，它是 buffer 的后缀子序列。它提供了对 buffer 中已接收数据的访问。

5 if(buffer_bytes(cb) > 512) { ... } else { ... }
这段代码检查 cb 中的数据量是否大于 512 字节。如果是，将执行 if 语句块；否则，将执行 else 语句块。

6 ws.write_some(false, buffers_prefix(512, cb));
如果 cb 中的数据量大于 512 字节，此行代码将发送 cb 的前缀（前 512 字节）到 WebSocket 连接中，并保留剩余的数据。

7 cb.consume(512);
这行代码告知 cb 对象消耗了前 512 字节的数据，以便在后续迭代中更新迭代范围。

8 ws.write_some(true, cb);
如果 cb 中的数据量少于等于 512 字节，此行代码将发送 cb 中的所有数据到 WebSocket 连接中。

buffer.consume(buffer.size());
这行代码清空 buffer 中存储的数据，使其为空。

总体来说，这段代码的作用是读取 WebSocket 数据并将其写回 WebSocket 连接，确保数据按照预期进行处理。最后，通过 buffer.consume(buffer.size()) 清空缓冲区，准备下一次数据读取操作。

关闭连接#

当我们想关闭连接时，可以通过close 或 async_close 的关闭函数。
具体而言，WebSocket 协议规定了两种关闭方式：

close
这是一个同步操作的函数，用于关闭 WebSocket 会话。当调用 close 时，客户端或服务器会向对方发送一个关闭帧，并且在收到对方的关闭帧后，会话将被正常关闭。

async_close
这是一个异步操作的函数，用于关闭 WebSocket 会话。与 close 不同，async_close 是一个非阻塞操作，它不会等待对方的关闭帧，而是立即返回，并触发一个异步关闭操作。这样可以在关闭过程中继续处理其他任务，而不必等待关闭完成。

这些关闭函数允许主机在 WebSocket 会话中发起关闭请求，以便安全地终止连接。应用程序可以根据需要选择适合的关闭函数，具体取决于其对同步或异步关闭的要求。

因为一个websocket会包含多个层，所以我们可以通过获取最底层，再执行关闭。这样保证所有层都安全关闭。

1
get_lowest_layer(wss).close();

函数用法

Sun, 17 May 2026 00:00:00 GMT

1. 函数简介#

定义#

函数是执行特定任务的代码块，可以被程序中的多个地方调用。使用函数可以增加代码的可重用性、可读性和可维护性。

功能#

封装：将特定功能封装在函数中，便于管理和修改。
复用：同一段功能代码可以在程序中多次调用，减少代码重复。
结构化：通过函数组织代码，提高程序的结构清晰度。

基本语法#

1
return_type function_name(parameter_list) {
2
    // function body
3
}

示例：

1
#include <iostream>
2

3
// 函数声明
4
int add(int a, int b);
5

6
int main() {
7
    int result = add(5, 3);
8
    std::cout << "5 + 3 = " << result << std::endl;
9
    return 0;
10
}
11

12
// 函数定义
13
int add(int a, int b) {
14
    return a + b;
15
}

展开收起

输出：

1
5 + 3 = 8

2. 函数的声明与定义#

函数声明（Function Declaration）#

告诉编译器函数的名称、返回类型和参数类型，但不包含函数体。通常放在头文件中或在使用函数前进行声明。

语法：

1
return_type function_name(parameter_list);

示例：

1
int multiply(int a, int b); // 函数声明

函数定义（Function Definition）#

提供函数的具体实现，包括函数体。函数定义可以在源文件中或与声明一起在头文件中出现（推荐仅声明在头文件中）。

语法：

1
return_type function_name(parameter_list) {
2
    // function body
3
}

示例：

1
int multiply(int a, int b) { // 函数定义
2
    return a * b;
3
}

函数分离编译#

声明：放在头文件（如 multiply.h）。
定义：放在源文件（如 multiply.cpp）。

multiply.h:

1
#ifndef MULTIPLY_H
2
#define MULTIPLY_H
3

4
int multiply(int a, int b);
5

6
#endif

multiply.cpp:

1
#include "multiply.h"
2

3
int multiply(int a, int b) {
4
    return a * b;
5
}

main.cpp:

1
#include <iostream>
2
#include "multiply.h"
3

4
int main() {
5
    int result = multiply(4, 6);
6
    std::cout << "4 * 6 = " << result << std::endl;
7
    return 0;
8
}

编译命令（假设使用g++）：

Terminal window

1
g++ main.cpp multiply.cpp -o program

输出：

1
4 * 6 = 24

3. 函数调用#

基本调用#

通过函数名称和必要的参数来调用函数。

示例：

1
#include <iostream>
2

3
void greet() {
4
    std::cout << "Hello, World!" << std::endl;
5
}
6

7
int main() {
8
    greet(); // 调用函数
9
    return 0;
10
}

输出：

1
Hello, World!

多次调用#

同一函数可以在程序中被调用多次。

示例：

1
#include <iostream>
2

3
void sayHello() {
4
    std::cout << "Hello!" << std::endl;
5
}
6

7
int main() {
8
    sayHello();
9
    sayHello();
10
    sayHello();
11
    return 0;
12
}

输出：

1
Hello!
2
Hello!
3
Hello!

4. 参数传递机制#

C++中函数参数的传递方式主要有以下三种：

传值调用（Pass by Value）
传引用调用（Pass by Reference）
传指针调用（Pass by Pointer）

传值调用#

定义：函数接收参数的副本，函数内对参数的修改不会影响原始数据。

语法：

1
void function_name(int a) {
2
    a = 10; // 只修改副本
3
}

示例：

1
#include <iostream>
2

3
void changeValue(int num) {
4
    num = 100;
5
    std::cout << "Inside function: " << num << std::endl;
6
}
7

8
int main() {
9
    int value = 50;
10
    changeValue(value);
11
    std::cout << "Outside function: " << value << std::endl;
12
    return 0;
13
}

输出：

Terminal window

1
Inside function: 100
2
Outside function: 50

解释：changeValue函数修改的是num的副本，原始变量value保持不变。

传引用调用#

定义：函数接收参数的引用，函数内对参数的修改会影响原始数据。

语法：

1
void function_name(int &a) {
2
    a = 10; // 修改原始数据
3
}

示例：

1
#include <iostream>
2

3
void changeValue(int &num) {
4
    num = 100;
5
    std::cout << "Inside function: " << num << std::endl;
6
}
7

8
int main() {
9
    int value = 50;
10
    changeValue(value);
11
    std::cout << "Outside function: " << value << std::endl;
12
    return 0;
13
}

输出：

Terminal window

1
Inside function: 100
2
Outside function: 100

解释：changeValue函数通过引用修改了原始变量value的值。

传指针调用#

定义：函数接收指向参数的指针，函数内通过指针可以修改原始数据。

语法：

1
void function_name(int *a) {
2
    *a = 10; // 修改原始数据
3
}

示例：

1
#include <iostream>
2

3
void changeValue(int *num) {
4
    *num = 100;
5
    std::cout << "Inside function: " << *num << std::endl;
6
}
7

8
int main() {
9
    int value = 50;
10
    changeValue(&value);
11
    std::cout << "Outside function: " << value << std::endl;
12
    return 0;
13
}

输出：

Terminal window

1
Inside function: 100
2
Outside function: 100

解释：changeValue函数通过指针修改了原始变量value的值。

选择合适的传递方式#

传值调用：适用于不需要修改原始数据且数据量较小的情况。
传引用调用：适用于需要修改原始数据或传递大型数据结构以提高效率。
传指针调用：类似传引用调用，但更灵活，可用于传递nullptr或指向动态分配的内存。

5. 返回值#

函数可以通过return语句将结果返回给调用者。返回值的类型可以是基本数据类型、引用、指针、对象等。

5.1 返回基本数据类型#

示例：

1
#include <iostream>
2

3
int add(int a, int b) {
4
    return a + b;
5
}
6

7
int main() {
8
    int sum = add(3, 4);
9
    std::cout << "Sum: " << sum << std::endl;
10
    return 0;
11
}

输出：

1
Sum: 7

5.2 返回引用#

注意：返回引用需要确保引用的对象在返回后依然有效（避免悬垂引用）。

示例：

1
#include <iostream>
2

3
int& getMax(int &a, int &b) {
4
    if(a > b)
5
        return a;
6
    else
7
        return b;
8
}
9

10
int main() {
11
    int x = 10;
12
    int y = 20;
13
    int &max = getMax(x, y);
14
    std::cout << "Max: " << max << std::endl;
15
    max = 30; // 修改引用
16
    std::cout << "After modification, y: " << y << std::endl;
17
    return 0;
18
}

展开收起

输出：

1
Max: 20
2
After modification, y: 30

解释：getMax函数返回较大的变量的引用，修改max实际上修改了y。

5.3 返回指针#

示例：

1
#include <iostream>
2

3
int* allocateArray(int size) {
4
    int* arr = new int[size];
5
    for(int i = 0; i < size; ++i)
6
        arr[i] = i * 2;
7
    return arr;
8
}
9

10
int main() {
11
    int size = 5;
12
    int* myArray = allocateArray(size);
13
    for(int i = 0; i < size; ++i)
14
        std::cout << myArray[i] << " ";
15
    std::cout << std::endl;
16
    delete[] myArray; // 释放内存
17
    return 0;
18
}

展开收起

输出：

1
0 2 4 6 8

解释：allocateArray函数动态分配一个数组并返回指向数组的指针。调用者需负责释放内存。

5.4 返回对象#

示例：

1
#include <iostream>
2
#include <string>
3

4
class Person {
5
public:
6
    std::string name;
7
    int age;
8

9
    Person(std::string n, int a) : name(n), age(a) {}
10
};
11

12
Person createPerson(std::string name, int age) {
13
    Person p(name, age);
14
    return p; // 返回对象
15
}
16

17
int main() {
18
    Person person = createPerson("Alice", 25);
19
    std::cout << "Name: " << person.name << ", Age: " << person.age << std::endl;
20
    return 0;
21
}

展开收起

输出：

1
Name: Alice, Age: 25

解释：createPerson函数返回一个Person对象。现代编译器通过返回值优化（RVO）减少对象拷贝，提高效率。

6. 函数重载#

定义#

函数重载允许在同一个作用域内定义多个名称相同但参数列表不同的函数。编译器通过参数列表的不同来区分调用哪个函数。

规则#

函数名相同。
参数列表（类型、数量或顺序）不同。
返回类型不参与重载的区分。

示例#

1
#include <iostream>
2

3
// 重载函数：不同参数数量
4
int add(int a, int b) {
5
    return a + b;
6
}
7

8
int add(int a, int b, int c) {
9
    return a + b + c;
10
}
11

12
// 重载函数：不同参数类型
13
double add(double a, double b) {
14
    return a + b;
15
}
16

17
int main() {
18
    std::cout << "add(2, 3) = " << add(2, 3) << std::endl;
19
    std::cout << "add(2, 3, 4) = " << add(2, 3, 4) << std::endl;
20
    std::cout << "add(2.5, 3.5) = " << add(2.5, 3.5) << std::endl;
21
    return 0;
22
}

展开收起

输出：

1
add(2, 3) = 5
2
add(2, 3, 4) = 9
3
add(2.5, 3.5) = 6

注意事项#

仅返回类型不同的重载是非法的。
默认参数可能会与重载产生冲突，使用时需谨慎。

非法示例：

1
double add(int a, int b) {
2
    return a + b + 0.0;
3
}
4

5
// 冲突重载，仅返回类型不同
6
// 会导致编译错误
7
// double add(int a, int b);

7. 默认参数#

定义#

函数参数可以指定默认值，调用函数时可以省略这些参数，默认值将被使用。

规则#

默认参数从右到左设置，不能部分设置。
函数声明和定义中默认参数只需在声明中指定。

示例#

1
#include <iostream>
2

3
// 函数声明时指定默认参数
4
void displayInfo(std::string name, int age = 18, std::string city = "Unknown");
5

6
int main() {
7
    displayInfo("Bob", 25, "New York"); // 全部参数传递
8
    displayInfo("Charlie", 30);         // 省略city
9
    displayInfo("Diana");               // 省略age和city
10
    return 0;
11
}
12

13
// 函数定义
14
void displayInfo(std::string name, int age, std::string city) {
15
    std::cout << "Name: " << name
16
              << ", Age: " << age
17
              << ", City: " << city << std::endl;
18
}

展开收起

输出：

1
Name: Bob, Age: 25, City: New York
2
Name: Charlie, Age: 30, City: Unknown
3
Name: Diana, Age: 18, City: Unknown

注意事项#

默认参数必须从右端开始，不能跳过中间参数。
如果同时使用默认参数和重载，可能会产生歧义，需谨慎设计。

8. 内联函数#

定义#

内联函数通过在函数前加inline关键字，建议编译器将函数代码嵌入到调用处，减少函数调用的开销。

使用场景#

适用于函数体积小、调用频繁的函数，如访问器（getter）和修改器（setter）等。

示例#

1
#include <iostream>
2

3
// 内联函数
4
inline int square(int x) {
5
    return x * x;
6
}
7

8
int main() {
9
    std::cout << "Square of 5: " << square(5) << std::endl;
10
    return 0;
11
}

输出：

1
Square of 5: 25

优点#

减少函数调用的开销（如栈操作）。
可能提高程序性能。

缺点#

使得代码体积增大，可能影响缓存性能。
编译器可能忽略内联请求，特别是对于复杂函数。

注意事项#

编译器对inline关键字的处理是建议性质，最终是否内联由编译器决定。
过度使用内联函数可能导致代码膨胀。

9. 递归函数#

定义#

递归函数是指在函数体内调用自身的函数。递归通常用于解决可以分解为相似子问题的问题，如阶乘、斐波那契数列、树的遍历等。

基本结构#

递归函数通常包含两个部分：

基准情形（Base Case）：直接返回结果，避免无限递归。
递归情形（Recursive Case）：将问题分解为更小的子问题并调用自身。

示例：计算阶乘#

1
#include <iostream>
2

3
// 递归函数计算阶乘
4
long long factorial(int n) {
5
    if(n < 0)
6
        return -1; // 错误情况
7
    if(n == 0 || n == 1)
8
        return 1; // 基准情形
9
    return n * factorial(n - 1); // 递归情形
10
}
11

12
int main() {
13
    int number = 5;
14
    long long result = factorial(number);
15
    if(result != -1)
16
        std::cout << number << "! = " << result << std::endl;
17
    else
18
        std::cout << "Invalid input!" << std::endl;
19
    return 0;
20
}

展开收起

输出：

1
5! = 120

示例：斐波那契数列#

1
#include <iostream>
2

3
// 递归函数计算斐波那契数
4
int fibonacci(int n) {
5
    if(n <= 0)
6
        return 0;
7
    if(n == 1)
8
        return 1;
9
    return fibonacci(n - 1) + fibonacci(n - 2);
10
}
11

12
int main() {
13
    int term = 10;
14
    std::cout << "Fibonacci(" << term << ") = " << fibonacci(term) << std::endl;
15
    return 0;
16
}

展开收起

输出：

1
Fibonacci(10) = 55

注意事项#

基准情形：必须正确设置，避免无限递归导致栈溢出（Stack Overflow）。
效率问题：一些递归实现可能效率低下（如斐波那契数列），可以通过“记忆化”或改用迭代方法优化。
堆栈深度：递归深度过大可能导致栈溢出，需避免深度递归。

递归优化：尾递归#

尾递归是指递归调用在函数的最后一步，可以被编译器优化为循环，减少堆栈消耗。

示例：尾递归阶乘

1
#include <iostream>
2

3
// 辅助函数，用于尾递归
4
long long factorialHelper(int n, long long accumulator) {
5
    if(n == 0)
6
        return accumulator;
7
    return factorialHelper(n - 1, n * accumulator);
8
}
9

10
// 尾递归函数
11
long long factorial(int n) {
12
    return factorialHelper(n, 1);
13
}
14

15
int main() {
16
    int number = 5;
17
    std::cout << number << "! = " << factorial(number) << std::endl;
18
    return 0;
19
}

展开收起

输出：

1
5! = 120

解释：factorialHelper函数的递归调用是函数的最后一步，编译器可以将其优化为迭代，减少堆栈消耗。

10. Lambda表达式#

定义#

Lambda表达式是C++11引入的匿名函数，便于在需要函数对象的地方快速定义和使用函数。它允许定义内联的、小型的可调用对象，无需单独定义函数。

语法#

1
[ capture_list ] ( parameter_list ) -> return_type {
2
    // function body
3
}

示例#

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

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

8
    // 使用Lambda表达式打印每个元素
9
    std::for_each(numbers.begin(), numbers.end(), [](int x) {
10
        std::cout << x << " ";
11
    });
12
    std::cout << std::endl;
13

14
    // 使用Lambda表达式计算总和
15
    int sum = 0;
16
    std::for_each(numbers.begin(), numbers.end(), [&sum](int x) {
17
        sum += x;
18
    });
19
    std::cout << "Sum: " << sum << std::endl;
20

21
    return 0;
22
}

展开收起

输出：

组件说明#

捕获列表（Capture List）：指定如何访问外部变量。
- [ ]：不捕获任何外部变量。
- [&]：按引用捕获所有外部变量。
- [=]：按值捕获所有外部变量。
- [x, &y]：按值捕获x，按引用捕获y。
参数列表（Parameter List）：类似普通函数的参数列表，可以省略类型（C++14及以上支持自动类型推断）。
返回类型（Return Type）：可指定返回类型，也可省略，编译器自动推断。
函数体（Function Body）：Lambda的具体实现。

高级示例：捕获并排序#

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
int main() {
6
    std::vector<int> data = {5, 2, 9, 1, 5, 6};
7

8
    // 按降序排序，使用Lambda表达式
9
    std::sort(data.begin(), data.end(), [](int a, int b) -> bool {
10
        return a > b;
11
    });
12

13
    std::cout << "Sorted data: ";
14
    for(auto num : data)
15
        std::cout << num << " ";
16
    std::cout << std::endl;
17

18
    return 0;
19
}

展开收起

输出：

1
Sorted data: 9 6 5 5 2 1

使用Lambda表达式与标准库#

C++标准库中的许多算法（如std::for_each、std::sort、std::transform等）常用Lambda表达式作为参数，以实现自定义的操作。

11. 函数指针与回调函数#

函数指针#

定义：指向函数的指针变量，保存函数的地址，可以通过指针调用函数。

声明与使用#

1
#include <iostream>
2

3
// 普通函数
4
void greet() {
5
    std::cout << "Hello from greet!" << std::endl;
6
}
7

8
int main() {
9
    // 定义函数指针
10
    void (*funcPtr)() = greet;
11

12
    // 通过指针调用函数
13
    funcPtr();
14

15
    return 0;
16
}

展开收起

输出：

1
Hello from greet!

函数指针作为参数#

示例：

1
#include <iostream>
2

3
// 高阶函数，接受函数指针作为参数
4
void execute(void (*func)()) {
5
    func(); // 调用传入的函数
6
}
7

8
// 被调用的函数
9
void sayHi() {
10
    std::cout << "Hi!" << std::endl;
11
}
12

13
int main() {
14
    execute(sayHi);
15
    return 0;
16
}

展开收起

输出：

1
Hi!

回调函数#

定义：通过函数指针传递的函数，通常用于在特定事件发生时执行自定义操作。

示例：基于函数指针的回调

1
#include <iostream>
2

3
// 回调类型定义
4
typedef void (*Callback)();
5

6
// 函数接收回调
7
void registerCallback(Callback cb) {
8
    std::cout << "Before callback" << std::endl;
9
    cb(); // 执行回调
10
    std::cout << "After callback" << std::endl;
11
}
12

13
// 回调函数
14
void myCallback() {
15
    std::cout << "Callback executed!" << std::endl;
16
}
17

18
int main() {
19
    registerCallback(myCallback);
20
    return 0;
21
}

展开收起

输出：

1
Before callback
2
Callback executed!
3
After callback

与Lambda表达式结合#

函数指针也可以指向Lambda表达式，但仅限于不捕获外部变量的Lambda。

示例：

1
#include <iostream>
2

3
// 回调类型定义
4
typedef void (*Callback)();
5

6
void executeCallback(Callback cb) {
7
    cb();
8
}
9

10
int main() {
11
    // 不捕获外部变量的Lambda
12
    Callback cb = []() {
13
        std::cout << "Lambda callback!" << std::endl;
14
    };
15

16
    executeCallback(cb);
17
    return 0;
18
}

展开收起

输出：

1
Lambda callback!

注意：捕获外部变量的Lambda无法转换为普通函数指针。

Vafail的个人博客

只出现一次数字

题目：只出现一次的数字#

题目描述#

示例#

示例 1#

示例 2#

示例 3#

提示#

代码#

stream流

1. C++流的基本概念#

常见的流类型#

2. 输出流 std::cout#

2.1 基本输出#

2.2 格式化输出#

3. 文件输出流 std::ofstream#

3.1 创建和打开文件#

3.2 向文件写入数据#

3.3 关闭文件#

3.4 示例代码#

4. 文件输入流 std::ifstream#

4.1 打开和读取文件#

4.2 处理读取的数据#

4.3 关闭文件#

4.4 示例代码#

5. 文件流 std::fstream （读写结合）#

5.1 同时进行读写操作#

5.2 示例代码#

6. 字符串流 std::stringstream#

6.1 std::stringstream 的基本概念#

6.2 字符串与其他数据类型的转换#

6.3 示例代码#

6.3.1 将多个数据类型组合成一个字符串#

6.3.2 从字符串中解析数据#

6.3.3 字符串与数字的相互转换#

6.3.4 使用 std::istringstream 和 std::ostringstream#

6.3.5 处理复杂的字符串格式#

6.4 总结#

7. 其他流操作#

7.1 检查文件是否成功打开#

7.2 逐行读取 vs 逐词读取#

7.3 错误处理#

7.4 追加模式#

7.5 读写模式中的其他标志#

7.6 实际应用示例#

单例模式

单例模式概念#

1. 控制实例数量#

2. 提供全局访问点#

3. 延迟实例化#

4. 避免命名冲突#

5. 管理共享资源#

设计单例模式的考虑因素#

适用场景#

不适用场景#

局部静态变量方式#

静态成员变量指针方式(饿汉式)#

静态成员变量指针方式(懒汉式)#

智能指针方式(懒汉式)#

辅助类智能指针单例模式#

通用的单例模板类(CRTP)#

万能引用和原样转发

1. 左值与右值#

1.1 定义与分类#

1.2 示例代码#

1.3 类型判断工具#

1.4 应用场景#

2. 模板万能引用（转发引用）#

2.1 定义与特性#

2.2 引用折叠规则#

关键点：#

2.3 示例代码#

3. 类型推导（Type Deduction）#

3.1 类型推导规则#

3.2 与引用的关系#

3.3 示例代码#

4. 原样转发（Perfect Forwarding）#

4.1 定义与作用#

4.2 实现原理#

2. 输出流 `std::cout`#

3. 文件输出流 `std::ofstream`#

4. 文件输入流 `std::ifstream`#

5. 文件流 `std::fstream` （读写结合）#

6. 字符串流 `std::stringstream`#

6.1 `std::stringstream` 的基本概念#

6.3.4 使用 `std::istringstream` 和 `std::ostringstream`#

5. `<font style="color:rgb(51, 51, 51);background-color:rgb(243, 244, 244);">op</font>` 在折叠表达式中的作用#

示例：检测类型是否具有 `<font style="color:rgb(51, 51, 51);background-color:rgb(243, 244, 244);">size()</font>` 成员函数#