从C到C++¶

有的同学可能会问：那为什么又来了个C++呢？C不是已经很好了吗？为什么还要搞个C++出来呢？

理由很简单：C语言的确简单高效，但“太弱”，缺乏现代编程语言的特性，如OOP（面向对象编程）、泛型；其标准库也极小，很多东西都得手搓，在日常编程中这是非常痛苦的。

因此，C++应运而生。C++在保留C语言高效和灵活的同时，引入了许多现代编程语言的特性，如类和对象、继承、多态、模板等，从而使得程序设计更加模块化、可维护和可扩展。此外，C++还提供了一个强大的标准库（STL），包括容器、算法和迭代器等，大大简化了日常编程任务。

C++广泛应用于多种需要兼顾性能和抽象的领域，如系统软件、游戏开发、嵌入式系统和高性能计算等，著名的Chrome、Adobe全家桶、MS Office、Visual Studio都是C++写的，古老的DirectX游戏引擎¹、现代的虚幻引擎²等也都要求用C++开发；而Unity引擎虽然允许用户使用C#辅助开发，但其底层核心（乃至C#的.NET运行时）也是用C++完成；Python里相当多的高性能库（如PyTorch、TensorFlow、JAX³等）也是用C++写的。C和C++在事实上构成了当今高性能计算和软件开发的基石，在编程语言排名中常年稳居第三名和第二名，仅次于Python⁴。

本章所学基本聚焦于C++14及其之前的标准，后续章节会介绍更新更好的新特性。当然，本节中为了代码的简洁起见，使用了一些诸如using namespace std;之类的写法，但在工程代码中应当避免使用这些写法；关于这个东西是什么、为什么不建议使用、以及如何避免使用，后续章节会详细介绍。

从C到C++的区别¶

C++的基本语法和C语言几乎完全一致，因此如果你已经掌握了C语言，那么学习C++将会非常容易。

第一个C++程序¶

下面是一个简单的C++程序，它输出“Hello, World!”到屏幕上：

#include <iostream> // 引入输入输出流库

int main() {
    std::cout << "Hello, World!" << std::endl; // 输出Hello, World!
    return 0; // 返回0表示程序成功结束
}

我们发现，这个HelloWorld和C语言的HelloWorld长得很像，但确实存在一些区别： - 引入的头文件有区别； - 输出语句有区别。

在C++中，基本的语法结构和C语言类似，包括变量声明、数据类型、控制结构（如条件语句和循环语句）、函数定义等，统统一致。可以说，C怎么写，C++就怎么写，完全没有区别。C语言的标准库在C++中也有其移植版本，一般是从 xx.h 变成了 cxx ，例如C语言的 stdio.h 在C++中变成了 cstdio ，但函数和用法几乎完全一致。

区别在于：C++自带bool类型，不需要 #include <stdbool.h> ；另，结构体和联合体的定义上有所不同；第三，C++的字符串推荐用 std::string ，而不是C风格的字符串；最后，C++推荐使用流对象来输入输出。

接下来会把C++的新特性一一列举。对于面向对象、泛型和STL则会在后续章节中详细介绍。

花括号初始化¶

在C++中，推荐使用花括号初始化（brace initialization）来初始化变量。这种初始化方式可以防止窄化转换（narrowing conversion），从而提高代码的安全性。例如：

int x = 10;      // 传统初始化（赋值或者拷贝风格）
int y(20);      // 传统初始化（构造函数风格）
int z{30};      // 花括号初始化
int a{3.14};    // 保证一定不会发生窄化转换，编译错误

C++的输入输出及其格式化¶

输入输出流¶

在C++中，我们建议使用更安全的输入输出流 cin 和 cout 来进行输入输出操作。它们分别用于从标准输入（通常是键盘）读取数据和向标准输出（通常是屏幕）打印数据。

cin 和 cout 的基本用法如下：

#include <iostream>

int main() {
    int age;
    std::cout << "请输入你的年龄：";  // 输出提示信息
    std::cin >> age;  // 从标准输入读取数据
    std::cout << "你输入的年龄是：" << age << std::endl;  // 输出读取到的数据
    return 0;
}

std::endl 是一个特殊的操纵符（manipulator），它的作用是输出一个换行符并刷新输出缓冲区，等价于'\n' << std::flush。

所谓“缓冲区”指的是输出流在输出数据时会先将数据存储在一个临时的内存区域（缓冲区）中，等到缓冲区满了或者遇到换行符时才会将数据真正输出到屏幕上。使用 std::endl 可以确保输出立即显示在屏幕上，而不是被缓冲起来等待下一次输出操作，这对于调试和交互式程序非常有用。

但是需要注意的是，过度使用 std::endl 可能会导致性能问题，因为每次使用它都会刷新输出缓冲区，这可能会增加程序的运行时间。对于需要频繁输出的情况，建议使用 '\n' 来代替 std::endl ，以避免不必要的性能开销。

在此类输出中，如涉及运算，必须使用括号，否则会出现优先级错误的问题。例如：

    std::cout << "两数之和为：" << (a + b) << std::endl; // 正确
    std::cout << "两数之和为：" << a + b << std::endl;   // UB

C风格的输入输出¶

当然，使用C风格的输入输出函数 printf 和 scanf 也是可以的。例如：

#include <cstdio> // C风格的输入输出库

int main() {
    int age;
    std::printf("请输入你的年龄：");  // 输出提示信息
    std::scanf("%d", &age);  // 从标准输入读取数据
    std::printf("你输入的年龄是：%d\n", age);  // 输出读取到的数据
    return 0;
}

<cstdio> 是C++的C风格输入输出库，与C语言的 <stdio.h> 头文件内容完全一致，只不过使用了C++的命名空间（ std ）。不过大多数实现也允许不使用 std:: 前缀，也允许使用 <stdio.h> 头文件，但我们不建议使用C的头文件。

C风格的 std::printf 和 std::scanf 速度更快，因为不需要流操作；但是它们存在一些安全隐患，例如格式化字符串攻击和缓冲区溢出等问题。我们建议在C++工程上使用更安全的 std::cin 和 std::cout 。

我们在写代码的时候一定不要一句C一句C++，或者说不要一句printf一句cout（反过来也不行），这样会导致缓冲区冲突，从而引发一些莫名其妙的问题。要么全用C的输入输出，要么全用C++的输入输出。

格式化输出¶

有时候，我们需要对输入输出进行一些格式化操作，例如设置小数点位数、对齐方式等。除了使用printf的格式化字符串外，C++提供了一些操纵符（manipulator）来实现这些功能。 - std::setw(n) ：设置输出宽度为n个字符。 - std::setprecision(n) ：设置小数点位数为n位。 - std::fixed ：固定小数位数输出浮点数。 - std::scientific ：使用科学计数法输出浮点数。 - std::left ：左对齐输出。 - std::right ：右对齐输出。

上述不少操纵符需要引用头文件 <iomanip> 。例如，我们可以使用这些操纵符来格式化输出一个表格：

#include <iostream>
#include <iomanip>  // 引入操纵符库
int main() {
    std::cout << std::left << std::setw(10) << "Name" << std::setw(5) << "Age" << std::setw(10) << "GPA" << std::endl;
    std::cout << std::left << std::setw(10) << "Alice" << std::setw(5) << 20 << std::setw(10) << std::fixed << std::setprecision(2) << 3.5 << std::endl;
    std::cout << std::left << std::setw(10) << "Bob" << std::setw(5) << 22 << std::setw(10) << std::fixed << std::setprecision(2) << 3.8 << std::endl;
    return 0;
}

格式化输入¶

对于输入，则复杂得多。我们推荐同学们使用更安全的C++风格输入输出方法，也就是 cin 、 cout 、 getline 等。

对于确定数量的干净⁵输入，可以直接使用 cin ：

int a, b, c;
// 假设输入格式为：1 2 3
cin >> a >> b >> c;  // 读入三个整数

对于不确定数量的干净输入，可以使用循环配合 cin ：

int n;
while (cin >> n) {
    // 处理输入的n
}

如果遇到脏输入，则情况变得复杂许多。常见的脏输入包括逗号分割的数字、带有多余空格的字符串等。对于这些情况，推荐使用 getline 配合字符串流（ stringstream ）来处理。下文演示了这种方式，并将逗号分割的整数字符串转换为整数数组：

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;

int main(){
    string line;
    string tmp;
    vector<int> results;

    // 1. 读一整行
    getline(cin, line);

    // 2. 创建字符串流
    stringstream ss(line);

    // 3. 按逗号分割并处理
    while (getline(ss, tmp, ',')) {
        results.push_back(stoi(tmp)); // 转换为整数并存储
    }
    // 如果转换为double，可以使用stod
}

工程上，脏数据非常常见，因此掌握这些输入方式是非常有必要的。

利用文件流进行文件读写¶

在C语言的章节中，我们已经知道，可以使用FILE结构体的指针来操作文件。但是这种操作有一定弊病：需要手动管理文件指针，容易出错。虽然智能指针能够部分解决手动管理文件指针的麻烦，但C++提供了更好的文件操作方式：文件流（file stream）。

文件流和输入输出流类似，也是一个流对象。文件流有两个：std::ifstream用于从文件读取数据，std::ofstream用于向文件写入数据，分别对应标准输入输出的std::cin和std::cout。这两个流对象提供了和标准输入输出流类似的操作方法，例如使用>>和<<运算符进行读写操作。

下面是一个简单的例子，演示如何使用文件流读取和写入文件：

#include <iostream> 
#include <fstream>  // 引入文件流库

int main(){
    std::ifstream infile("input.txt"); // 打开输入文件
    std::ofstream outfile("output.txt"); // 打开输出文件，默认是覆盖模式
    int a, b;
    infile >> a >> b; // 从输入文件读取数据
    outfile << "Sum: " << (a + b) << std::endl; // 向输出文件写入数据
    infile.close(); // 关闭输入文件
    outfile.close(); // 关闭输出文件
    return 0;
}

ofstream默认是覆盖模式打开文件的，如果想要以追加模式打开文件，可以使用以下方式：

std::ofstream outfile("output.txt", std::ios::app); // 以追加模式打开输出文件

当然，也可以使用一个统一的文件流对象来同时进行读写操作，这时需要使用std::fstream类，但这时候需要指定读写模式：

std::fstream file("data.txt", std::ios::in | std::ios::out); // 以读写模式打开文件

我们有这些读写模式可以使用： - std::ios::in ：以读模式打开文件。 - std::ios::out ：以写模式打开文件。 - std::ios::app ：以追加模式打开文件，写入的数据会追加到文件末尾。 - std::ios::ate ：打开文件后将文件指针移动到文件末尾，可以用于读写操作。 - std::ios::trunc ：如果文件已存在，则在打开时将其内容截断为0长度（实际上就是覆盖模式）。 - std::ios::binary ：以二进制模式打开文件，而不是文本模式。这一手段打开的文件能够避免字符转换。 这些读写模式实际上都是独热编码，也正因此，我们可以使用按位或运算符（|）来组合多个模式。

文件的其他操作¶

在C语言中，我们能够使用remove等函数来对文件和目录进行操作。在C++中也有类似的功能，位于<filesystem>头文件中。这个头文件在C++17中引入，提供了一些用于文件和目录操作的类和函数。 下面是一些常用的文件操作函数： - std::filesystem::remove(path) ：删除指定路径的文件或目录。 - std::filesystem::rename(old_path, new_path) ：重命名文件或目录。 - std::filesystem::copy(source, destination) ：复制文件或目录。 - std::filesystem::create_directory(path) ：创建一个新目录。 - std::filesystem::exists(path) ：检查指定路径是否存在。 - std::filesystem::file_size(path) ：获取指定文件的大小。 - std::filesystem::current_path() ：获取当前工作目录的路径。 - std::filesystem::absolute(path) ：获取指定路径的绝对路径。 - std::filesystem::directory_iterator(path) ：迭代指定目录下的文件和子目录。 - std::filesystem::space(path) ：获取指定路径所在文件系统的空间信息。 - std::filesystem::last_write_time(path) ：获取指定文件的最后修改时间。 - std::filesystem::permissions(path, perms) ：设置指定文件或目录的权限。 - std::filesystem::remove_all(path) ：递归删除指定路径的文件或目录及其内容。

需要注意的是，path是一个类型，可以是字符串类型（如std::string）或者std::filesystem::path类型。使用这些函数时，需要包含头文件<filesystem>，并且在编译时需要链接文件系统库（例如使用-lstdc++fs选项）。

常变量、常量和它们的关系¶

常变量（也叫不可变变量、只读变量、运行时常量）、常量（也叫编译期常量）往往笼统地称为常量。它们一旦确定就不会在程序运行时改变，任何试图对它们进行运行时更改的操作都会使得编译不通过。常量的值应当在声明时确定，可以通过赋值或者计算得到。它们的名字通常使用大写字母来表示，以便于和变量区分。

声明常变量的方法和声明变量差不多，但是要在最前面加上 const 关键字，如：

const int MAX_VALUE = 100;
const int P = a + b; // 这里的a和b可以是变量
// P = 10 // 这行代码编译不通过，因此要注释掉

如果常变量的值必须在编译时确定，可以使用常量。常量的值在编译的时候值就确定了，不过因此也需要在定义中就写明它的值。常量的声明方法和常变量类似，只是把 const 换成 constexpr 。

常量也可以通过计算得到，计算在编译时进行，可以节省程序运行时间，但是要求用于计算的东西也必须是常量、字面值（直接写出来的值）、constexpr函数或者立即函数⁶。下文是常量的几个例子。

constexpr double E = 2.71828;
constexpr double PI = 3.14159;
constexpr double EPI = E * PI;

在现代 C++ 中， const 常变量不依靠运行时初始化来确定其值（例如const int b = 1;），其表现就和 constexpr 常量一样了。因此，在大多数时候，我们也可以把 const 常变量当作 constexpr 常量来使用。但如希望严谨表达意图，仍建议使用 constexpr 来声明常量。

    int sqr(int x) { return x * x; } // 普通函数
    const int sqr_c(const int x) { return x * x; } // const函数
    constexpr int sqr_ce(const int x) { return x * x; } // constexpr函数
    consteval int sqr_cv(const int x) { return x * x; } // consteval函数

数组¶

C++虽然支持C风格的数组 int arr[10]; ，但是不推荐使用这种方式来声明数组。

在C++中，数组一般使用 std::array 和 std::vector 来声明。它们分别表示静态数组和动态数组。

静态数组¶

静态数组的大小在编译时确定，不能动态改变。它的基本格式如下：

#include <array>  // 引入数组库
array<int, 10> arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // 声明一个包含10个整数的数组
cout << arr[0] << endl; // 访问数组的第一个元素

这东西的实现和C风格数组相似，但一个重要的区别是：它是一个复杂类，而不是基本类型，有很多方法能够操作；另一个重要的区别是，在作为函数参数传递时，它不会退化为指针，从而避免了信息丢失的问题。

也就是说：

void foo(array<int, 10> arr) {
    cout << arr.size() << endl; // 可以获取数组的大小
}

void bar(int arr[10]) {
    cout << sizeof(arr) / sizeof(arr[0]) << endl; // 这里会输出错误的结果，因为arr退化为指针，sizeof(arr)得到的是指针大小而非数组大小
}

动态数组¶

动态数组的大小可以在运行时确定，可以动态改变。它的基本格式如下：

#include <vector>  // 引入向量库
vector<int> vec; // 声明一个空的动态数组
vec.push_back(1); // 向数组末尾添加一个元素1
vec.push_back(2); // 向数组末尾添加一个元素2
cout << vec[0] << endl; // 访问数组的第一个元素
cout << vec.size() << endl; // 获取数组的大小
vec.pop_back(); // 删除数组末尾的元素
vec.remove(0); // 删除数组中值为0的元素

动态数组的实现和静态数组类似，也是一个复杂类，有很多方法能够操作。它的大小可以动态改变，因此非常灵活，但性能上有较大的损失，在大型数组上比array慢一倍；但数组如果太大又不得不使用动态数组，否则栈空间不够用。

使用vector能够避免和C一样用malloc和free来直接操作内存，省心省力。

动态数组的扩容机制是一个值得研究的话题。当动态数组的容量不足以容纳新添加的元素时，通常会进行扩容操作。扩容的过程一般包括以下几个步骤： 1. 分配一块更大的内存空间，通常是当前容量的两倍。 1. 将原有元素从旧内存空间复制到新内存空间。 1. 释放旧的内存空间。 1. 更新动态数组的内部指针和容量信息。 这种扩容策略能够在保证动态数组性能的同时，减少内存分配的次数，从而提高整体效率。不过需要注意的是，扩容操作可能会导致内存碎片化，因此在频繁添加和删除元素的场景下，可能需要考虑其他数据结构（例如链表）来替代动态数组。

堆和栈¶

在C++中，变量的内存分配主要有两种方式：栈（stack）和堆（heap）。栈是一种后进先出（LIFO）的数据结构，适用于存储局部变量和函数调用信息；堆则是一种动态分配的内存区域，适用于存储需要在运行时动态创建和销毁的对象。

栈内存的分配和释放由编译器自动管理，当函数调用时，局部变量会被压入栈中；当函数返回时，这些变量会被自动弹出栈。栈内存的分配速度较快，但空间有限，通常只有几MB到几十MB。

堆内存的分配和释放需要程序员手动管理，使用 new 关键字分配内存，使用 delete 关键字释放内存。堆内存的空间较大，可以达到几GB，但分配和释放的速度较慢，且容易导致内存泄漏和碎片化问题。

字符串¶

C++风格的字符串类型是 std::string ，它可以存储一串字符。字符串的基本格式如下：

#include <string>   // 引入字符串库
string str = "Hello, World!";

字符串的本质是一个数组，存储了一串字符（C风格的字符串正是char[]）。我们可以通过索引来访问字符串中的字符，例如str[0]表示第一个字符，str[1]表示第二个字符，以此类推。

字符串的长度可以通过 str.length() 方法来获取。除此以外，还有很多字符串操作方法，例如 str.substr() （获取子串）、 str.find() （查找子串）等。

字符串是一个复杂类，和以上提到的所有数据类型都有区别。具体为什么是“复杂类”，这涉及到C++的面向对象编程（OOP）特性。我们会在后续章节中详细介绍。

结构体、联合体¶

C++的结构体和联合体与C中的略有区别。

例如，我们可以声明一个表示学生的结构体：

struct Student {
    string name;  // 学生姓名
    int age;      // 学生年龄
    double gpa;   // 学生绩点
};

Student student1;  // 声明一个学生变量
student1.name = "Alice";  // 设置学生姓名
student1.age = 20;  // 设置学生年龄
student1.gpa = 3.5;  // 设置学生绩点
cout << "Name: " << student1.name << ", Age: "
     << student1.age << ", GPA: " << student1.gpa << endl;

以上内容很好地展示了怎么定义、声明、使用一个结构体。结构体的成员可以通过点（.）运算符来访问，例如 student1.name 表示学生1的姓名。可以看到，不需要再像C语言一样，定义起来那么复杂。联合体也类似，这里不再赘述了。

C++结构体、联合体的内存结构和C语言中的是一样的，都是按照成员的顺序依次存储在内存中的。

另一个非常重要的不同是：C++结构体和联合体可以包含方法（函数），而C语言中的结构体和联合体只能包含数据成员。这使得C++的结构体和联合体更加强大和灵活，可以实现朴素的面向对象编程（OOP）特性，如：

struct Student {
    string name;  // 学生姓名
    int age;      // 学生年龄
    double gpa;   // 学生绩点
    void printInfo() {  // 成员方法，打印学生信息
        cout << "Name: " << name << ", Age: "
             << age << ", GPA: " << gpa << endl;
    }
};

Student student1;  // 声明一个学生变量
student1.name = "Alice";  // 设置学生姓名
student1.age = 20;  // 设置学生年龄
student1.gpa = 3.5;  // 设置学生绩点
student1.printInfo();  // 调用成员方法，打印学生信息

枚举¶

枚举是一个可以存储一组命名常量的变量。

枚举有两种类型，一种是传统无作用域枚举 enum ，另一种是C++11引入的有作用域枚举 enum class （也叫强枚举）。它们的区别在于，传统无作用域枚举的常量可以直接访问，枚举名和枚举值都泄漏到所在的作用域；而有作用域枚举的常量需要通过枚举名来访问。

传统无作用域枚举的基本格式如下：

    enum Color { RED, GREEN=5, BLUE };

Color color = RED; // 正统调用，color的值为0
int n = (int)RED; // 正统调用，n的值为0
int n = RED; // 不报错，n的值为0
Color c = 7; // 不报错，但是c的值不是RED、GREEN、BLUE中的任何一个，属于有效但未命名的值

有作用域枚举的基本格式如下：

    enum class Color : std::uint8_t { RED, GREEN=5, BLUE };

Color color = Color::RED; // 正确，color的值为Color::RED
int n = Color::RED; // 报错，不能将Color类型赋值给int类型
Color c = 6; // 报错，不能将int类型赋值给Color类型
int n = static_cast<int>(Color::RED); // 正确，n的值为0

枚举作为一个数据类型很笨，不仅没有任何方法，也不能进行运算，唯一的作用是定义一组常量，便于阅读；在 switch 语句中的使用较为多见。而剩下的很多方法，都不得不手动定义。

例如下列代码中，我们定义了一个枚举的遍历方法：

enum class Color : std::uint8_t {
    FIRST=RED,
    RED=0,
    GREEN=1,
    BLUE=2,
    LAST=BLUE
};

for (Color c = Color::FIRST; c <= Color::LAST; c = static_cast<Color>(static_cast<int>(c) + 1)) {
    // 遍历 Color 枚举的所有值
}

智能指针（穿了衣服版）¶

我们已经知道C风格的指针是什么了。C++中虽然也能和C一样使用“裸指针”，但是不推荐这么做。C++引入了智能指针的概念，来帮助我们更好地管理内存，不需要再手动malloc/free了。

智能指针有三个⁷主要类型。这三个主要类型都定义在<memory> 头文件中，分别是： - std::unique_ptr ：表示独占所有权的强引用智能指针，一个对象只能有一个 unique_ptr 指向它。当这个 unique_ptr 被销毁时，所指向的对象也会被自动释放。 - std::shared_ptr ：表示共享所有权的强引用智能指针，一个对象可以有多个 shared_ptr 指向它。对象会在最后一个指向它的 shared_ptr 被销毁时自动释放。 - std::weak_ptr ：表示弱引用的智能指针，不拥有对象的所有权。它通常与 shared_ptr 一起使用，用于解决循环引用的问题。

void foo() {    
    int a = 42; // 创建一个整数对象，a拥有它的所有权
    int* ptr = new int(42); // 创建一个整数对象，ptr拥有它的所有权
    delete ptr; // 释放ptr指向的整数对象
}

例如：

void foo(){
    auto ptr = std::make_unique<int>(42); // 创建一个unique_ptr，指向一个整数42
    std::cout << *ptr << std::endl; // 输出42
} // ptr超出作用域，所指向的整数自动释放

void bar(){
    auto ptr1 = std::make_shared<int>(42); // 创建一个shared_ptr，指向一个整数42
    {
        auto ptr2 = ptr1; // 共享所有权
        std::cout << *ptr2 << std::endl; // 输出42
    } // ptr2超出作用域，但整数不会释放，因为ptr1仍然指向它
    std::cout << *ptr1 << std::endl; // 输出42
} // ptr1超出作用域，所指向的整数自动释放

auto ptr1 = std::make_unique<int>(42); // 创建一个unique_ptr，指向一个整数42
auto ptr2 = std::make_shared<int>(42); // 创建一个shared_ptr，指向一个整数42

struct Node {
    int value;
    std::shared_ptr<Node> next; // 直接定义的shared_ptr，也是好的用法
    Node(int val) : value(val), next(nullptr) {}
};

而 weak_ptr 的使用则更为复杂一些，通常用于解决循环引用的问题。例如：

#include <iostream>
#include <memory>
#include <string>
using namespace std;
struct Node {
    string name;
    shared_ptr<Node> next; // 强引用，可能导致循环引用
    weak_ptr<Node> prev;   // 弱引用，避免循环引用

    Node(const string& n) : name(n), next(nullptr), prev() {}
};
class List{
public:
    shared_ptr<Node> head;
    shared_ptr<Node> tail;
    ... // 其他方法
}

struct Node {
    string name;
    shared_ptr<Node> next; // 强引用，可能导致循环引用
    shared_ptr<Node> prev; // 强引用，可能导致循环引用
}

这是写了一个双向链表节点的例子。注意其中的 next 是强引用，而 prev 是弱引用。这样可以避免循环引用的问题，从而防止内存泄漏。这个指针在多线程编程中也很有用，可以安全地访问共享资源。当然，我们一般不去主动构造一个没有配合的弱引用，弱引用大多都是依附于共享强引用而存在的。

而数组中也不再建议使用指针来访问了，改为统一使用STL容器，例如 std::vector 、 std::array 的迭代器。于是，裸指针在C++中基本光荣退休。至于迭代器是啥，我们会在后续章节中详细介绍。

基本上，我们可把使用哪种指针的决策流程总结如下： - 不共享所有权，使用 std::unique_ptr 。这是99%的情况。 - 共享所有权且肯定没有循环引用，使用 std::shared_ptr 。 - 共享所有权且可能有循环引用，使用 std::shared_ptr 和 std::weak_ptr ，后者用于打破循环引用。 - 数组？使用 std::vector 、 std::array 等STL容器，而非指针。

C++的智能指针极大地简化了内存管理，减少了内存泄漏和悬空指针等问题的发生。推荐大家在C++编程中尽量使用智能指针，而不是裸指针。

C++独占的特性¶

上述内容中，就算是 std::array 和智能指针，实际上都能在C中找到影子，在C中也可以较为容易地实现这些功能。但是，C++中也有一些独占的特性，是C中很难或无法实现的。下面介绍几个重要的C++独占特性。

命名空间¶

我们知道，一个软件还是程序，可能由很多人来完成。为了方便，每一个人都有可能定义自己的东西，例如功能（函数）、数据（变量）等。那么，如果两个人给自己不同的东西起了同样的名字怎么办？这时，电脑就无法区分它们了。

一个简单的方法是加强沟通，减少重名的可能性。但是，这样做并不现实。有的项目可能有数百人参与，沟通成本过高；有的项目是给下游使用的，这时又不可能沟通。这个问题非常棘手。

为了解决这个问题，C++引入了命名空间的概念。命名空间可以参照我们说过的虚拟环境概念来理解：每一个人都有自己的一个沙盒，在自己的沙盒里可以随便起名字，互不干扰。这样一来，即使两个人起了同样的名字，也不会冲突，因为它们属于不同的命名空间。

    namespace Alice {
        int value = 42; // 数据（变量）
        void show() {   // 功能（方法）
            std::cout << "Alice's value: " << value << std::endl;
        }
    }
    namespace Bob {
        int value = 100; // 数据（变量）
        void show() {    // 功能（方法）
            std::cout << "Bob's value: " << value << std::endl;
        }
    }

但是新的问题又来了：有时候，别人在他们的命名空间里写了一些东西，而这些东西又是我们想要的。为了方便起见，肯定不能写第二遍。那么，我们该怎么办呢？可以这样写：

    Alice::show(); // 调用Alice命名空间中的show函数
    Bob::show();   // 调用Bob命名空间中的show函数

为了帮助我们更好的开发，C++提供了一些东西减少我们的重复劳动。这些东西被C++放在了“标准”命名空间中，也就是 std 。诸如 cout 、 cin 、 endl 等都在这个命名空间中。因此，我们在使用这些东西的时候，必须加上 std:: 前缀，例如 std::cout 、 std::cin 、 std::endl 等。

为了方便起见，可以使用 using namespace std; 来引入整个 std 命名空间，这样在这个文件以及其下游文件中，就可以直接使用标准空间中的东西，而不需要加上 std:: 前缀了。但是这样做也是有风险的：这会把整个标准命名空间都引进来，容易导致重名冲突等问题。

举例：假设你自己写了一个swap函数，然后在你的头文件中使用了 using namespace std; ，那么当别人引入你的头文件时，标准命名空间中的 std::swap 函数也会被引入，从而导致重名冲突，最终引发编译错误。

命名空间的编译原理¶

命名空间符号在编译时是在符号前加上命名空间前缀来实现的。例如， std::cout 在编译时会被转换为类似 _ZSt4cout 这样的符号名（具体名称可能因编译器而异）。这样做的好处是可以避免不同命名空间中的符号冲突。

引用¶

引用是C++中的一个重要特性，其核心任务是让变量有第二个名字，但不管理生命周期。引用不能为空、不能重新指向、不拥有对象，但在函数参数传递、返回值等场景中极为有用。

左值引用¶

默认提到引用，指的就是左值引用。

引用的基本格式如下：

类型& 引用名 = 原变量名;

int a = 10;  // 声明一个整数变量
int& ref = a;  // 声明一个整数的引用
cout << "a: " << a << ", ref: " << ref << endl;
ref = 20;  // 修改引用的值
cout << "a: " << a << ", ref: " << ref << endl;

以上代码的意思是：声明一个名为ref的引用，它是变量a的别名。我们可以通过ref来访问a。当我们修改ref的值时，实际上也修改了a的值。

而在函数形参中，引用是较大形参传递的首选。

void draw(const Widget& w) {
    // 使用w进行绘制操作
}

void update(Widget& w) {
    // 修改w的状态
}

为什么不用智能指针？因为智能指针管理生命周期，而引用不管理生命周期。引用更轻量级，适合用于函数参数传递和返回值等场景。除非你要转移或重置指针本身，否则不需要使用 unique_ptr ；除非你要延长对象寿命（如缓存、异步任务等），否则不需要使用 shared_ptr 。

但引用也不是万能的：容器里就不要存引用了，这是值（具体对象）和多态基类（智能指针）的天下，引用请靠边站（不是对象，存不了）。

右值引用¶

右值引用是C++11引入的一种新特性，绑定的是“马上要死”的临时变量，这一点和左值引用绑定的“长期活着”的变量不同。

一般，有自己名字的变量，要引用全都是左值引用；而没有自己名字的临时变量，则要用右值引用。另，std::move 可以把左值强制转换为右值引用，从而实现移动语义。那什么是“移动语义”呢？后面会讲。

举例：

int x = 1; // x 是一个左值，1 是一个右值
int& lref = x; // 左值引用，绑定到左值 x
int&& rref = 2; // 右值引用，绑定到右值 2
int&& rref2 = x // 错误，不能将左值绑定到右值引用
int&& rref3 = x + 3; // 合法，x + 3 是一个右值
rref = x + 3; // 合法，x + 3 是一个右值

那么这玩意有什么用呢？

第一个用途：把拷贝变成搬运，即“移动语义”。举个例子：

    string s1 = "hello";
    string s2 = s1 + "world";

为了物尽其用，干脆把这个临时对象的资源直接搬进s2好了，不就省事了吗？这就是移动语义的核心思想。

实现移动语义需要用到右值引用，也就是说，重载：

    string(const string& other); // 拷贝构造函数
    string(string&& other); // 移动构造函数

    string(string&& other) noexcept
        : data(other.data) {    // 直接抢夺资源指针
        other.data = nullptr; // 搬家后，把原对象的指针置空，防止析构时重复释放
    }

而第二个用途就是“完美转发”。这在模板编程中非常有用，可以把参数原封不动地传递给另一个函数，而不会丢失其左值/右值属性。

template<class T>
void foo(T&& arg) {
    bar(std::forward<T>(arg)); // 完美转发
}

unique_ptr只能移动、不能拷贝的特性就是由右值引用实现的：

std::unique_ptr<int> p1 = std::make_unique<int>(5);
std::unique_ptr<int> p2 = p1;      // 拷贝构造被删除
std::unique_ptr<int> p3 = std::move(p1); // OK，移动构造

C++函数的高级特性¶

C++下定义函数的方法和C完全一致。但是，C++对函数进行了扩展，增加了一些高级特性，例如函数重载、函数默认参数值等。

C++函数的编译原理¶

C++函数在编译时会进行名称修饰（Name Mangling），这是为了支持函数重载等特性。名称修饰的过程会将函数名、参数类型、返回类型等信息编码到符号名中，从而生成一个唯一的符号名。例如，假设我们有以下两个函数：

int add(int a, int b);
double add(double a, double b);

call _Z3addii  # 对应 int add(int, int)
call _Z3adddd  # 对应 double add(double, double)

但这就会导致一个问题：如果我们需要在C++中调用C语言的函数怎么办？因为C语言不支持名称修饰，而C++支持名称修饰，这就会导致链接错误。为了解决这个问题，C++提供了 extern "C" 关键字，可以告诉编译器按照C语言的方式来处理函数名称，从而避免名称修饰。例如：

extern "C" {
    void c_function(int a);
}

函数重载¶

函数重载是C++中的一个重要特性，它允许我们定义多个同名的函数或运算符，但它们的参数列表或返回类型不同。写一个例子就好了：

struct Tensor2D{
    int x_dim, y_dim;
}
Tensor2D operator+(const Tensor2D& other) {
    // 实现加法运算
    Tensor2D result;
    result.x_dim = this->x_dim + other.x_dim;
    result.y_dim = this->y_dim + other.y_dim;
    return result;
}

除了重载运算符，还可以重载流运算符来实现自定义输入输出，重载函数实现对不同参数的处理等。重载的关键是参数列表的不同，返回类型可以相同或不同。刚才在名称修饰中，我们已经提到过，返回类型不参与名称修饰，因此不能仅通过返回类型来区分重载函数。

函数默认参数值¶

函数默认参数值是C++中的一个特性，它允许我们在函数声明时为某些参数指定默认值。如果调用函数时没有提供这些参数的值，编译器会使用默认值。

例如：

void greet(const std::string& name = "Guest") {
    std::cout << "Hello, " << name << "!" << std::endl;
}

greet(); // 输出: Hello, Guest!
greet("Alice"); // 输出: Hello, Alice!

需要注意的是，函数缺省的参数必须从右向左依次定义，不能在中间或左侧定义缺省参数。这一点和C#、Python等语言不同，必须牢记。例如，下面的代码是错误的：

void foo(int a = 10, int b); // 错误，b没有默认值

void foo(int a, int b = 20); // 正确

而在函数声明和定义分离的情况下，默认参数值只能在函数声明中指定，而不能在函数定义中指定。例如：

void greet(const std::string& name = "Guest"); // 函数声明
void greet(const std::string& name) { // 函数定义
    std::cout << "Hello, " << name << "!" << std::endl;
}

类型推断¶

类型推断是C++11引入的一个特性，它允许编译器根据变量的初始值自动推断变量的类型。使用类型推断可以使代码更简洁、更易读。 类型推断的基本语法是使用 auto 关键字：

auto x = 5;  // 编译器推断x的类型为int
auto y = 3.14;  // 编译器推断y的类型为double
auto str = "Hello, World!";  // 编译器推断str的类型为const char*

必须注意，auto 不是一个类型，而是一个占位符，编译器会根据变量的初始值来推断出一个具体的类型。因此，使用 auto 时必须确保变量有一个明确的初始值，否则编译器无法推断出类型，会导致编译错误。我们也绝对不能把 auto 当成一个万能的类型来使用，例如：

auto x; // 错误，缺少初始值，编译器无法推断出类型

auto x = 5; // 正确，编译器推断x的类型为int
x = "Hello"; // 错误，x的类型已经被推断为int，不能赋值为字符串

但是依然需要注意：std::variant 和 std::any 以及模板虽然可以实现类型的灵活性，但它们也不是动态类型，他们仅仅是一个盒子，里面可以装不同类型的东西，但这个盒子本身的类型是确定的。具体使用见C++高级特性那一章。

因此，我们需要根据实际需求来选择合适的工具，而不是滥用 auto 或者其他类型灵活性的工具。

类型别名¶

类型别名是C就有的一个特性，但是C++11对它进行了扩展。类型别名允许我们为现有的类型创建一个新的名称，使得代码更易读。

C++中可以使用 using 关键字来定义类型别名。

using ll = long long;  // 定义一个长整型的别名
using IntVector = std::vector<int>;  // 定义一个整型向量的别名
IntVector v = {1, 2, 3};  // 使用别名创建一个整型向量

如果使用C风格的语法，则是：

typedef long long ll;  // 定义一个长整型的别名
typedef std::vector<int> IntVector;  // 定义一个整型向量的别名
IntVector v = {1, 2, 3};  // 使用别名创建一个整型向量

using和typedef几乎没有什么区别，只不过using的语法更加符合直觉（用这个作为这个的别名），类似于声明变量；而typedef则更像是定义一个宏（虽然实际上不是），阅读方向是反直觉的。

using的另一个独特之处是可以用于模板类型的别名：

template <typename T>
using Matrix = std::vector<std::vector<T>>;  // 定义一个二维向量的别名
Matrix<int> m = {{1, 2}, {3, 4}};  // 使用别名创建一个二维向量
Matrix<double> dm = {{1.1, 2.2}, {3.3, 4.4}};  // 使用别名创建一个二维向量

类型强转¶

有时候，在编程中我们需要将一个类型转化成另一个类型，以满足特定的需求。类型强转包括两类：隐式转换和显式转换。隐式转换是编译器自动进行的，而显式转换则需要程序员手动指定。

在一般情况下，隐式转换是安全的，不会导致数据丢失或错误。然而，有些情况下隐式转换可能会引发诸如精度等问题。默认能够进行的隐式转换包括以下几步： 1. 标准整形提升：所有比 int 小的整型（如 char 、 short ）会被提升为 int 或 unsigned int 。 1. 整形等级转换：提升之后，如果类型仍不匹配，编译器会尝试将较小的整型转换为较大的整型（如 int 转为 long ）。 1. 浮点等级转换：如果涉及浮点数，编译器会尝试将较小的浮点类型转换为较大的浮点类型（如 float 转为 double ）。 1. 混合类别转换：如果操作数类型不同，编译器会尝试将整型转换为浮点型，以避免精度丢失。转换后的类型为与浮点数的类型相同的浮点类型。 1. 其他转换：包括数组到指针、函数到指针、空指针常量、枚举到整型⁹、类类型的转换¹⁰等。

在C++中，类型强转被拆成了四个方式（四大金刚）： - static_cast ：编译期安全的强转，包括数值提升/截断，枚举/整型，子类指针转父类指针、void转型等。它是最常用的类型转换方式，适用于大多数情况。 - dynamic_cast ：运行时安全的强转，几乎仅用于父类指针转子类指针。它会在运行时检查类型安全，如果转换不安全，则返回nullptr。它只能用于有虚函数的类。同时，它是唯一一个在运行时检查强转安全性的转换方式。 - const_cast ：常变转换，其他啥都不干。它是唯一一个能去const的转换方式。 - reinterpret_cast ：按位重解释*，用于int指针互转、void指针互转、无关类指针互转等。它是危险的转换方式，仅在编译期做极弱的检查。它也可以用于转引用，但是如果转不了不会返回空引用¹¹而是报错。除非我们知道在干什么，否则不要使用它。

举例说明：

#include <iostream>
using namespace std;

double d = 3.14;
int a = static_cast<int>(d);  // 使用static_cast进行数值转换
int a = (int)d;  // C风格的强转，也行

const int c = 42;
int* p = const_cast<int*>(&c);  // 使用const_cast去掉const属性
// *p = 100; // 但是修改原变量的值是个UB

class Base;
class Derived : public Base;
// 注意：以上两行代码仅用于说明继承关系，实际过不了编译
Base* b = new Derived();
Derived* d = dynamic_cast<Derived*>(b);  // 使用dynamic_cast将父类指针转为子类
Derived* d = static_cast<Derived*>(b);  // 使用static_cast转型（不安全，但是能过编译）

uintptr_t ptr = reinterpret_cast<uintptr_t>(b);  // 使用reinterpret_cast将指针转换为整数

那么有些同学可能会问：为什么C++要提供这么多种类型强转？难道C风格的强转不行吗？没错，两种代码实际上都可以用。不过，C风格的强转像个大锤，一口气把任何东西都能砸成目标东西，但是它可不带管安全性的；而C++强转四大金刚分别是四把精确的手术刀，功能单一、语义明确，编译器会帮助你把关；要是危险或者出错了，编译器给你兜底。这样就可以避免很多潜在的错误。

C语言的强转实际上会先尝试常变转换，再尝试数值转换，要是不行就常变数值一起转，还不行就按位重解释。所以说这玩意实际上是四合一，不过也导致它隐形语义极为复杂、易于出错，出错了也不容易搜索定位。

const volatile void* v = ...;
int* bad = (int*)v;  // C风格的强转，实际上一口气把const和volatile都去掉了，顺便做了个按位重解释

所以说，我们非常建议优先使用C++四大强转做显式强转。我们非常不建议在C++中使用旧式风格的强转，除非要做向下兼容等不这么做不行的事情。

Lambda表达式¶

Lambda表达式是C++11引入的一个特性，它允许我们在代码中定义匿名函数。Lambda表达式可以捕获外部变量，并且可以作为参数传递给其他函数。它的基本语法如下：

[捕获列表](参数列表) -> 返回类型 {
    // 函数体
}

例如：

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {1, 2, 3, 4, 5};
    int sum = 0;
    for_each(nums.begin(), nums.end(), [&sum](int n) { sum += n; });  // 使用Lambda表达式计算总和
    cout << "Sum: " << sum << endl;  // 输出结果
    return 0;
}

Lambda表达式的类型是特殊的。它是一个独一无二的、不可命名的、由编译器生成的闭包类型。该类是匿名的，每一个Lambda表达式都会生成一个独一无二的类。这个类会重载 operator() ，使得Lambda表达式可以像函数一样被调用。其类型是一个确定的类型，但是该类型既不能命名也不能写出。Lambda表达式也不是一个函数指针，但是可以隐式转换为函数指针（前提是没有捕获任何外部变量）。

例如下列代码：

auto lambda = [](int x) { return x * x; };

class __lambda_unique_name {
public:
    int operator()(int x) const { return x * x; }
};

有些时候，我们需要对其进行存储或传递，此时需要声明其类型。此时， auto 是好的实践之一。但是如果要传递给函数怎么办呢？为了这个目的，C++11引入了 std::function 模板类，它可以存储任何可调用对象，包括Lambda表达式、函数指针、函数对象等。使用 std::function 可以方便地传递和存储Lambda表达式。

#include <iostream>
#include <functional>  // 包含std::function的头文件
using namespace std;

void applyFunction(const function<int(int)>& func, int value) {
    cout << "Result: " << func(value) << endl;  // 调用传入的函数并输出结果
}

int main() {
    auto lambda = [](int x) { return x * x; };  // 定义一个Lambda表达式
    applyFunction(lambda, 5);  // 将Lambda表达式传递给函数
    return 0;
}

    using FuncPtr = int(*)(int);  // 定义一个函数指针类型
    FuncPtr func = [](int x) { return x * x; };  // 将Lambda表达式转换为函数指针
    cout << "Result: " << func(5) << endl;  // 调用函数指针并输出结果

多文件编程¶

头文件和源文件¶

头文件是一些预先写好的代码的集合。通过包含头文件，我们可以使用这些预先写好的代码，而不需要重新编写它们。头文件的扩展名通常是 .h 或 .hpp 。引入头文件只需要在文件的开头使用 #include 指令即可。

头文件有两种类型：标准库头文件和自定义头文件。标准库头文件是C++标准库提供的头文件，通常使用尖括号括起来，例如 <iostream> 、 <vector> 等，这样会先在系统路径中查找，再去当前路径中查找；自定义头文件是用户自己编写的头文件，通常使用双引号括起来，例如 "myheader.h" ，这样会先在当前路径中查找，再去系统路径中查找。

与“头文件”相对应的是源文件，它们通常包含程序的主要逻辑和实现代码。源文件的扩展名通常是 .cpp 、 .cxx 或 .cc 。源文件可以包含头文件，并且可以定义函数、类和变量等。

// 这是一个源文件
#include <iostream>  // 引入标准库头文件
#include "myheader.h"  // 引入自定义头文件

int main() {
    // 使用头文件中的代码
    return 0;
}

自己写个头文件¶

有时候，我们自己需要写一个项目，这个项目代码量较大，可能有数千行。此时，我们需要多文件编程，以便于代码的组织和管理。

C++的多文件编程，文件结构通常是这样的：

project/
    main.cpp // 主要的程序入口
    module1.cpp // 模块1的实现
    module1.h // 模块1的头文件
    module2.cpp // 模块2的实现
    module2.h // 模块2的头文件
    ... 这里可能还有其他文件

自己写头文件时，通常包括以下内容： - 声明函数、类、变量等的接口。 - 使用预处理指令防止重复包含。 例如，我们可以编写一个简单的头文件 myheader.h ，包含一个函数的声明和定义：

#ifndef MYHEADER_H  // 编译守卫，防止重复包含
#define MYHEADER_H
int add(int, int);  // 函数声明
#endif

#include "myheader.h"  // 引入头文件
int add(int a, int b) {  // 函数定义
    return a + b;
}

#include <iostream>
#include "myheader.h"  // 引入头文件

int main() {
    int x = 5;
    int y = 10;
    int sum = add(x, y);  // 调用add函数
    std::cout << "Sum: " << sum << std::endl;  // 输出结果
    return 0;
}

g++ main.cpp myheader.cpp -o myprogram

如果源文件数量过多，那么就不应该使用诸如gcc等工具手动地编译。此时，应该使用 Makefile 、 CMake 、 XMake 、 Conan 等构建工具来管理编译过程。关于后三个构建工具的使用，将在下一章中介绍。

再强调一遍：在多文件编程中，不建议使用 using namespace std; 。尤其是头文件，严格禁止在头文件中使用该语句！

#include <iostream>
int main() {
    auto x;              
    x = 42;
    std::cout << x << '\n';
}

#include <iostream>
int main() {
    int a[5] = {1,2,3,4,5};
    for (auto v : a)          
        v += 10;
    for (auto v : a)
        std::cout << v << ' '; // 输出不符合预期的原因是？
}

// a.cpp
int add(int a, int b = 0) { return a + b; }

// main.cpp
int add(int a, int b = 0);   // 声明
int main() {
    std::cout << add(5) << '\n';
}

#include <iostream>
constexpr int sq(int x) { return x * x; }
int main() {
    int n;
    std::cin >> n;
    constexpr int val = sq(n);
    std::cout << val << '\n';
}

#include <cstdio>
#include <iostream>
int main() {
    std::cout << "C++ ";
    printf("C\n");          // 可能先打印 C
}

#include <iostream>
int f(int x) { return x + 1; }
int f(void* p) { return 2; }
int main() {
    std::cout << f(nullptr) << '\n'; // 输出不确定
}

int add(int a, int b = 0);