Introduction

该文档记录部分(不太准确的)C++知识，以及一些面试题。

大部分知识均不完善，不是手册，仅仅作为笔记。

Tip

如果感兴趣的话，可以提交你自己的知识到仓库中。

C++语言面试题汇总

1. volatile关键字有什么作用？

   • 数据类型-基本数据类型-修饰符-volatile

2. const和constexpr关键字有什么作用，有什么区别？

   • 数据类型-基本数据类型-修饰符-const
   • 数据类型-基本数据类型-修饰符-constexpr

3. static关键字有什么作用？和C语言中的有什么区别？

   • 数据类型-基本数据类型-修饰符-static

4. extern有什么作用？

   • 数据类型-基本数据类型-修饰符-extern

5. 面向对象的三大特征是什么？

   • 类与对象-三大特征

6. typedef和define有什么区别？

   • 预处理器-define
   • 派生数据类型-typedef
   • tips-typedef和define有什么区别

7. 指针常量与常量指针各是什么，二者有什么区别？

   • 变量与常量-常量指针与指向常量的指针

C++基础知识

C++基础部分包括语言的核心语法与程序结构，理解从“源代码到可执行程序”的基本过程。本部分将介绍变量与常量、数据类型、运算符、控制结构、函数、数组、指针、结构体、类与对象等基础概念。

掌握这些内容后，就能编写出功能完整、逻辑清晰的小型程序，理解程序的输入输出、流程控制和内存中数据的基本表示方式。C++基础知识不仅是学习更复杂特性的起点，也是理解程序设计思想与计算机工作原理的重要桥梁。

本章内容

运行环境与基础概念

初识C++应知必会的基础概念。

C++ 程序结构（Program Structure）

引言

C++ 程序的结构决定了它的组织方式、执行流程和可维护性。 从最小的“Hello, World!”程序开始，我们可以认识一个 C++ 程序通常包含的头文件、命名空间、函数定义、语句块等组成部分。

一个最小可运行的 C++ 程序

#include <iostream>   // 头文件：引入输入输出库
using namespace std;  // 使用标准命名空间

int main() {          // 主函数：程序执行入口
    cout << "Hello, World!" << endl;  // 输出语句
    return 0;         // 返回值：表示程序是否成功结束
}

程序执行流程说明

程序的基本组成部分

一个完整的 C++ 程序通常由以下几个部分组成：

1. 预处理指令（Preprocessor Directives） 在编译前由预处理器执行，例如：

   #include <iostream>
   #define PI 3.14159
   

2. 命名空间（Namespace） 命名空间用于避免名称冲突：

   namespace myspace {
       int x = 10;
   }
   

3. 主函数 main() 所有可执行 C++ 程序都必须有且仅有一个 main() 函数。

4. 函数定义（Functions） 函数是代码逻辑的基本单元，示例：

   int add(int a, int b) {
       return a + b;
   }
   

5. 变量与语句（Variables & Statements） 程序的逻辑通过语句执行，通过变量存储数据。

   int sum = add(2, 3);
   cout << sum << endl;
   

C++ 程序的执行入口

• 程序从 main() 函数开始执行。

• main() 的返回值会传递给操作系统。

• 常见的两种形式：

  int main() {
      // 无参数版本
      return 0;
  }
  
  int main(int argc, char* argv[]) {
      // 带命令行参数的版本
      // argc 表示参数数量
      // argv 表示参数数组
      return 0;
  }
  

程序的语句块与作用域

语句块使用花括号 {} 表示，定义一个新的作用域（scope）：

int x = 10;
{
    int x = 20;   // 内层作用域的 x 隐藏外层变量
    cout << x;    // 输出 20
}
cout << x;        // 输出 10

作用域是 C++ 的重要概念，影响变量的可见性与生命周期。

程序结构的逻辑层次（层级模型）

这是一种从外到内的逻辑组织结构。良好的层级划分有助于程序的模块化。

程序文件结构（大型项目）

在真实项目中，一个 C++ 程序通常被拆分为多个文件：

project/
├── main.cpp        // 程序入口
├── math/
│   ├── add.cpp
│   └── add.h
└── utils/
    ├── log.cpp
    └── log.h

通过 头文件 (.h/.hpp) 声明接口，源文件 (.cpp) 实现功能：

• add.h

  #ifndef ADD_H
  #define ADD_H
  
  int add(int a, int b);
  
  #endif
  

• add.cpp

  #include "add.h"
  int add(int a, int b) {
      return a + b;
  }
  

• main.cpp

  #include <iostream>
  #include "add.h"
  
  int main() {
      std::cout << add(3, 4) << std::endl;
      return 0;
  }
  

大型工程中，通常直接或间接地使用Cmake或make进行编译和项目管理。

预处理器 (Preprocessor)

C++ 预处理器（Preprocessor）是 C++ 编译过程中的第一阶段。它负责处理源代码中所有以 # 开头的指令，在实际编译（生成目标代码）之前对源代码进行文本替换、文件包含、条件编译等操作。

一、预处理指令 (Directives)

预处理指令以 # 符号开头，并且占据一行。它们不是 C++ 语句，因此不需要以分号 (;) 结尾。

二、宏定义 (#define)

宏定义是预处理器最重要的功能之一，它执行的是文本替换。

1. 对象式宏 (Object-like Macros) - 定义常量

   #define BUFFER_SIZE 1024
   // 预处理后：所有 BUFFER_SIZE 都会被替换为 1024
   

2. 函数式宏 (Function-like Macros) - 定义类似函数的替换

   使用时注意：必须在参数和整个宏体周围加上括号，以避免运算符优先级问题。

   #define SQUARE(x) ( (x) * (x) )
   
   // 错误示例：#define SQUARE(x) x * x
   // SQUARE(1 + 2) -> 1 + 2 * 1 + 2 -> 5 (错误!)
   // 正确示例：SQUARE(1 + 2) -> ( (1 + 2) * (1 + 2) ) -> 9 (正确!)
   

   最佳实践: 除非必要，在 C++ 中应使用 const 或 constexpr 变量代替对象式宏，使用 内联函数 (inline) 或 模板 代替函数式宏，以获得类型检查和更好的可读性。

3. 宏的特殊操作符

   • # (字符串化运算符 / Stringizing Operator)：将宏参数转换为字符串字面值。

     #define MESSAGE(x) #x
     // std::cout << MESSAGE(Hello World);  ->  输出: Hello World
     

   • ## (连接运算符 / Token-Pasting Operator)：连接两个宏标记（token），形成一个新的标记。

     #define GLUE(a, b) a ## b
     // int GLUE(my, Variable) = 10;  ->  int myVariable = 10;
     

三、文件包含 (#include)

用于将一个文件的内容插入到另一个文件中。

1. 尖括号 (<>)：用于包含标准库头文件。编译器会在标准系统路径下查找。

   #include <iostream>
   

2. 双引号 ("")：用于包含用户自定义头文件。编译器首先在当前源文件目录查找，然后才在标准系统路径下查找（具体的查找路径取决于编译器设置）。

   #include "my_header.h"
   

四、条件编译 (Conditional Compilation)

条件编译允许根据预处理器定义的条件，决定是否将一段代码发送给编译器。这对于平台移植、调试开关和头文件保护至关重要。

1. 头文件保护 (Header Guards) - 经典方式

   用于防止头文件被重复包含，导致重定义错误。

   #ifndef MY_HEADER_H // IF Not DEFined
   #define MY_HEADER_H
   
   // 头文件内容
   
   #endif // MY_HEADER_H
   

2. 基于宏的条件

   #define DEBUG_MODE // 开启调试模式
   
   // ...
   
   #ifdef DEBUG_MODE   // 如果 DEBUG_MODE 宏已定义，则编译以下代码
       std::cout << "Debugging output." << std::endl;
   #endif
   
   #ifndef RELEASE_MODE // 如果 RELEASE_MODE 宏未定义，则编译以下代码
       // ...
   #endif
   

3. 多分支条件

   #define OS_LINUX 1 // 假设在 Linux 平台编译
   
   #if OS_LINUX
       #include <unistd.h>
   #elif OS_WINDOWS
       #include <windows.h>
   #else
       #error "Unsupported OS!"
   #endif
   

   • #if 后面要求表达式求值为非零（真）或零（假）。表达式中未定义的宏会被当作零处理。
   • defined 运算符：#if defined(MACRO_NAME) 与 #ifdef MACRO_NAME 效果相似，但 defined 可以用于更复杂的布尔表达式中，例如 #if defined(A) && !defined(B)。

五、编译器特定指令 (#pragma)

#pragma 指令是一种特殊的预处理指令，用于向编译器提供特定于编译器或平台的指示。由于它们是非标准的（不属于 C++ 语言规范），因此其功能和语法可能在不同编译器之间有所不同。

1. #pragma once

   • 目的： 实现头文件保护，防止头文件被重复包含。

   • 优点： 代码更简洁，不会污染全局宏命名空间，并且大多数现代编译器（GCC, Clang, MSVC 等）都支持且执行效率更高（编译器可以直接比较文件名或路径）。

   • 用法： 放在头文件的最开始。

     // my_header.h
     #pragma once
     
     struct MyData { /* ... */ };
     

   • 对比 #ifndef：

   • #ifndef 是标准 C++ 的一部分，可移植性最高。

   • #pragma once 是事实上的行业标准，使用更方便，但技术上非标准。在新的代码中通常推荐使用它。

2. #pragma warning (主要用于 MSVC)

   • 目的： 临时修改或控制编译器警告的行为。

   • 关键语法：

   • #pragma warning( disable : 警告编号 )：禁用特定的警告。

   • #pragma warning( error : 警告编号 )：将特定的警告视为错误。

   • #pragma warning( push )：保存当前的警告状态到堆栈。

   • #pragma warning( pop )：恢复最近一次保存的警告状态。

   • 用途示例： 临时禁用第三方库中产生的警告。

     #pragma warning( push )         // 保存当前警告状态
     #pragma warning( disable : 4100 ) // 禁用 MSVC 警告 C4100 (未使用的形参)
     
     void unused_param_func(int x)
     {
         // ... code that intentionally doesn't use x
     }
     
     #pragma warning( pop )          // 恢复之前的警告状态
     

   GCC/Clang 对应功能： 它们通常使用 #pragma GCC diagnostic push/pop 和 #pragma GCC diagnostic ignored "-Wxxx"。

3. 其它特定 #pragma

   • #pragma pack(n)：指定结构体成员的对齐字节数，常用于跨平台或与硬件交互。
   • #pragma comment(...)：向目标文件中插入注释信息或链接器指令（如链接特定的库文件）。

命名空间（Namespace）

一、概念与作用

• 定义：命名空间是声明性区域，它提供了一种将代码组织成逻辑组并避免命名冲突的机制。
• 作用：
  • 将类型、函数、变量等标识符包含在一个有名称的范围（Scope）内。
  • 在大型程序中，尤其当程序包含多个库时，有效解决名称冲突问题（例如，不同库中可能存在同名的函数或变量）。

二、命名空间声明

使用 namespace 关键字来声明一个命名空间。

// 文件: MyCode.h

namespace MyNamespace {
    int value;

    void FunctionA() {
        // ...
    }

    class MyClass {
        // ...
    };
}

三、访问命名空间成员

要访问命名空间内的成员，需要使用范围解析运算符 ::。

方式一：完整限定名称（Fully Qualified Name）

在命名空间外部使用完整的名称来限定成员。

// 访问 MyNamespace 中的 value 和 FunctionA
MyNamespace::value = 10;
MyNamespace::FunctionA();

方式二：using 声明（using Declaration）

将命名空间中的特定名称引入当前作用域。

#include "MyCode.h"

// 引入 MyNamespace 中的 FunctionA
using MyNamespace::FunctionA;

void SomeOtherFunction() {
    // 此时可以直接使用 FunctionA，而不需要 MyNamespace::
    FunctionA();

    // 访问 value 仍需限定
    MyNamespace::value = 20;
}

方式三：using 指示词（using Directive）

将命名空间中的所有名称引入当前作用域。

#include "MyCode.h"

// 将 MyNamespace 中的所有名称引入
using namespace MyNamespace;

void AnotherFunction() {
    // 此时可以直接使用所有成员
    value = 30;
    FunctionA();
}

最佳实践：

1. 避免在头文件（.h 或 .hpp）中使用 using namespace 指示词，因为这会将命名空间中的所有名称带入所有包含该头文件的文件中，可能导致难以调试的名称冲突或隐藏问题。
2. 在实现文件（.cpp）的顶部或函数内部，可以使用 using namespace 指示词以简化代码。
3. 如果只使用一两个标识符，建议使用完整限定名称或using 声明。

四、命名空间的特性

1. 分散定义（Separated Definition）

命名空间可以在单个文件中的多个块中声明，也可以在多个文件中声明。编译器会将所有部分连接起来。

// 文件 A.h
namespace Utils {
    void func1();
}

// 文件 B.h
namespace Utils {
    void func2(); // 即使在不同文件，也属于同一个 Utils 命名空间
}

2. 全局命名空间（Global Namespace）

• 未在任何显式命名空间中声明的标识符属于隐式全局命名空间。

• 要显式访问全局命名空间中的标识符，可以使用没有名称的范围解析运算符 ::：

  int globalVar = 100;
  
  namespace Local {
      int globalVar = 200; // 隐藏全局变量
  
      void test() {
          int val1 = globalVar; // 使用 Local::globalVar (200)
          int val2 = ::globalVar; // 使用 全局命名空间 的 globalVar (100)
      }
  }
  

3. 嵌套命名空间（Nested Namespaces）

命名空间可以嵌套，C++17 引入了内联嵌套简化语法。

namespace Outer {
    namespace Inner {
        void innerFunc();
    } // 结束 Inner
} // 结束 Outer

// 访问方式：
Outer::Inner::innerFunc();

// C++17 简化写法：
namespace Outer::Inner {
    void anotherInnerFunc();
}

4. 匿名或未命名命名空间（Anonymous/Unnamed Namespaces）

声明一个没有名称的命名空间。

namespace {
    int MyFunc() { return 0; }
    int internalVar;
}

• 作用：未命名命名空间中的变量和函数只在当前编译单元（文件）内可见，它们具有内部链接（internal linkage），等同于在全局作用域中使用 static 关键字。
• 用途：避免在其他文件中看到变量声明，替代老式的 static 全局/函数定义。

5. 命名空间别名（Namespace Alias）

用于为过长的命名空间名称创建别名，以提高代码可读性和输入效率。

namespace VeryLongNamespaceName {
    void func();
}

// 创建别名
namespace VLNN = VeryLongNamespaceName;

// 使用别名访问
VLNN::func();

五、std 命名空间

1. std 命名空间简介

• 标准库：std 是 Standard（标准）的缩写，是 C++ 标准库（Standard Library）中所有实体（Entities）的容器。
• 内容：所有 C++ 标准库提供的类、函数、变量、模板等都被声明在 std 命名空间内。
  • 常见的例子包括：
    • 输入/输出：std::cout, std::cin, std::endl
    • 字符串：std::string
    • 容器：std::vector, std::map, std::list
    • 算法：std::sort, std::find
    • 其他：std::unique_ptr, std::exception 等。

2. 使用 std 成员

由于标准库的所有内容都在 std 命名空间内，因此需要使用前面介绍的三种方式来访问它们。

示例：完整限定名称（推荐）

这是最安全、最清晰的方式，尤其是在头文件和库代码中。

#include <iostream>

void print_message() {
    // 每次使用都需要前缀 std::
    std::cout << "Hello, C++ World!" << std::endl;
}

示例：using 声明

将特定的标准库成员引入当前作用域。

#include <iostream>
#include <vector>

using std::cout;
using std::vector;

void process_data() {
    // 可以直接使用 cout 和 vector
    cout << "Processing data..." << '\n';
    vector<int> numbers = {1, 2, 3};
    // 但 std::endl 仍需限定
    cout << "Done." << std::endl;
}

示例：using 指示词

将整个 std 命名空间引入当前作用域。

#include <iostream>

// 将所有 std:: 成员引入
using namespace std;

void dangerous_example() {
    // 可以直接使用 cout 和 endl
    cout << "This is quick but potentially risky." << endl;

    // 风险：如果用户定义了名为 'cout' 的变量，则会发生命名冲突或名称隐藏。
    // int cout = 100; // 错误：在某些编译器上可能导致二义性或隐藏 std::cout
}

3. C 库头文件的兼容性

C++ 标准库也包含了 C 语言的标准库函数（如 printf, malloc 等）。

• C++ 风格：使用 c 前缀和不带 .h 后缀的头文件（例如，<cmath> 对应 C 语言的 <math.h>）。
  • 在 C++ 风格的头文件中，所有函数和类型都位于 std:: 命名空间中。
• C 风格（兼容性）：使用带 .h 后缀的头文件（例如，<math.h>）。
  • 为了兼容性，在 C 风格的头文件中，函数和类型通常同时位于全局命名空间和 std:: 命名空间中。

C++ 程序的编译与运行（Compilation and Execution）

引言

C++ 是一种 编译型语言（compiled language）。 这意味着在执行程序之前，必须先将源代码 (.cpp) 转换为计算机可以理解的机器指令（可执行文件）。

整个过程通常包括以下几个阶段：

源代码 (.cpp)
   ↓
预处理（Preprocessing）
   ↓
编译（Compilation）
   ↓
汇编（Assembly）
   ↓
链接（Linking）
   ↓
可执行文件（Executable）
   ↓
运行（Execution）

编译过程的四个主要阶段

可以通过这些命令观察 C++ 源码在每个阶段的输出，理解“编译器到底做了什么”。

完整编译命令示例

最常用的编译命令只需一行：

g++ main.cpp -o main

• g++：GNU C++ 编译器（GCC 的 C++ 前端）
• main.cpp：源文件
• -o main：指定输出文件名（不写则默认为 a.out）

运行程序：

./main

输出：

Hello, World!

多文件编译示例

大型项目通常由多个源文件组成：

project/
├── main.cpp
├── add.cpp
└── add.h

编译方式一：一步完成

g++ main.cpp add.cpp -o main

编译方式二：分步编译

g++ -c main.cpp -o main.o
g++ -c add.cpp -o add.o
g++ main.o add.o -o main

分步编译的好处是：当部分文件修改时，只需重新编译变动的部分，而不是整个项目。

运行机制详解

C++ 程序编译完成后，会生成一个可执行文件（如 main 或 main.exe）。 程序的运行流程如下：

操作系统加载可执行文件
   ↓
执行程序的入口函数 main()
   ↓
程序逻辑执行
   ↓
return 返回值传递给操作系统

返回值 0 通常表示正常退出，非零值表示错误或异常终止。

编译器与构建工具

使用 IDE 进行编译运行

常见 IDE

在 IDE 中执行的隐含步骤

当你点击“运行（Run）”时，IDE 实际执行了以下操作：

1. 调用编译器生成目标文件；
2. 执行链接步骤生成可执行程序；
3. 启动该可执行文件并显示输出。

常见编译选项

扩展

• 交叉编译 (Cross Compilation)：在一台机器上为另一架构（如 ARM、RISC-V）生成可执行程序。 示例：

  riscv64-linux-gnu-g++ main.cpp -o main_rv
  

• 静态链接 vs 动态链接：

  • 静态链接 (.a)：在编译时嵌入库文件。
  • 动态链接 (.so / .dll)：运行时动态加载库。

编译与链接

C++ 程序从源代码到可执行文件要经过预处理、编译、汇编、链接四个阶段。理解这个过程，才能解释许多看似奇怪的现象：为什么头文件要加 include guard、为什么模板定义要放在头文件里、为什么会出现「未定义引用」错误。

一、编译流程

源文件 (.cpp)
    ↓ 预处理（Preprocessing）
预处理后的源文件 (.i)
    ↓ 编译（Compilation）
汇编代码 (.s)
    ↓ 汇编（Assembly）
目标文件 (.o / .obj)
    ↓ 链接（Linking）
可执行文件

用 GCC 可以分步执行：

g++ -E main.cpp -o main.i      # 只做预处理
g++ -S main.i -o main.s        # 编译为汇编
g++ -c main.s -o main.o        # 汇编为目标文件
g++ main.o -o main             # 链接

日常使用的 g++ main.cpp -o main 会依次完成全部四步。

二、声明与定义

这是 C++ 中最基本也最重要的区分：

// 声明
extern int global_var;        // 变量声明
int add(int a, int b);        // 函数声明

// 定义
int global_var = 42;          // 变量定义
int add(int a, int b) {       // 函数定义
    return a + b;
}

类定义、inline 函数、模板定义是例外——它们可以出现在多个翻译单元中。

三、单一定义规则（ODR）

ODR（One Definition Rule） 规定：

• 任何变量、函数、类类型、枚举在整个程序中只能有一个定义
• 同一个翻译单元内不能有重复定义
• 不同翻译单元中的定义必须完全相同（对于类、inline 函数、模板）

违反 ODR 属于未定义行为——编译器可能不报错，但链接时或运行时出现奇怪问题。

常见的 ODR 违规：

// header.h
int global_value = 42;   // 错误：这是定义，被多个 .cpp 包含会重复定义

正确做法是加 extern 声明，在一个 .cpp 中定义：

// header.h
extern int global_value;   // 声明

// one.cpp
int global_value = 42;     // 定义（只此一处）

四、头文件

1. 为什么要用头文件

C++ 采用分离编译模型：每个 .cpp 独立编译成目标文件。如果多个文件都要用同一个函数，就需要一种机制共享声明——这就是头文件。

// math_utils.h —— 声明
#pragma once
int add(int a, int b);
int multiply(int a, int b);

// math_utils.cpp —— 定义
#include "math_utils.h"
int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

// main.cpp —— 使用
#include "math_utils.h"
int main() {
    return add(1, 2);
}

2. Include Guard

头文件可能被间接包含多次，导致重复定义。两种防护方式：

// 方式一：include guard（标准做法）
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

// 内容

#endif

// 方式二：#pragma once（非标准但广泛支持）
#pragma once

// 内容

#pragma once 更简洁，且能避免宏名冲突；include guard 是标准做法，可移植性更好。两者都可以用，但不要混用。

3. 头文件里应该放什么

模板和 inline 函数必须放在头文件，因为编译器在实例化时需要看到完整定义。

五、链接

链接器的工作是解析符号引用：把每个目标文件中「引用了但未定义」的符号，与其它目标文件中「定义了」的符号对应起来。

1. 静态库与动态库

# 创建静态库
g++ -c lib.cpp -o lib.o
ar rcs libmylib.a lib.o
g++ main.cpp -L. -lmylib -o main

# 创建动态库
g++ -fPIC -c lib.cpp -o lib.o
g++ -shared lib.o -o libmylib.so
g++ main.cpp -L. -lmylib -o main

2. 常见链接错误

「未定义引用」（undefined reference）：声明了但没定义。

undefined reference to `add(int, int)'

原因通常是：忘记链接某个源文件或库、函数签名不匹配、模板定义没放在头文件。

「重复定义」（multiple definition）：同一个符号在多个目标文件中都有定义。

multiple definition of `global_value'

原因通常是：在头文件中定义了变量或非 inline 函数。

六、inline 与 static 的链接语义

这两个关键字都影响链接行为，但方式不同。

1. inline

inline 最初用于建议编译器内联展开，现代 C++ 中它的主要作用是允许在多个翻译单元中重复定义：

// header.h
inline int square(int x) { return x * x; }   // 多个 .cpp 包含也没问题

编译器会保证最终只保留一份。因此 inline 函数可以放在头文件中。

C++17 起还支持 inline 变量：

// header.h
inline int global_counter = 0;   // 头文件中定义变量，C++17 起可行

2. static

static 在 C++ 中有多重含义，取决于使用位置：

内部链接意味着同名符号在不同 .cpp 中互不冲突：

// a.cpp
static int counter = 0;   // 只在本文件可见

// b.cpp
static int counter = 0;   // 另一个独立的变量，不冲突

Warning

头文件中的 static 是陷阱

在头文件中定义 static 函数或变量，每个包含它的 .cpp 都会得到独立的一份副本：

// header.h
static int counter = 0;   // 每个 .cpp 各有一份！

这会导致内存浪费，且修改一个副本不会影响其它。应该用 inline（C++17）或 extern 声明。

七、条件编译

预处理指令可以根据条件选择性地编译代码：

// 平台判断
#ifdef _WIN32
    #include <windows.h>
#elif defined(__linux__)
    #include <unistd.h>
#endif

// 调试开关
#ifdef DEBUG
    #define LOG(msg) std::cout << msg << '\n'
#else
    #define LOG(msg)
#endif

// 版本判断
#if __cplusplus >= 202002L
    // C++20 及以上
#endif

标准库提供了 __cplusplus 宏表示语言版本（C++17 为 201703L，C++20 为 202002L）。

八、注意事项

• 头文件必须加 include guard。否则重复包含会导致重复定义。
• 变量定义不要放在头文件。应使用 extern 声明 + 单处定义，或 C++17 的 inline 变量。
• 模板和 inline 函数必须放头文件。编译器实例化时需要看到完整定义。
• static 在头文件中会复制。每个翻译单元各一份，通常不是想要的效果。
• c_str() 和 data() 的指针会失效。容器修改后指针可能悬垂。
• ODR 违规是未定义行为。编译器可能不报错，问题在链接期或运行期才暴露。
• #pragma once 非标准。虽然广泛支持，但严格可移植的代码应用 include guard。
• 编译单元是独立编译的。修改一个 .cpp 只需重新编译它，这是增量编译的基础。

九、相关章节

• 编译运行：编译器与基本编译命令
• 预处理器：宏定义与预处理指令
• 命名空间：符号的组织与查找
• 模板：为什么模板定义要放在头文件

C++ 注释（Comments）

1. 概述

注释用于解释程序逻辑、记录设计思路、说明接口功能或在调试时暂时屏蔽代码。 C++ 编译器在编译阶段会忽略注释内容，它们不会出现在目标文件中。 良好的注释能显著提升代码的可读性与可维护性。

2. 注释的基本类型

C++ 提供两种常见的注释形式：

2.1 单行注释（Single-line Comment）

以 // 开头，直到行尾结束。

// 输出欢迎信息
std::cout << "Hello, World!" << std::endl;

// 在行末添加说明
int count = 10;  // 循环次数

适用于简短说明或临时调试。

2.2 多行注释（Multi-line Comment）

以 /* 开始，以 */ 结束，可以跨越多行。

/*
此部分用于初始化程序资源。
包括：
1. 配置加载
2. 内存分配
3. 日志系统启动
*/
initialize_system();

注意：多行注释 不支持嵌套，即不能在 /* ... */ 内再次使用 /* ... */。

3. 注释编写原则

1. 准确：注释必须与代码逻辑一致。
2. 必要：解释“为什么这样做”，而非“代码做了什么”。
3. 简洁：避免冗长或与代码重复的描述。
4. 及时：修改代码时应同步更新注释。
5. 一致：保持统一的注释风格与格式。

示例：

// 不推荐：重复代码逻辑
int x = x + 1; // x 加 1

// 推荐：说明设计目的
// 自增以保持计数连续性
x++;

4. 文档化注释（Documentation Comments）

在较大的工程中，可以通过特殊格式的注释自动生成接口文档。 常用工具为 Doxygen，支持从源码中提取函数、类、参数等说明信息。

4.1 格式示例

/**
 * @brief 计算两个整数的和
 * @param a 第一个整数
 * @param b 第二个整数
 * @return 两数之和
 */
int add(int a, int b) {
    return a + b;
}

或者：

/// 计算矩形面积
/// @param width 宽度
/// @param height 高度
/// @return 面积
double area(double width, double height);

4.2 常用标签

5. 实际使用规范

在团队开发或课程项目中，建议采用以下注释习惯：

1. 文件头部：说明文件用途、作者、日期。
2. 函数前：使用文档注释描述功能、参数与返回值。
3. 代码内部：仅在逻辑复杂处添加必要注释。
4. 调试阶段：临时屏蔽代码时使用 //，不保留旧逻辑。

示例：

/**
 * @file user_manager.cpp
 * @brief 用户管理模块
 * @author Ding
 * @date 2025-10-13
 */

/// 初始化用户系统
/// @return 初始化是否成功
bool init_user_system() {
    // TODO: 支持从配置文件加载默认用户
    return true;
}

6. 调试与维护中的注释

• 调试时临时屏蔽代码

  // 禁用日志输出
  // std::cout << "Debug info" << std::endl;
  

• 避免保留废弃代码

  // 不推荐：应使用版本控制系统管理
  // old_function();
  

命名规则 (Naming Conventions)

命名规则是代码风格的重要组成部分，它能显著提高代码的可读性、可维护性和团队协作效率。在 C++ 社区中，存在多种主流命名规范（如 Google Style、LLVM Style）。

核心原则

1. 一致性 (Consistency)： 在一个项目或代码库中，一旦选定了一种命名风格，就必须始终如一地使用它，避免混用多种风格导致的混乱。

2. 描述性 (Descriptive)： 名称应清晰地描述其所代表的实体的用途或含义，便于其他开发者理解代码。

3. 避免歧义 (Avoid Ambiguity)： 避免使用容易引起误解的缩写或模糊单词，例如 tmp、data 等，必要时增加上下文信息。

常用命名风格

命名实体规范

命名限制与最佳实践

1. C++ 保留标识符

C++ 标准保留了某些名称供编译器和标准库使用，用户代码禁止使用：

1.1 全局范围（Global Scope）保留

• 包含两个连续下划线 __ 的名称 示例：__myVar, My__Class
• 以下划线 _ 开头，紧跟大写字母 示例：_PrivateMember, _Max_Value

1.2 全局命名空间（Global Namespace）保留

• 以下划线 _ 开头的名称 示例：_name, _a_local_var 在局部作用域内可能安全，但全局范围内使用会违反标准。最佳实践：避免任何下划线开头的自定义名称。

1.3 关键字 (Keywords)

绝对禁止使用 C++ 关键字作为标识符：

C++11/14/17/20 新增：constexpr, noexcept, override, concept

2. 命名技巧与长度

• 避免单字母名称：除循环迭代器（i, j, k）和数学变量（x, y, z）外，应使用描述性名称。

  差： int s; 好： int studentCount;

• 避免匈牙利命名法：现代 C++ 不推荐通过前缀标注类型，如 iAge、szName。类型信息已由编译器和 IDE 提供。

• 布尔值命名：布尔变量或函数应以动词开头，清晰表达状态。 示例：bool isValid;, bool hasError();, bool isFinished;

• Getter/Setter 命名：遵循约定提高可读性。

  • Getter: getValue() 或 value() (变量名 value_)
  • Setter: setValue(int newValue) 或 set_value(int newValue)

3. 文件命名规范

头文件保护 (Header Guards)：确保文件内容只被编译一次。推荐使用 全大写 + 项目/目录/文件名 的宏。

// network/tcp_socket.h
#ifndef MYPROJECT_NETWORK_TCP_SOCKET_H
#define MYPROJECT_NETWORK_TCP_SOCKET_H

// ... 代码 ...

#endif // MYPROJECT_NETWORK_TCP_SOCKET_H

示例代码

// 1. 类型 (PascalCase)
class EmployeeManager {
private:
    // 2. 成员变量 (推荐使用后缀，避免保留标识符)
    int employee_count_;

    // 错误示范（应避免）
    // int __bad_var;           // 双下划线
    // int _AnotherBadVar;      // 下划线开头 + 大写
    // int _safe_in_local_scope; // 全局范围不安全

public:
    // 3. 函数/方法 (camelCase)
    bool isValidEmployee(const std::string& name) {
        // 4. 局部变量 (camelCase)
        int maxHours = 40;

        if (this->employee_count_ < maxHours) { // 使用 this-> 或后缀区分成员
            return true;
        }
        return false;
    }
};

// 5. 宏常量 (UPPER_CASE)
#define MAX_BUFFER_SIZE 1024

数据类型

在 C++ 中，数据类型（Data Types） 是程序设计的基础，它定义了变量在内存中的存储方式、可表示的取值范围以及能进行的操作。 理解数据类型不仅是掌握语法的关键，也是进行性能优化、内存管理和类型安全编程的前提。

C++ 的类型系统丰富而严格，既包含直接映射到硬件的基本类型（Fundamental Types），也支持由这些类型构建的派生类型（Derived Types），此外还提供了面向对象与泛型编程所需的抽象类型系统。

本章将系统介绍 C++ 中的数据类型体系结构，内容包括：

• 基本数据类型： 描述整型、浮点型、布尔型、空类型等语言内建类型及其修饰符（signed、unsigned、long 等）。

• 派生数据类型： 介绍数组、指针、引用、函数、结构体、类、枚举等由基本类型组合或扩展而来的类型。

• 字符串类型： 涵盖 C 风格字符串 (char[]) 与 C++ 字符串类 (std::string、std::wstring) 的使用与区别。

• 类型转换： 探讨隐式与显式类型转换、C 风格转换与 C++ 四种安全转换（static_cast、const_cast、reinterpret_cast、dynamic_cast）。

• 类型推导： 说明 auto、decltype、模板参数推导等机制如何简化类型声明并保持类型安全。

基本数据类型

C++ 基本数据类型

C++ 修饰符

C++11 新增数据类型

说明

宽字符类型 (wchar_t)

wchar_t 是 C++ 中用于存储宽字符的类型，广泛应用于需要处理 Unicode 字符集的程序中。与普通的 char 类型（通常用于存储 ASCII 字符）不同，wchar_t 的设计目的是为了支持更大的字符集，特别是 Unicode。由于 wchar_t 需要存储更多的字符信息，因此其大小取决于平台，通常在 2 或 4 字节之间。在一些平台上，wchar_t 被定义为 2 字节（16 位），在其他平台上则可能是 4 字节（32 位）。使用 wchar_t 可以轻松处理如中文、日文等非拉丁字符。

#include <iostream>

int main() {
    wchar_t wide_char = L'我';  // 使用 wchar_t 存储一个 Unicode 字符
    std::wcout << wide_char << std::endl;  // 输出：我
    return 0;
}

char16_t 和 char32_t

char16_t 和 char32_t 是 C++11 引入的专门用于存储 Unicode 字符的类型，分别表示 16 位和 32 位字符类型。char16_t 是为了支持 UTF-16 编码而设计的，而 char32_t 是为了支持 UTF-32 编码。char16_t 用 2 字节来存储一个字符，而 char32_t 用 4 字节存储一个字符。这两种类型能够直接表示 Unicode 字符，而无需进行额外的编码转换。

char16_t 和 char32_t 提供了对更广泛字符集的支持，尤其适合那些需要处理全球化文本的应用程序。char16_t 和 char32_t 作为 Unicode 字符的表示方式，分别与 UTF-16 和 UTF-32 编码兼容，能够表示包括基本多语言平面（BMP）以及更高平面字符在内的所有 Unicode 字符。

#include <iostream>

int main() {
    char16_t char16 = u'你';  // 使用 char16_t 存储一个 UTF-16 编码的字符
    char32_t char32 = U'你';  // 使用 char32_t 存储一个 UTF-32 编码的字符

    std::wcout << "char16_t: " << char16 << std::endl;
    std::wcout << "char32_t: " << char32 << std::endl;

    return 0;
}

volatile

在现代 CPU 中通常包含多个核心，每个核心都有独立的缓存。多个核心可能同时缓存了同一段主存的数据。一般情况下，缓存和主存的数据是一致的，但在多线程并发场景下，由于缓存写回策略的影响，数据的修改可能无法及时同步到主存，从而导致数据不一致的问题。

volatile 关键字用于告诉编译器：某个变量的值可能随时被外部因素（如其他线程、硬件设备或中断）修改，因此缓存中的值并不可靠。出于这个原因，编译器在访问该变量时不会进行过度优化，而是强制每次都从内存中读取最新的值。

1. 可见性 volatile 保证变量的值在不同线程或不同硬件环境下始终是“最新可见”的。即使某个核心或寄存器中有缓存数据，访问 volatile 变量时也必须直接从内存或硬件中获取，而不是使用缓存副本。

2. 不可优化 在编译阶段，为了提高执行效率，编译器会进行多种优化。例如：

   int flag = 0;
   while (flag == 0) {
       // 等待 flag 改变
   }
   

   若 flag 未被声明为 volatile，编译器可能认为 flag 始终等于 0，于是直接将循环优化为 while(false)，导致死循环。

   使用 volatile 可以禁止类似的优化，包括 消除优化、传播优化 和 合并优化，从而保证变量的读写行为不会被错误简化。

3. 顺序性 volatile 还会在一定程度上影响指令的顺序。编译器在处理 volatile 变量时，会保证读写操作不会因乱序优化而颠倒，从而维持必要的执行顺序。

volatile 在嵌入式编程和多线程编程中尤为重要：

• 多线程共享变量：确保不同线程读取到的值保持一致。
• 中断处理：中断可能随时修改某个变量，主程序通过 volatile 保证能正确检测到变化。
• 硬件寄存器访问：在嵌入式系统中，硬件寄存器的值可能在后台自动更新，必须通过 volatile 确保每次访问都直接读取硬件寄存器的当前值。

尽管 volatile 在保证可见性、防止编译器优化、维持一定顺序性方面很有用，但它并不是并发编程的“万能钥匙”，主要局限性如下：

1. 不保证原子性

   • volatile 仅保证读写操作不会被优化和缓存，但不能保证复合操作的原子性。

   • 例如：

     volatile int counter = 0;
     counter++; // 实际分解为：读取 -> 修改 -> 写回
     

     在多线程环境下可能发生竞态条件，导致结果错误。

2. 不等同于内存屏障（Memory Barrier）

   • volatile 的“顺序性”只作用于编译器层面，防止指令在编译时被重排。
   • 但在 CPU 的指令执行层面，仍然可能发生硬件乱序执行。若需要在多线程同步中严格保证内存访问顺序，还需要使用更强的同步原语（如 C++ 中的 std::atomic 或内存屏障指令）。

3. 性能开销

   • 每次访问 volatile 变量都要从内存中读取最新值，无法使用寄存器缓存，可能造成一定性能损失。

4. 局限于特定场景

   • volatile 更适合用于：

     • 标志位（如中断标志、任务完成标志）。
     • 硬件寄存器访问。

   • 但在复杂的多线程共享数据同步场景下，仅依赖 volatile 是不够的，往往需要互斥锁、原子操作或更高级的同步机制。

mutable

mutable 关键字是用来修饰类的成员变量的，意味着即使该对象是常量（const），这些成员变量也可以被修改。通常，mutable 用于那些希望在 const 方法中进行修改的成员变量，比如用于缓存的成员变量。通过 mutable，我们可以在 const 方法中修改这些成员，而不会破坏 const 对象的常量性。

以下示例展示了在 const 方法中修改 mutable 成员变量的情况：

class MyClass {
public:
    mutable int cache;  // 使用 mutable 修饰的成员变量

    MyClass() : cache(0) {}

    void updateCache() const {
        // 即使 updateCache 是 const 方法，cache 依然可以被修改
        cache++;
    }
};

int main() {
    const MyClass obj;
    obj.updateCache();  // 可在 const 对象上调用
    std::cout << obj.cache << std::endl;  // 输出：1
    return 0;
}

decltype

decltype 是 C++11 引入的一个关键字，用于获取表达式的类型，而不需要显式地声明变量的类型。它通常用于模板编程中，或者当我们不确定某个表达式的类型时。decltype 可以非常方便地获取复杂类型，尤其是当类型通过复杂的表达式推导出来时。

例如，以下代码通过 decltype 获取了变量 x 的类型，并且通过 auto 使得代码更加简洁：

int x = 5;
decltype(x) y = 10;  // y 的类型是 int，因为 x 是 int

auto z = x + y;  // z 的类型由编译器推断，类型为 int

std::initializer_list

std::initializer_list 是 C++11 引入的一个模板类，用于支持初始化列表。它允许在创建对象时通过花括号 {} 来传递多个值。initializer_list 主要用于支持类的构造函数接收不定数量的参数，或者将多个值传递给函数，特别适用于那些需要接收多个初始值的容器类型。

#include <initializer_list>
#include <iostream>

void printList(std::initializer_list<int> list) {
    for (auto i : list) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

int main() {
    printList({1, 2, 3, 4, 5});  // 使用 initializer_list
    return 0;
}

std::tuple

std::tuple 是 C++11 引入的一个模板类，允许存储多个不同类型的元素。与数组和 std::vector 不同，tuple 允许每个元素拥有不同的类型。std::tuple 是一个非常强大的工具，可以将多个不同类型的值打包在一起，并在需要时访问这些值。它常用于函数返回多个不同类型的值，或在需要将多种类型的参数组合起来时使用。

#include <tuple>
#include <iostream>

int main() {
    std::tuple<int, double, char> t(1, 3.14, 'A');

    std::cout << std::get<0>(t) << ", ";  // 1
    std::cout << std::get<1>(t) << ", ";  // 3.14
    std::cout << std::get<2>(t) << std::endl;  // A

    // 修改 tuple 的元素
    std::get<0>(t) = 42;
    std::cout << std::get<0>(t) << std::endl;  // 42

    return 0;
}

static

static 关键字在 C++ 中有三种主要用途，取决于它所修饰的对象和作用域，而在C语言中由于不支持类从而只支持修饰局部静态变量和外部静态变量、函数。

1. 局部变量（函数内）- 改变存储期

当 static 用于函数内的局部变量时，它改变了变量的存储期（Storage Duration）。

• 存储期：static 局部变量在程序运行期间只会被初始化一次，且生命周期与整个程序相同（静态存储期），但其作用域仍限定在定义它的函数内部。
• 用途：用于记录函数被调用的次数，或者在多次调用中保持某个状态。

void func() {
    static int count = 0; // 只在程序启动时初始化一次
    count++;
    std::cout << "Count: " << count << std::endl;
}
// 每次调用 func()，count 都会递增，而不是重置为 0

2. 全局变量和函数（文件作用域）- 改变链接性

当 static 用于全局变量或普通函数时，它改变了它们的链接性（Linkage）。

• 链接性：将默认的外部链接（External Linkage，可以在其他源文件访问）改为内部链接（Internal Linkage）。
• 用途：使变量或函数只在其定义的**当前翻译单元（源文件）**中可见和可用，避免与其他源文件中的同名标识符发生冲突。

// file1.cpp
static int global_data = 10; // 只能在 file1.cpp 中访问
static void helper_func() {  // 只能在 file1.cpp 中调用
    // ...
}

3. 类成员（成员变量和成员函数）- 类级别共享

当 static 用于类内部的成员时，它使成员成为类级别的共享资源，而不是每个对象独有的资源。

• 静态成员变量：
  • 该变量为所有类的对象所共享，只存在一个副本。
  • 它必须在类外部进行定义和初始化（除非是 const static 整数类型）。
  • 可以通过类名或对象访问。
• 静态成员函数：
  • 它不依赖于任何特定的类对象。
  • 它不能直接访问非静态的成员变量或成员函数（因为它没有 this 指针）。
  • 通常用于访问和操作静态成员变量，或作为工具函数。

class MyClass {
public:
    static int object_count; // 静态成员变量声明

    MyClass() {
        object_count++;
    }

    static int get_count() { // 静态成员函数
        return object_count;
    }
};

// 在类外定义和初始化静态成员
int MyClass::object_count = 0;

int main() {
    MyClass obj1;
    MyClass obj2;
    // 使用类名直接访问静态成员
    std::cout << MyClass::get_count() << std::endl; // 输出：2
    return 0;
}

auto

auto 是 C++11 引入的一个关键字，允许编译器自动推导出变量的类型。auto 使得代码更加简洁，并且减少了显式指定类型的需求，尤其在处理复杂类型时非常有用。auto 通常用于变量声明时，让编译器根据赋值的表达式自动推断类型，这在迭代器和模板编程中尤其常见。

int main() {
    auto x = 10;  // x 的类型是 int
    auto y = 3.14;  // y 的类型是 double

    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

const

在 C 语言和 C++ 中，const 都用于限定变量为“只读”。 但是 C++ 对 const 的支持更为强大和灵活，它不仅影响编译器的检查机制，还会在类型系统中起作用。

1. 基本特性

   • 在 C 中，const 修饰的变量默认是只读存储（readonly），但本质上仍然是变量，而不是常量。

     const int x = 10;
     int *p = (int*)&x; // 通过强制转换依然能修改
     *p = 20;           // UB（未定义行为）
     

   • 在 C++ 中，const 更严格，编译器会将其视为类型的一部分。

     const int x = 10;
     x = 20;  // 编译错误，禁止修改
     

2. 修饰位置

   const 可以修饰不同对象，表达不同含义：

   • 修饰变量：值不可修改。

   • 修饰指针：

     const int *p;  // 指向常量的指针（*p 不可改，p 可改）
     int *const p;  // 常量指针（p 不可改，*p 可改）
     const int *const p; // 指向常量的常量指针
     

   • 修饰函数参数：保证函数体内不会修改该参数。

   • 修饰成员函数：表示该成员函数不会修改对象的成员变量，本质上是修饰this指针。

3. 作用域与链接

   • 在 C 中，const 全局变量默认是 外部链接，除非显式加 static使得在本文件可见。
   • 在 C++ 中，const 全局变量默认是 内部链接（只在本翻译单元内可见），若要在多个文件共享，需加 extern。

4. 局限性

   • const 并不保证编译期求值，它仅仅保证“运行时不能被修改”。
   • 如果需要编译期常量（如数组大小、模板参数），在 C++11 之前通常使用 #define 或 enum hack。

constexpr

constexpr 是 C++11 引入的关键字，用于声明“编译期常量表达式”。它不仅意味着值不可变，更重要的是： 编译器必须在编译期对其进行求值（只要表达式满足常量表达式要求）。

1. 基本特性

   • constexpr 变量一定是常量，并且能在编译期被计算：

     constexpr int size = 10;
     int arr[size]; // 合法
     

   • 与 const 不同，constexpr 要求初始化表达式必须是编译期可计算的常量。

2. 函数支持

   • constexpr 还可以修饰函数：

     constexpr int square(int x) {
         return x * x;
     }
     int arr[square(5)]; // 在编译期计算为 25
     

   • 这样的函数可以在编译期使用，也可以在运行时调用（若传入非常量参数）。

3. 类与构造函数

   • C++11 起，constexpr 可以修饰构造函数，表示该类的对象可以在编译期生成常量。
   • C++14/17 对 constexpr 的限制逐步放宽，例如允许有分支、循环，更接近普通函数。

4. 区别于 const

   • const：运行期常量（只读），初始化表达式可以是运行时值，可以使用const_cast去除限定。
   • constexpr：编译期常量，初始化表达式必须在编译期可求值。

   对比示例：

   const int a = std::time(nullptr); // 合法，运行期决定
   constexpr int b = std::time(nullptr); // 错误，不能在编译期求值
   

extern

extern 关键字用于声明而非定义变量或函数。被extern标识的变量或者函数声明其定义在别的文件中，提示编译器遇到此变量和函数时在其他模块寻找其定义。 它出现在多文件项目中，用于在一个文件中访问另一个文件定义的全局变量或函数。

• 作用：

  • 告诉编译器“该变量或函数在别处定义”；
  • 不会为其分配存储空间（除非在定义处）；
  • 避免重复定义全局符号。

// file1.cpp
int count = 10;  // 定义全局变量

// file2.cpp
#include <iostream>
extern int count;  // 声明外部变量（非定义）
int main() {
    std::cout << count << std::endl;  // 输出 10
    return 0;
}

• 在C++中：

  C++ 默认情况下，const 全局变量具有内部链接（internal linkage），也就是仅在本文件内可见。 若希望跨文件共享一个常量变量，必须结合 extern 使用：

  // file1.cpp
  extern const int BUFFER_SIZE = 1024;
  
  // file2.cpp
  extern const int BUFFER_SIZE;  // 声明外部常量
  

• 与函数结合使用：

  对于函数来说，extern 是默认属性，即所有非 static 函数都具有外部链接性，因此通常可省略：

  extern void foo();  // 与 void foo(); 等价
  

register

register 是早期 C/C++ 时代用于提升变量访问速度的关键字，提示编译器将变量存储在 CPU 寄存器中，而非内存中。

• 特点：

  • 变量可能被存放在 CPU 寄存器中，而非内存；
  • 不能对 register 变量使用取地址操作符 &；
  • 仅能修饰局部变量或函数参数；
  • 在现代编译器中通常被自动优化机制取代，因此多用于教学或历史理解。

#include <iostream>

int main() {
    register int i;  // 建议编译器将 i 放入寄存器中
    for (i = 0; i < 5; ++i) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

• 局限性：

  • 编译器不保证一定会将其放入寄存器；
  • 不能取地址（即 &i 是非法的）；
  • 在现代 C++ 中几乎没有实际性能提升，优化器会自动选择合适的寄存器分配策略。

派生数据类型

C++派生数据类型

在 C++ 中，派生数据类型（Derived Types） 是由基本数据类型或其他派生类型构建而来的类型。 它们扩展了语言的表达能力，使得开发者能够通过组合与抽象创建更复杂的数据结构与行为模型。

派生类型包括数组、指针、引用、函数、结构体、类、联合体以及枚举类型等。

数组（Array）

数组用于存储相同类型元素的固定长度序列，在内存中是连续存放的。

int numbers[5] = {1, 2, 3, 4, 5};
std::cout << numbers[2]; // 输出 3

• 下标从 0 开始，越界访问会导致未定义行为（Undefined Behavior）。

• 在函数参数中，数组会退化为指针：

  void printArray(int arr[], int size); // 等价于 void printArray(int* arr, int size);
  

• 若需要安全的动态数组，请使用 std::vector。

指针（Pointer）

指针是存储变量地址的变量，是 C++ 的核心特性之一。

int a = 10;
int* p = &a;    // 指针p指向a
std::cout << *p; // 输出10

关键点：

• * 用于定义或解引用指针；
• & 用于取地址；
• 指针类型必须与目标对象类型一致；
• nullptr 表示空指针（C++11 引入）。

常见错误：

• 解引用空指针或野指针会导致崩溃；

• 动态内存需成对使用：

  int* p = new int(5);
  delete p;
  

推荐使用智能指针（std::unique_ptr, std::shared_ptr）来避免内存泄漏。

引用（Reference）

引用是另一个变量的别名，必须在定义时初始化。

int value = 10;
int& ref = value;
ref = 20; // value 也变为 20

• 引用不能为空；

• 绑定后不能再更改引用目标；

• 常用于函数参数传递以避免拷贝：

  void modify(int& x) { x *= 2; }
  

C++11 还引入了 右值引用 (T&&)，用于支持移动语义和完美转发。

函数类型（Function Type）

函数本身也是一种类型，其类型由返回值类型和参数类型列表组成。

int add(int a, int b) { return a + b; }

函数类型也可通过指针或引用使用：

int (*funcPtr)(int, int) = add;
std::cout << funcPtr(2, 3); // 输出5

C++11 提供了更安全的函数封装：

• std::function：可存储任意可调用对象；
• auto 和 Lambda 表达式使函数类型推导更简洁。

结构体（struct）

结构体是用户自定义的复合类型，可包含多个不同类型的成员。

struct Point {
    int x;
    int y;
};

Point p1 = {10, 20};
std::cout << p1.x << ", " << p1.y;

• 默认成员访问权限是 public；
• 可以包含成员函数；
• 可以与类（class）结合使用面向对象设计。

类（class）

类是 C++ 的核心概念之一，支持 封装（Encapsulation）、继承（Inheritance） 和 多态（Polymorphism）。

class Rectangle {
private:
    int width, height;

public:
    Rectangle(int w, int h) : width(w), height(h) {}
    int area() const { return width * height; }
};

• 成员默认为 private；
• 支持构造函数、析构函数、运算符重载等；
• 是对象与抽象数据类型的基础。

类与对象是C++语言极为重要的内容。

联合体（union）

联合体（union）允许多个成员共用同一块内存。

union Data {
    int i;
    float f;
    char c;
};

Data d;
d.i = 10;
std::cout << d.i; // 输出10
d.f = 3.14;       // i 被覆盖

• 占用的内存大小等于最大成员的大小；
• 只能同时存储一个有效成员；
• 可用于节省内存或实现类型复用。

枚举类型（enum）

枚举用于定义一组具名的整数常量，提高代码可读性与类型安全。

创建枚举类型时，使用关键字 enum。其一般形式为：

enum 枚举名 {
     标识符[=整型常数],
     标识符[=整型常数],
     ...
     标识符[=整型常数]
} 枚举变量;

例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 color。最后，c 被赋值为 blue：

enum color { red, green, blue } c;
c = blue;

默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。然而，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，green 的值为 5：

enum color { red, green=5, blue };

在此示例中，blue 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1，而 red 的值仍然为 0。

C++11 引入 强类型枚举：

enum class Status { OK, ERROR };
Status s = Status::OK;

强类型枚举不会隐式转换为整数，作用域也更加安全。

C++类型别名

类型别名可通过 typedef 或 using 定义。

示例：

typedef unsigned long ulong_t;
using ushort_t = unsigned short;

using 语法更直观，且支持模板别名：

template <typename T>
using Vec = std::vector<T>;
Vec<int> v = {1, 2, 3};

Tip

typedef 和 define 有什么区别？

typedef 和 #define 虽然在表面上都可以用于“简化代码书写”，但它们的本质、用途以及生效阶段存在明显区别。

(1) 用法不同： typedef 用于为已有的数据类型定义一个新的类型别名，从而增强程序的可读性和可维护性。例如，可以通过 typedef unsigned int uint; 为 unsigned int 定义一个更简洁的别名。 而 #define 是一种宏定义指令，主要用于定义常量或书写复杂但使用频繁的宏表达式，如 #define PI 3.14159 或 #define MAX(a, b) ((a) > (b) ? (a) : (b))。 前者作用于类型层面，后者仅进行文本替换。

(2) 执行时间不同： typedef 属于编译阶段的一部分，编译器在处理类型定义时会进行语法与类型检查，确保类型合法。 而 #define 是在编译前的预处理阶段执行的，它仅做简单的字符串替换，并不参与类型检查，因此如果使用不当，容易造成潜在的逻辑错误。

(3) 作用域不同： typedef 受 C/C++ 作用域规则限制，只在其定义的作用域内有效，例如在函数内定义的类型别名在函数外无法使用。 相对地，#define 不受作用域约束，只要在定义之后且未被 #undef 取消，其宏名在整个文件（甚至被包含的其他文件）中都有效，因此若管理不当，可能造成命名冲突。

(4) 对指针的操作不同： typedef 和 #define 在定义指针类型时的行为存在显著区别。 例如：

#define PINT1 int*
typedef int* PINT2;

PINT1 a, b;  // 等价于 int* a, b; => b是int类型
PINT2 c, d;  // 等价于 int* c, *d; => c和d都是int*类型

这表明：#define 仅仅进行文本替换，而 typedef 定义的是一种完整的类型。使用 typedef 可以避免宏替换带来的歧义。

(5) 语法要求不同： typedef 是一条语句，因此必须以分号结尾； #define 是预处理指令，不属于语句，不能加分号，否则分号也会被替换到目标文本中，引发错误。

C++标准库类型

std::string类型的详细介绍见字符串类型章节，其他标准库类型见STL章节。

C++ 字符串类型

C++ 提供了两种主要的字符串表示方式：C 风格字符串和 C++ 引入的 string 类类型。尽管 C++ 中 string 类型在许多情况下更为常用，但 C 风格字符串仍然是 C++ 中的一个重要组成部分，特别是在需要与旧有的 C 库代码兼容时。

C 风格字符串

C 风格的字符串源自 C 语言，并在 C++ 中继续得到支持。这种字符串表示方式实际上是一个以 null 字符 \0 结尾的字符数组。C 风格字符串的本质是一个一维字符数组，末尾的 null 字符标识了字符串的结束。

C 风格字符串的定义与初始化

您可以通过以下方式定义并初始化一个 C 风格字符串：

char site[6] = {'H', 'E', 'L', 'L', 'O', '\0'};

也可以使用更简便的方式进行初始化：

char site[] = "HELLO";

在这种情况下，C++ 编译器会自动在字符串的末尾添加 null 字符 \0，无需显式地写出。

#include <iostream>

using namespace std;

int main() {
   char s[] = "HELLO"; // 字符串自动以 '\0' 结束

   cout << s << endl;

   return 0;
}

输出：

HELLO

C 风格字符串的常用操作函数

C 风格字符串有许多函数可以进行常见的操作。以下是常用的几个字符串操作函数：

#include <iostream>
#include <cstring>

using namespace std;

int main() {
   char str1[13] = "hello";
   char str2[13] = "world";
   char str3[13];
   int len;

   // 复制 str1 到 str3
   strcpy(str3, str1);
   cout << "strcpy(str3, str1): " << str3 << endl;

   // 连接 str1 和 str2
   strcat(str1, str2);
   cout << "strcat(str1, str2): " << str1 << endl;

   // 计算连接后的长度
   len = strlen(str1);
   cout << "strlen(str1): " << len << endl;

   return 0;
}

输出：

strcpy(str3, str1): hello
strcat(str1, str2): helloworld
strlen(str1): 10

C++ 中的 string 类

C++ 标准库提供了 string 类，它是 C 风格字符串的现代替代品。string 类提供了丰富的成员函数，支持字符串的动态操作，简化了字符串处理过程，并且避免了 C 风格字符串的许多潜在问题。

string 类基本操作

C++ 中的 string 类提供了方便的字符串处理方法，使得字符串操作变得更加高效和直观。以下是一些常见的操作。

#include <iostream>
#include <string>

using namespace std;

int main() {
   string str1 = "hello";
   string str2 = "world";
   string str3;
   int len;

   // 复制 str1 到 str3
   str3 = str1;
   cout << "str3: " << str3 << endl;

   // 连接 str1 和 str2
   str3 = str1 + str2;
   cout << "str1 + str2: " << str3 << endl;

   // 计算连接后的总长度
   len = str3.size();
   cout << "str3.size(): " << len << endl;

   return 0;
}

输出：

str3: hello
str1 + str2: helloworld
str3.size(): 10

string 类的常用成员函数

string 类提供了多种函数来执行常见的字符串操作，常见的成员函数包括：

• append(str)：将 str 追加到当前字符串末尾。
• insert(pos, str)：在位置 pos 处插入字符串 str。
• erase(pos, len)：从位置 pos 开始，删除 len 个字符。
• substr(pos, len)：返回从位置 pos 开始的长度为 len 的子字符串。
• find(str)：返回子字符串 str 在当前字符串中首次出现的位置。
• replace(pos, len, str)：将当前位置 pos 开始的 len 个字符替换为字符串 str。

#include <iostream>
#include <string>

using namespace std;

int main() {
    string str = "Hello, world!";

    // 获取子字符串
    string sub = str.substr(7, 5);  // 从位置 7 开始，获取 5 个字符
    cout << "Substring: " << sub << endl;

    // 查找字符 'w' 在字符串中的位置
    size_t pos = str.find('w');
    cout << "'w' found at: " << pos << endl;

    // 替换子字符串
    str.replace(7, 5, "C++");
    cout << "After replace: " << str << endl;

    return 0;
}

输出：

Substring: world
'w' found at: 7
After replace: Hello, C++!

类型转换

类型转换是将一个数据类型的值转换为另一种数据类型的值。在 C++ 中，类型转换主要有四种方式：静态转换、动态转换、常量转换和重新解释转换。每种转换方式有其特定的应用场景和注意事项。

静态转换（Static Cast）

静态转换用于将一个数据类型的值强制转换为另一种类型，通常适用于类型之间存在一定的相似性。例如，可以将 int 类型转换为 float 类型。静态转换并不会进行运行时的类型检查，因此在某些情况下，它可能会导致运行时错误，尤其是在转换较为复杂的对象时。

例如：

int i = 10;
float f = static_cast<float>(i);  // 将 int 转换为 float

动态转换（Dynamic Cast）

动态转换是 C++ 中用于在继承体系中进行类型转换的方式。它通常用于将基类指针或引用转换为派生类指针或引用，特别是在涉及多态的场景中。与静态转换不同，动态转换会在运行时检查转换是否合法，确保程序的类型安全。如果转换失败，对于指针类型，它会返回 nullptr，而对于引用类型，则会抛出 std::bad_cast 异常。

例如：

#include <iostream>

class Base {
public:
    virtual ~Base() = default;  // 基类必须有虚函数
};

class Derived : public Base {
public:
    void show() {
        std::cout << "Derived class method" << std::endl;
    }
};

int main() {
    Base* ptr_base = new Derived;  // 基类指针指向派生类对象

    // 将基类指针转换为派生类指针
    Derived* ptr_derived = dynamic_cast<Derived*>(ptr_base);

    if (ptr_derived) {
        ptr_derived->show();  // 成功转换，调用派生类方法
    } else {
        std::cout << "Dynamic cast failed!" << std::endl;
    }

    delete ptr_base;
    return 0;
}

输出：

Derived class method

在转换引用时，也可以使用 dynamic_cast，不过如果转换失败，它会抛出异常：

#include <iostream>
#include <typeinfo>

class Base {
public:
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void show() {
        std::cout << "Derived class method" << std::endl;
    }
};

int main() {
    Derived derived_obj;
    Base& ref_base = derived_obj;  // 基类引用绑定到派生类对象

    try {
        Derived& ref_derived = dynamic_cast<Derived&>(ref_base);
        ref_derived.show();  // 成功转换，调用派生类方法
    } catch (const std::bad_cast& e) {
        std::cout << "Dynamic cast failed: " << e.what() << std::endl;
    }

    return 0;
}

输出：

Derived class method

动态转换提供了更高的安全性，确保在程序运行时可以正确地进行类型检查。尽管如此，它相对于静态转换而言，性能开销较高，因为需要进行类型验证。

常量转换（Const Cast）

常量转换（const_cast）用于去除对象的 const 限定符，从而使得一个 const 对象能够被修改。它并不会改变对象的实际类型，只是去掉了 const 属性。这种转换通常用于需要修改原本被声明为常量的对象时，尽管这种做法应谨慎使用。

例如：

const int i = 10;
int& r = const_cast<int&>(i);  // 去除 const 限定符

此代码将 const int 转换为普通的 int，使得对 i 的修改变得可能。但请注意，修改一个原本是常量的对象可能导致未定义的行为。

重新解释转换（Reinterpret Cast）

重新解释转换（reinterpret_cast）允许将一个数据类型的值重新解释为另一种数据类型的值。它通常用于在指针类型之间进行转换，不会进行任何类型检查，因此可能会导致未定义的行为。这种转换应谨慎使用，特别是在不同类型之间进行转换时，必须确保数据在内存中的表示是兼容的。

例如：

int i = 10;
float f = reinterpret_cast<float&>(i);  // 将 int 转换为 float

这段代码通过 reinterpret_cast 将 int 类型的数据重新解释为 float 类型。然而，重新解释转换的使用非常危险，因为它不会检查类型是否真正兼容。如果目标类型与原类型不兼容，可能会导致程序崩溃或者数据损坏。因此，reinterpret_cast 应该仅在非常确定数据类型兼容的情况下使用。

自动类型推导

在 C++ 中，自动类型推导（type inference）允许编译器根据初始化表达式推断变量的类型，从而减少显式指定类型的需求。C++11 引入了 auto 关键字，它使得变量声明更加简洁和灵活，同时也有助于避免类型错误。

auto 关键字的基本使用

auto 关键字让编译器根据初始化表达式推导出变量的类型。在声明变量时，使用 auto 代替类型名称，编译器将自动推断类型。

#include <iostream>

int main() {
    auto x = 42;  // 自动推导类型为 int
    auto y = 3.14;  // 自动推导类型为 double

    std::cout << "x: " << x << ", y: " << y << std::endl;

    return 0;
}

在这个例子中，auto 自动推导出 x 的类型为 int，y 的类型为 double，根据其初始化值。无需显式地指定类型。

输出：

x: 42, y: 3.14

auto 与容器

auto 在处理容器时非常有用，尤其是当容器类型复杂且冗长时，使用 auto 可以简化代码并提高可读性。C++11 引入了范围-based for 循环，配合 auto 使用可以轻松地遍历容器。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用 auto 遍历容器
    for (auto& v : vec) {
        std::cout << v << " ";
    }

    std::cout << std::endl;

    return 0;
}

在此示例中，auto 用来自动推导容器元素的类型。由于我们希望修改容器中的元素，所以使用了 auto& 来获取元素的引用。

输出：

1 2 3 4 5

auto 和指针

在使用指针时，auto 也可以自动推导出指针的类型。注意，auto 仅推导出变量本身的类型，而不推导出指针指向的类型。

#include <iostream>

int main() {
    int num = 100;
    int* ptr = &num;

    // 使用 auto 推导指针类型
    auto p = ptr;  // p 将是 int* 类型

    std::cout << "p points to: " << *p << std::endl;

    return 0;
}

在这个例子中，auto 推导出变量 p 的类型为 int*，与原始指针 ptr 类型相同。

输出：

p points to: 100

auto 与函数返回类型

auto 不仅可以用于变量声明，还可以用于函数的返回类型。当返回类型较为复杂或需要根据返回的表达式推导时，auto 可以简化代码。

#include <iostream>
#include <vector>

auto get_sum(const std::vector<int>& vec) {
    int sum = 0;
    for (auto v : vec) {
        sum += v;
    }
    return sum;  // 返回类型由 auto 自动推导
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::cout << "Sum: " << get_sum(vec) << std::endl;
    return 0;
}

在这个示例中，auto 用于函数 get_sum 的返回类型，编译器根据 sum 变量的类型推导出返回值的类型。

输出：

Sum: 15

auto 与模板

auto 也可以与模板结合使用，尤其是在模板函数中，允许推导类型从而使得函数更加灵活。使用 auto 可以避免显式指定模板参数，从而简化模板代码。

#include <iostream>

template <typename T>
auto add(T a, T b) {
    return a + b;  // 返回类型自动推导
}

int main() {
    std::cout << add(1, 2) << std::endl;    // 输出 3
    std::cout << add(1.5, 2.5) << std::endl; // 输出 4.0

    return 0;
}

在这个示例中，auto 自动推导 add 函数的返回类型，无论是整型还是浮点型，都能正确处理。

输出：

3
4

注意

1. auto 不能用于函数参数类型 auto 只能用于变量声明和返回类型，不能用于函数的参数类型。例如，以下代码是错误的：

   auto add(auto a, auto b) { // 错误，auto 不能用于函数参数类型
       return a + b;
   }
   

2. auto 与引用、常量结合 当使用 auto 时，变量的类型是根据初始化表达式的类型来推导的。如果需要引用或常量，应该明确使用 auto& 或 const auto& 来推导引用类型或常量类型。

   const auto& ref = some_variable; // 推导为 const 引用
   

3. 类型推导的限制 编译器根据初始化表达式推导类型，但不能从不完整的类型推导。因此，必须确保变量在声明时能够通过表达式推导出类型。

变量与常量

一、基本概念

在 C++ 中，变量 (Variable) 是内存中的一块可命名的存储空间，用于保存数据值。 常量 (Constant) 则是在程序执行期间不能被修改的值。

变量与常量是程序存储数据和表达逻辑的基础。

二、变量 (Variable)

1. 定义变量

变量在使用前必须定义。定义时需指定类型，并可选地赋初值。

int age = 20;        // 定义并初始化一个整型变量
double weight;       // 定义一个浮点型变量，但未初始化
char grade = 'A';    // 定义并初始化一个字符型变量

建议始终初始化变量，避免使用未定义的值（否则可能产生未定义行为）。

2. 变量的命名规则

变量的命名要求符合一定的命名规则，具体可参考命名规则，可简要总结为：

1. 只能包含字母、数字和下划线 _

2. 不能以数字开头

3. 区分大小写 (score 与 Score 不同)

4. 不能使用 C++ 关键字 (int, return 等)

5. 应体现变量含义，例如：

   int studentCount;  // 好
   int sc;            // 不推荐
   

3. 变量的作用域与生命周期

(1)作用域 (Scope)

变量的可见范围取决于其定义位置：

int globalVar = 10;  // 全局变量

void func() {
    int localVar = 5;  // 局部变量
}

(2)生命周期 (Lifetime)

• 局部变量：进入作用域时创建，离开作用域时销毁。
• 全局变量/静态变量：程序启动时创建，程序结束时销毁。

void counter() {
    static int count = 0; // 静态局部变量，只初始化一次
    count++;
    std::cout << count << std::endl;
}

4. 变量的存储类型说明符

extern int count; // 声明外部变量
auto x = 3.14;    // 类型自动推断为 double

还有更多的变量修饰符，详见基本数据类型。

三、常量 (Constant)

1. 字面值常量 (Literal Constant)

直接出现在代码中的固定值：

123          // 整数常量
3.14         // 浮点常量
'a'          // 字符常量
"Hello"      // 字符串常量
true, false  // 布尔常量

有时候会以宏定义的方式存在，例如#define pi 3.14，在预处理阶段完成替换处理，本质上还是字面值常量。

使用宏替换的方式，被替换的常量在编译出来的二进制中会重复存在，因此使用constexpr会提高空间利用率。

2. const 常量

const 修饰的变量一旦初始化，其值不能被修改，因此const常量本质上是不可变化的变量：

const double PI = 3.14159;
PI = 3.14; // 错误：不能修改常量

常量指针与指向常量的指针

Tip

指针常量和常量指针各是什么，有什么区别？

指针常量是指定义了一个指针，这个指针的值只能在定义时进行初始化，其他时候不能改变。

常量指针是指定义了一个指针，这个指针指向了一个只读的对象，不能通过常量指针来修改这个对象的值。

指针常量强调的是指针本身的不可改变性，而常量指针强调的是指针对其所指对象的不可改变性。

无论是指针常量还是常量指针，其最大的用途就是作为函数的形式参数，保证实参在被调用函数中的不可改变特性。

3. constexpr 常量表达式（C++11 起）

constexpr 表示在编译期即可确定值的常量。它比 const 更严格：

constexpr int max_size = 100;
constexpr int square(int x) { return x * x; }

int arr[square(4)]; // 编译期确定数组大小

const 表示值不可改，而 constexpr 表示在编译时确定值。

4. 枚举常量 (Enumeration)

枚举用于定义一组命名的整型常量：

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

自定义起始值：

enum ErrorCode { OK = 0, NotFound = 404, ServerError = 500 };

四、变量与常量的对比

五、示例代码

#include <iostream>
using namespace std;

constexpr double PI = 3.14159;

int main() {
    int radius = 5;
    const double area = PI * radius * radius;

    cout << "半径：" << radius << endl;
    cout << "圆面积：" << area << endl;

    // area = 100; // 常量不可修改
    return 0;
}

输出：

半径：5
圆面积：78.5397

控制结构（Control Structures）

在 C++ 中，控制结构用于控制程序语句的执行顺序。C++ 的控制流主要分为三种类型：

1. 顺序结构：从上到下依次执行语句，是程序的默认执行方式。
2. 选择结构：根据条件判断，执行不同的分支语句。
3. 循环结构：重复执行一段代码，直到某个条件满足为止。

在理解控制结构时，最关键的是掌握表达式求值时机、作用域规则与循环/分支退出机制。

一、循环结构（Loop Structure）

循环结构的本质是在某个条件满足时重复执行代码块。 C++ 提供了三种主要循环语法：for、while 和 do...while。

虽然三者都能实现循环逻辑，但它们在执行顺序与条件判断时机上存在显著差异。

1. for 循环

for (初始化表达式; 条件表达式; 迭代表达式) {
    // 循环体
}

在执行时，for 循环遵循如下过程：

1. 初始化表达式在循环开始时执行一次；
2. 计算条件表达式，若为 true，则进入循环体；
3. 执行循环体中的语句；
4. 执行迭代表达式（通常为自增或自减操作）；
5. 再次判断条件表达式；
6. 若条件仍为真，继续循环；否则退出循环。

#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 5; ++i) {
        cout << "当前 i = " << i << endl;
    }
}

程序执行顺序如下：

初始化：i = 0
判断条件：i < 5 → true
执行循环体：输出 i
迭代表达式：i++
再判断...

• 局部作用域：在 for 循环中声明的变量（如 int i）仅在循环内部可见，循环结束后变量被销毁。

• 可省略项：

  for (;;) {
      // 无限循环
  }
  

  如果条件表达式被省略，默认为 true。

• 循环控制建议：

  • 在循环内部修改循环变量容易出错；
  • 条件表达式应当保证能在有限次迭代后终止，否则会造成死循环。

C++11 引入了基于范围的 for 循环（range-based for loop）：

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

int main() {
    vector<int> nums = {1, 2, 3, 4, 5};
    for (int x : nums) {
        cout << x << " ";
    }
}

等价于传统形式：

for (auto it = nums.begin(); it != nums.end(); ++it)
    cout << *it << " ";

这种写法更简洁、安全，也更符合 STL 容器的使用习惯。

2. while 循环

while (条件表达式) {
    // 循环体
}

while 循环先判断条件，再执行循环体。执行流程如下：

1. 判断条件；
2. 若条件为 true，执行循环体；
3. 循环体执行完毕后，再次判断条件；
4. 若条件为 false，循环终止。

int i = 0;
while (i < 5) {
    cout << "i = " << i << endl;
    ++i;
}

与 for 相比，while 更适用于循环次数不确定但终止条件明确的情况，例如文件读取或网络接收：

string line;
while (getline(cin, line)) {
    cout << line << endl;
}

这种结构常见于 IO 流循环，因为输入次数事先未知。

一个经典的初学者错误：

int i = 0;
while (i < 10);
{
    cout << i << endl;
    ++i;
}

这里的分号 ; 结束了 while 语句，导致循环体为空。 实际运行时这段代码会陷入死循环，因为条件判断永远为真而循环体无法修改变量。

3. do...while 循环

do {
    // 循环体
} while (条件表达式);

与 while 不同，do...while 先执行循环体一次，再判断条件。 因此，无论条件是否为真，循环体至少会被执行一次。

int n;
do {
    cout << "请输入一个正数：";
    cin >> n;
} while (n <= 0);

程序会反复要求输入，直到输入值大于零。 这种结构常用于需要先执行一次再决定是否继续的交互逻辑。

4. 循环控制语句

• break —— 提前结束循环

  break 用于立即终止当前循环或 switch 语句，不会再执行后续的循环体和条件判断。

  for (int i = 0; i < 10; ++i) {
      if (i == 5)
          break;
      cout << i << " ";
  }
  

• continue —— 跳过当前迭代

  continue 会跳过本次循环剩余部分，直接进入下一次条件判断。

  for (int i = 0; i < 10; ++i) {
      if (i % 2 == 0)
          continue; // 跳过偶数
      cout << i << " ";
  }
  

• goto —— 无条件跳转（极少使用）

  int i = 0;
  loop_start:
  if (i < 5) {
      cout << i << endl;
      ++i;
      goto loop_start;
  }
  

  虽然语法合法，但这种写法不符合结构化编程思想，现代 C++ 中几乎不使用。

5. 嵌套循环与性能考量

循环可以嵌套，例如输出九九乘法表：

for (int i = 1; i <= 9; ++i) {
    for (int j = 1; j <= i; ++j) {
        cout << j << "x" << i << "=" << i * j << "\t";
    }
    cout << endl;
}

嵌套循环会带来O(n²) 级别的时间复杂度，因此在数据量大时应当考虑优化：

• 减少内层循环的迭代次数；
• 将不必要的计算提前至循环外；
• 使用 break 或条件提前退出。

二、判断结构（Selection Structure）

判断结构的目的是让程序在不同条件下执行不同语句。 C++ 提供了两种主要形式：if 与 switch，另有三目运算符用于简单条件判断。

1. if 条件语句

if (条件表达式) {
    // 条件成立时执行
}
else {
    // 条件不成立时执行
}

在执行时，编译器首先计算条件表达式的布尔值：

• 若为 true，执行 if 块；
• 否则执行 else 块（如果存在）。

除此以外，if还支持多分支判断：

if (score >= 90)
    cout << "优秀";
else if (score >= 80)
    cout << "良好";
else if (score >= 60)
    cout << "及格";
else
    cout << "不及格";

编译器从上至下依次判断条件表达式。 当某个条件为真时，后续分支将被跳过。

• 短路求值（short-circuit evaluation）

逻辑运算符 && 和 || 在判断中具有短路行为：

if (x != 0 && 10 / x > 1)  // 安全

若 x == 0，第一个条件为 false，第二个表达式不会被求值，从而避免除零错误。 短路机制是 C++ 逻辑判断中非常重要的性能与安全特性。

• 悬挂 else（dangling else）问题

if (a > 0)
    if (b > 0)
        cout << "A";
    else
        cout << "B";

此时 else 默认匹配最近的未匹配 if，即第二个 if。 建议始终使用大括号 {} 明确逻辑边界。

2. switch 语句

switch (表达式) {
    case 常量1:
        // 语句
        break;
    case 常量2:
        // 语句
        break;
    default:
        // 默认语句
        break;
}

switch 表达式的值会与每个 case 标签进行匹配，若相等，则从该处开始执行，直到遇到 break 或 switch 结束。

int day = 3;
switch (day) {
    case 1: cout << "Monday"; break;
    case 2: cout << "Tuesday"; break;
    case 3: cout << "Wednesday"; break;
    default: cout << "Invalid";
}

• 语义分析与注意事项

• switch 的判断值必须是整数类型或枚举类型；

• case 标签必须是常量表达式；

• 若 break 省略，将导致贯穿 (fall through)，继续执行后续分支；

• default 分支可选，但建议始终保留。

• 现代 C++ 的枚举与 switch

enum class Color { Red, Green, Blue };

Color c = Color::Green;
switch (c) {
    case Color::Red: cout << "Red"; break;
    case Color::Green: cout << "Green"; break;
    case Color::Blue: cout << "Blue"; break;
}

使用 enum class 可避免命名冲突和隐式转换，提高类型安全性。

3. 条件运算符（三目运算符）

C++ 提供了简洁的条件表达式：

表达式1 ? 表达式2 : 表达式3;

求值逻辑：

• 若表达式1为真，则整个表达式结果为表达式2；
• 否则结果为表达式3。

示例：

int a = 10, b = 20;
int max = (a > b) ? a : b;

该语句的效果等价于：

if (a > b) max = a;
else max = b;

三目运算符常用于简单赋值，但不适合复杂逻辑，因为可读性较差。

操作符（Operators）

操作符（Operator）是 C++ 表达式的核心组成部分，用于对操作数（Operand）进行各种运算、比较或逻辑处理。 在编译阶段，操作符会被转化为相应的汇编指令或函数调用（例如运算符重载时）。

C++ 拥有丰富的操作符体系，并且允许程序员通过运算符重载（operator overloading）定义自定义类型的操作方式，从而实现与内置类型一致的自然语法。

一、操作符的分类

二、算术操作符（Arithmetic Operators）

1. 基本算术运算

示例：

int a = 10, b = 3;
cout << a + b << endl; // 13
cout << a - b << endl; // 7
cout << a * b << endl; // 30
cout << a / b << endl; // 3
cout << a % b << endl; // 1

2. 注意事项

• 整数除法：两个整数相除结果仍为整数，小数部分会被截断。

• 浮点除法：若任一操作数为浮点型，则结果为浮点数。

• 取余运算 %：仅适用于整数类型。

• 负数取余：结果的符号与被除数相同，例如：

  cout << (-7) % 4; // 输出 -3
  

三、自增与自减操作符（++ 与 --）

1. 区分前置与后置

同理适用于 --。

2. 编译层面的区别

前置自增：

int& operator++(int& i) { i += 1; return i; }

后置自增：

int operator++(int& i, int) { int old = i; ++i; return old; }

因此后置版本通常会创建临时对象，性能略低。

四、关系操作符（Relational Operators）

用于比较两个值的大小或相等性，结果为 bool 类型。

int a = 5, b = 10;
cout << (a < b) << endl;  // 1
cout << (a == b) << endl; // 0

五、逻辑操作符（Logical Operators）

逻辑操作符用于布尔表达式组合，返回 true 或 false。

短路求值（short-circuit evaluation）是逻辑运算的重要特性，它不仅提升性能，也避免非法运算（例如除零）。

if (ptr != nullptr && *ptr > 10)
    cout << "安全访问";

六、位操作符（Bitwise Operators）

位操作符直接作用于整数的二进制表示。

示例：

unsigned int a = 5;  // 00000101
unsigned int b = 3;  // 00000011
cout << (a & b);     // 00000001 -> 1
cout << (a | b);     // 00000111 -> 7
cout << (a ^ b);     // 00000110 -> 6
cout << (~a);        // 11111010 -> 取反

注意：

• 位移运算的右操作数必须为非负；
• 有符号右移的高位填充由实现定义；
• 通常使用无符号类型进行位操作以避免歧义。

七、赋值与复合赋值操作符（Assignment Operators）

1. 基本赋值

int x = 10;

2. 复合赋值

复合赋值的优点是只计算一次左值，因此在复杂左值表达式中效率更高：

arr[getIndex()] += 10; // getIndex() 只调用一次

八、条件运算符（Ternary Operator）

三目运算符语法：

条件 ? 表达式1 : 表达式2;

示例：

int max = (a > b) ? a : b;

等价于：

if (a > b)
    max = a;
else
    max = b;

注意：

• 运算符返回一个值，因此可嵌入表达式；
• 但应避免多层嵌套，影响可读性。

九、逗号运算符（Comma Operator）

逗号运算符从左到右依次求值，整个表达式的结果是最后一个表达式的值：

int a = (b = 3, b + 2); // b=3执行后，再计算b+2，a=5

在 for 循环中常见：

for (int i = 0, j = 10; i < j; ++i, --j)
    cout << i << " " << j << endl;

十、成员与指针操作符（Member & Pointer Operators）

示例：

struct Test { int x; void show() { cout << x; } };
Test t{42};
Test* p = &t;
cout << t.x;    // 使用 .
cout << p->x;   // 使用 ->

十一、指针相关操作符

这两个符号在声明与使用中含义不同：

int* p;   // 声明指针类型
*p = 10;  // 解引用赋值

十二、类型转换操作符（Cast Operators）

1. C 风格强制类型转换

int a = 10;
double b = (double)a;

2. C++ 风格强制类型转换

示例：

Base* b = new Derived();
Derived* d = dynamic_cast<Derived*>(b); // 安全类型检查

十三、其他特殊操作符

1. sizeof

返回对象或类型的字节大小，结果类型为 size_t：

cout << sizeof(int); // 通常为4

对数组时返回整个数组的大小，而不是指针大小：

int arr[10];
cout << sizeof(arr); // 40 (假设int为4字节)

2. typeid

用于在运行时获取类型信息，常与 RTTI（运行时类型识别）配合使用。

#include <typeinfo>
int a = 5;
cout << typeid(a).name(); // 输出类型名

3. new 与 delete

动态内存分配与释放：

int* p = new int(10);
delete p;

int* arr = new int[5];
delete[] arr;

new 会自动调用构造函数，而 delete 调用析构函数。

十四、运算符优先级与结合性

建议使用括号明确运算顺序，尤其在混合表达式中。

十五、运算符重载（Operator Overloading）

C++ 允许为自定义类型定义运算符行为，让类的对象也能像内置类型一样使用 +、==、<< 等符号：

class Vector {
public:
    int x, y;
    Vector(int x, int y): x(x), y(y) {}
    Vector operator+(const Vector& v) const {
        return Vector(x + v.x, y + v.y);
    }
};

使用：

Vector a(1, 2), b(3, 4);
Vector c = a + b; // 等价于 a.operator+(b)

注意：

• 不能重载 .、::、?:、sizeof；
• 运算符重载不会改变操作符优先级；
• 应保证语义一致性（例如重载 == 时应与 != 保持逻辑对称）。

运算符重载的完整规则——成员函数与友元函数的选择、各类运算符的重载方式、返回值设计以及常见陷阱——属于面向对象进阶内容，详见 运算符重载。

函数 (Functions)

函数是 C++ 程序的基本组成部分，它们用于将程序分解为可管理、可重复使用的代码块。

一、函数的基本概念

1. 定义

函数是一段执行特定任务的命名代码块。

2. 优点

• 模块化 (Modularity): 使程序结构清晰，易于理解和维护。
• 代码重用 (Code Reusability): 一次编写，多次调用，避免重复劳动。
• 简化调试 (Easier Debugging): 易于隔离和测试代码。

二、函数的构成要素

一个函数通常由以下几个部分组成：

1. 函数原型 (Function Prototype) / 函数声明 (Declaration)

告诉编译器函数的名称、返回类型和参数列表，但没有函数体。

格式:

返回类型 函数名(参数类型 参数名, ...);

示例:

int add(int a, int b); // 函数原型

• 注意: 函数原型通常放在 main 函数之前或头文件 (.h 文件) 中。

2. 函数定义 (Function Definition)

包含函数头和函数体（实际执行的代码）。

格式:

返回类型 函数名(参数类型 参数名, ...)
{
    // 函数体：执行任务的代码
    // ...
    return 表达式; // 如果返回类型不是 void
}

示例:

int add(int a, int b) // 函数头
{
    // 函数体
    return a + b;
}

3. 函数调用 (Function Call)

在程序中执行函数。

格式:

函数名(实参1, 实参2, ...);

示例:

int sum = add(5, 3); // 调用 add 函数，5 和 3 是实参

三、函数的关键要素

1. 返回类型 (Return Type)

函数执行完毕后返回给调用者的值的类型。

• 可以是任何有效的数据类型（如 int, double, bool, 自定义类型等）。
• void: 如果函数不返回任何值，则使用 void。

2. 函数名 (Function Name)

用于唯一标识函数。遵循 C++ 命名规则。

3. 参数 (Parameters) / 形参 (Formal Parameters)

定义在函数头中，用于接收调用者传递的数据。

• 格式: 类型 名称 (例如 int x)

4. 实参 (Arguments)

调用函数时传递给形参的实际值。

5. return 语句

用于：

• 返回值: 将一个值返回给调用者。
• 结束执行: 立即终止函数的执行。
• 注意: 对于返回类型非 void 的函数，必须有 return 语句返回一个与返回类型兼容的值。

四、参数传递 (Argument Passing)

函数调用时，将实参的值复制或引用到形参中，主要有三种方式：

1. 值传递 (Pass by Value) (最常用)

• 机制: 将实参的值复制给形参。

• 效果: 函数内部对形参的任何修改，不会 影响到外部的实参。

• 声明:

  void func(int x); // x 是一个副本
  

2. 地址传递 (Pass by Pointer) (C 风格，C++ 中不推荐)

• 机制: 传递实参的内存地址（指针）。

• 效果: 函数可以通过指针修改实参的值。

• 声明:

  void func(int *ptr); // ptr 是一个指向 int 的指针
  

3. 引用传递 (Pass by Reference) (C++ 推荐)

• 机制: 形参成为实参的别名（引用）。

• 效果: 函数内部对形参的任何修改，会 直接影响到外部的实参。

• 声明:

  void func(int &ref); // ref 是实参的引用
  

  • 优点: 既能修改外部变量，又避免了指针的复杂性和值传递的开销。

五、函数的进阶特性

1. 默认参数 (Default Arguments)

允许在函数声明时给参数设定一个默认值。调用时若不提供该实参，则使用默认值。

• 规则: 默认参数必须从右向左依次设置。一旦一个参数有了默认值，它右边的所有参数都必须有默认值。

示例:

void print_info(int a, int b = 10, int c = 20); // b 和 c 是默认参数

// 调用方式
print_info(1);      // a=1, b=10, c=20
print_info(1, 5);   // a=1, b=5, c=20
print_info(1, 5, 8); // a=1, b=5, c=8

2. 函数重载 (Function Overloading)

在同一作用域内，允许存在多个同名函数，但它们的 参数列表 必须不同（数量、类型或顺序）。

• 作用: 使程序能够使用一个统一的名称来执行相似但操作不同数据类型的任务。

示例:

int operate(int a, int b)
{ return a + b; }

double operate(double a, double b)
{ return a * b; }

int operate(int a) // 与前两个函数参数数量不同
{ return a * a; }

3. 内联函数 (Inline Functions)

使用 inline 关键字修饰的函数。

• 目的: 建议编译器在函数被调用的地方直接将函数体的代码展开，而不是执行常规的函数调用机制。
• 优点: 消除函数调用开销，提高小函数的执行效率。
• 缺点: 可能导致代码膨胀（占用更多内存）。
• 适用场景: 函数体非常简单（只有一两行代码）的情况。

示例:

inline int square(int x) { return x * x; }

• 注意: inline 只是对编译器的建议，编译器可以忽略它。

示例代码

#include <iostream>

// 函数原型 (声明)
int add(int a, int b);
void swap_by_ref(int &x, int &y);

// 带有默认参数的函数原型
void greet(std::string name, std::string greeting = "Hello");

// main 函数 (程序入口)
int main() {
    int num1 = 10, num2 = 5;

    // 1. 函数调用
    int sum = add(num1, num2); // num1, num2 是实参
    std::cout << "Sum: " << sum << std::endl; // 输出: 15

    // 2. 引用传递示例
    int x = 100, y = 200;
    std::cout << "Before swap: x=" << x << ", y=" << y << std::endl;
    swap_by_ref(x, y); // 交换 x 和 y 的值
    std::cout << "After swap: x=" << x << ", y=" << y << std::endl; // 输出: x=200, y=100

    // 3. 默认参数示例
    greet("Alice");           // 使用默认问候语: Hello Alice
    greet("Bob", "Good Morning"); // 使用自定义问候语: Good Morning Bob

    return 0;
}

// 函数定义
int add(int a, int b) // a, b 是形参 (值传递)
{
    return a + b;
}

// 引用传递实现值交换
void swap_by_ref(int &x, int &y) // x, y 是引用
{
    int temp = x;
    x = y;
    y = temp;
    // x 和 y 的改变会影响到 main 函数中的实参
}

// 默认参数实现
void greet(std::string name, std::string greeting)
{
    std::cout << greeting << " " << name << std::endl;
}

Lambda 表达式

Lambda 表达式（C++11 引入）用于在调用点就地定义一个匿名函数对象。它让「把函数作为参数传递」变得极为简洁，是标准库算法、回调、异步任务中最常用的语法之一。

Lambda 的本质是编译器生成的一个闭包类型（closure type）——一个重载了 operator() 的匿名类。因此它和手写的函数对象在行为上完全等价，只是写法更紧凑。

一、基本语法

[capture](parameters) -> return_type { body }

最简单的形式：

auto add = [](int a, int b) { return a + b; };
std::cout << add(3, 4);   // 7

返回类型通常可以省略。但如果函数体中有多个 return 语句且类型不一致，就必须显式指定：

auto f = [](int x) -> double {
    if (x > 0) return x * 1.0;
    return 0.0;
};

二、捕获列表

捕获列表决定 lambda 内部能访问哪些外部变量，以及访问方式。

1. 按值捕获与按引用捕获

int a = 10, b = 20;

auto byValue = [a] { return a; };        // 拷贝 a
auto byRef   = [&b] { return b; };       // 引用 b

a = 100;
b = 200;

std::cout << byValue();   // 10（捕获时的副本）
std::cout << byRef();     // 200（引用的是原变量）

2. mutable

按值捕获的变量在 lambda 内默认是 const 的，要修改副本必须加 mutable：

int count = 0;

auto counter = [count]() mutable {
    return ++count;   // 修改的是副本
};

std::cout << counter();   // 1
std::cout << counter();   // 2
std::cout << count;       // 0（原变量未变）

Warning

按引用捕获的生命周期陷阱

lambda 不会延长被引用对象的生命周期。如果 lambda 的生命周期超过了被引用变量，就会产生悬垂引用：

auto makeLambda()
{
    int local = 42;
    return [&local] { return local; };   // 错误：local 已销毁
}

auto f = makeLambda();
f();   // 未定义行为

需要返回 lambda 时，应改为按值捕获。

3. 初始化捕获（C++14）

初始化捕获（init-capture）允许在捕获时执行表达式，并给捕获的变量起新名字：

// 移动捕获：把 move-only 对象移入 lambda
auto ptr = std::make_unique<int>(42);
auto f = [p = std::move(ptr)] { return *p; };   // ptr 被移入 lambda

// 捕获时计算
int x = 10;
auto g = [y = x * 2] { return y; };   // y = 20

这是唯一能把 move-only 类型（如 unique_ptr）放进 lambda 的方式。

4. 捕获 this

在成员函数中，[this] 捕获的是指针，[*this]（C++17）捕获的是对象副本：

class Widget
{
    int value_ = 42;

public:
    auto byPointer()
    {
        return [this] { return value_; };   // 引用当前对象
    }

    auto byCopy()
    {
        return [*this] { return value_; };  // 拷贝整个对象（C++17）
    }
};

[this] 的 lambda 在对象销毁后调用会悬垂；[*this] 则安全。

三、泛型 Lambda

C++14 起，参数可以用 auto，此时 lambda 的 operator() 变成一个模板：

auto print = [](auto x) { std::cout << x << '\n'; };

print(42);        // int
print("hello");   // const char*
print(3.14);      // double

C++20 起可以显式写模板参数列表，从而使用 Concepts 约束：

auto add = []<typename T>(T a, T b) { return a + b; };

// 带约束
auto integralAdd = []<std::integral T>(T a, T b) { return a + b; };

显式模板参数还能解决一个常见问题——对 vector 的 size() 求值：

// C++20 前：需要额外处理
auto before = [](auto&& v) { return v.size(); };

// C++20：可以正确推导
auto after = []<typename T>(std::vector<T> const& v) { return v.size(); };

四、其它特性

1. constexpr Lambda（C++17）

如果 lambda 满足 constexpr 函数的要求，operator() 自动是 constexpr：

constexpr auto square = [](int x) { return x * x; };
static_assert(square(5) == 25);

2. 无捕获 Lambda 转换为函数指针

无捕获的 lambda 可以隐式转换为函数指针，因此能传给 C 风格 API：

void c_function(int (*callback)(int));

c_function([](int x) { return x * 2; });   // OK：无捕获

有捕获的 lambda 不能这样转换，因为需要携带状态。

3. 立即调用

lambda 定义后可以立刻调用，常用于初始化复杂常量：

const int value = [] {
    // 复杂的计算过程
    return 42;
}();

4. 递归 Lambda

lambda 无法直接调用自己（因为名字还没定义完）。常见做法是把自己作为参数传入：

auto factorial = [](auto self, int n) -> int {
    return n <= 1 ? 1 : n * self(self, n - 1);
};

std::cout << factorial(factorial, 5);   // 120

C++23 起可以用 this auto self 显式对象参数，写法更自然：

auto factorial = [](this auto self, int n) -> int {
    return n <= 1 ? 1 : n * self(n - 1);
};

五、与函数对象的关系

lambda 在编译期被展开成一个匿名类：

int threshold = 10;
auto pred = [threshold](int x) { return x > threshold; };

// 大致等价于：
class __Lambda
{
    int threshold_;
public:
    __Lambda(int t) : threshold_(t) {}
    bool operator()(int x) const { return x > threshold_; }
};

这解释了 lambda 的几个特性：

• 每个 lambda 都有独一无二的类型，因此不能用 decltype 之外的方式声明，通常用 auto 接收。
• 两个写法相同的 lambda 也是不同类型。
• 需要存储 lambda 时，如果类型必须统一，可以用 std::function（有类型擦除开销）。

六、常见用法

配合标准库算法是最典型的场景：

std::vector<int> v{5, 2, 8, 1, 9};

// 排序：按绝对值降序
std::sort(v.begin(), v.end(), [](int a, int b) {
    return std::abs(a) > std::abs(b);
});

// 查找：第一个大于 5 的元素
auto it = std::find_if(v.begin(), v.end(), [](int x) { return x > 5; });

// 统计：偶数个数
int evens = std::count_if(v.begin(), v.end(), [](int x) { return x % 2 == 0; });

// 变换：每个元素平方
std::transform(v.begin(), v.end(), v.begin(), [](int x) { return x * x; });

// 移除：删除所有小于 3 的元素
v.erase(std::remove_if(v.begin(), v.end(), [](int x) { return x < 3; }), v.end());

七、注意事项

• 按引用捕获有生命周期风险。lambda 不会延长被引用对象的生命周期，返回 lambda 时应按值捕获。
• [=] 捕获 this 是陷阱。在成员函数中，[=] 捕获的是 this 指针而非对象副本，对象销毁后调用会悬垂。C++20 起这种隐式捕获已被弃用，应显式写 [this] 或 [*this]。
• mutable 只影响副本。加了 mutable 后修改的是 lambda 内部的副本，原变量不变。
• 每个 lambda 类型唯一。不要试图写出 lambda 的类型，用 auto 或 std::function。
• std::function 有开销。它涉及类型擦除和可能的堆分配，性能敏感处应直接用 auto 或模板参数。
• 捕获列表不能捕获类成员。[x] 中的 x 必须是变量，类成员需要用 [x = x] 或 [this]。
• 无捕获 lambda 才能转函数指针。有捕获的 lambda 携带状态，无法转换。

八、相关章节

• 函数：函数对象与函数指针
• 模板：泛型 lambda 与模板的关系
• Utility：std::function 与 std::bind
• Algorithms：算法中 lambda 的典型用法
• 多线程与并发：lambda 作为线程函数

类与对象

C++ 是一种支持面向对象编程（Object-Oriented Programming, OOP）的语言。 在面向对象的设计思想中，类（Class）是 C++ 的核心特性之一，常被称为用户自定义的数据类型（user-defined type）。

类用于定义对象的结构与行为，是一种将数据与操作这些数据的函数封装在一起的抽象描述。 在类中，用于存储数据的部分称为成员变量（Member Variables），而用于操作这些数据的函数称为成员函数（Member Functions）。

类本质上是一种模板（Template）或蓝图（Blueprint），通过它可以创建出多个具有相同属性和行为的具体实例，这些实例被称为对象（Objects）。每个对象都拥有属于自己的成员变量副本，并可以通过成员函数来执行特定的操作。

一、类的结构

在 C++ 中，类（Class）是一种由用户定义的数据类型（User-defined Data Type）， 它将数据（成员变量）与操作数据的函数（成员函数）有机地结合在一起， 从而实现封装（Encapsulation）与抽象（Abstraction）。

一个类的基本结构如下：

class ClassName {
private:
    // 私有成员（数据与函数）
protected:
    // 受保护成员
public:
    // 公有成员
};

1. 类的基本组成

类由以下几个主要部分构成：

2. 访问控制符（Access Specifiers）

访问控制符用于限定类成员的可见性和访问范围：

示例：

class Example {
private:
    int secret;          // 私有成员
protected:
    int semi_secret;     // 受保护成员
public:
    int visible;         // 公有成员
};

默认情况下，class 的成员默认是 private， 而 struct 的成员默认是 public。

3. 成员变量（Member Variables）

成员变量用于存储对象的状态。 每个对象都会拥有独立的一份成员变量副本。

class Student {
private:
    std::string name;
    int age;
};

成员变量可以是基本类型、对象、指针、引用、数组、容器等。

也可以为成员变量提供默认初始值（C++11 起支持）：

class Point {
    int x = 0;
    int y = 0;
};

4. 成员函数（Member Functions）

成员函数用于定义对象的行为，通常用于访问和修改成员变量。

class Student {
private:
    std::string name;
    int age;

public:
    void setInfo(const std::string& n, int a) {
        name = n;
        age = a;
    }

    void display() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

也可以在类外定义成员函数：

void Student::display() {
    std::cout << "Name: " << name << ", Age: " << age << std::endl;
}

5. 构造函数（Constructor）

构造函数在对象创建时自动执行，用于初始化成员变量。 它与类同名，无返回值。

class Student {
private:
    std::string name;
    int age;

public:
    // 构造函数
    Student(const std::string& n, int a) : name(n), age(a) {
        std::cout << "Constructor called." << std::endl;
    }
};

构造函数的种类包括：

构造函数支持多态，可以使用多个参数不同的构造函数，在使用时会自动匹配。

6. 析构函数（Destructor）

析构函数在对象销毁时自动调用，用于资源释放或清理。

class Student {
public:
    ~Student() {
        std::cout << "Destructor called." << std::endl;
    }
};

析构函数名以 ~ 开头，无参、无返回值，每个类最多有一个析构函数。

7. this 指针

this 是一个隐含指针，指向调用成员函数的当前对象。 它可用于区分成员变量与同名参数：

class Student {
private:
    std::string name;

public:
    Student(const std::string& name) {
        this->name = name; // 区分成员变量与参数
    }
};

8. 静态成员（Static Members）

静态成员属于类本身，而非具体对象。 所有对象共享同一份静态数据。

静态成员分为两类：

1. 静态成员变量（Static Member Variables）
2. 静态成员函数（Static Member Functions）

(1)静态成员变量

静态成员变量在所有对象之间共享同一份存储空间。 它不依赖于任何对象存在，无论创建多少个对象，这个变量都只有一份。

因此，静态成员变量常用于表示类级别的公共信息，例如计数器、配置、全局状态等。

class Counter {
public:
    static int count;
    Counter() { count++; }
};

int Counter::count = 0;

(2)静态函数变量

静态成员函数同样属于类本身，而不是对象。 它的主要特征是：

• 不依赖任何对象实例
• 无法访问非静态成员变量或函数（因为没有具体对象可供操作）
• 通常用于类级别的操作，如访问静态数据或执行与对象无关的逻辑。
• 没有 this 指针，因为它不属于任何对象

class Counter {
private:
    static int count;

public:
    Counter() { count++; }

    // 静态成员函数
    static void showCount() {
        std::cout << "Current count: " << count << std::endl;
    }
};

// 类外定义静态变量
int Counter::count = 0;

int main() {
    Counter a, b;
    Counter::showCount();  // 通过类名访问
    a.showCount();         // 也可通过对象访问
}

9. 常成员（const Members）

• 常成员函数：在函数后加 const，表示不修改成员变量。
• 常对象：对象一旦定义，其状态不可更改。

class Point {
private:
    int x, y;

public:
    void display() const {
        std::cout << "(" << x << ", " << y << ")" << std::endl;
    }
};

10. 友元（Friend）

友元函数或友元类可以访问类的私有成员。 这在操作符重载、类间紧密协作时非常有用。

#include <iostream>

class Box {
private:
    int width;
public:
    void set_width(int val){
        width = val;
    }
    friend void printWidth(Box b);
};

void printWidth(Box b) {
    std::cout << "Width: " << b.width << std::endl;
}

int main(){
    Box a;
    a.set_width(20);
    printWidth(a);
}

友元会破坏封装性，应谨慎使用。

友元函数不是成员函数，不能用 对象.函数() 方式调用。它只是可以访问类私有成员的普通函数，调用方式与普通函数相同。

11. 类的组合与嵌套

一个类可以将另一个类作为成员，这种关系称为组合（Composition）。

class Address {
public:
    std::string city;
};

class Person {
public:
    std::string name;
    Address addr;  // 组合
};

当对象销毁时，其组合成员也会自动销毁。

二、对象

在 C++ 中，对象（Object）是类的实例（Instance）。 当我们定义了一个类后，这个类本身只是一个抽象的模板或蓝图， 而对象才是真正占用内存、可操作的具体实体。

类定义了“事物的共性”，对象体现了“事物的个性”。

1. 对象的创建与定义

定义一个类对象与定义普通变量非常相似：

class Student {
public:
    std::string name;
    int age;
};

int main() {
    Student s1;  // 创建对象 s1
    s1.name = "张三";
    s1.age = 20;

    Student s2;  // 再创建一个对象 s2
    s2.name = "李四";
    s2.age = 21;
}

每个对象都有独立的成员变量副本，互不影响。

例如：

s1.age = 20;
s2.age = 21;
// 修改 s1 的 age 不会影响 s2

2. 对象的初始化

当类中定义了构造函数时，对象可以在定义时直接初始化：

class Point {
private:
    int x, y;

public:
    Point(int a, int b) {  // 构造函数
        x = a;
        y = b;
    }

    void show() {
        std::cout << "(" << x << ", " << y << ")" << std::endl;
    }
};

int main() {
    Point p1(1, 2);  // 调用构造函数
    Point p2 = Point(3, 4); // 另一种写法
    p1.show();
    p2.show();
}

注意：对象创建时，构造函数会被自动调用；对象销毁时，析构函数会被自动调用。

3. 对象的作用域与生命周期

对象的生命周期与其定义的位置有关。

示例：

class Example {
public:
    Example() { std::cout << "Constructed\n"; }
    ~Example() { std::cout << "Destructed\n"; }
};

int main() {
    Example local;            // 局部对象
    static Example global;    // 静态对象
    Example* ptr = new Example();  // 动态对象

    delete ptr; // 手动释放
}

输出顺序体现了不同对象的生命周期管理。

4. 对象数组

可以定义一个包含多个对象的数组：

class Point {
public:
    int x, y;
    Point(int a = 0, int b = 0) : x(a), y(b) {}
};

int main() {
    Point arr[3] = { {1,2}, {3,4}, {5,6} };
    for (auto& p : arr)
        std::cout << "(" << p.x << ", " << p.y << ")\n";
}

若类中没有默认构造函数，则必须在定义对象数组时显式提供初始化参数。

5.对象的指针与引用

(1)对象指针

和基本类型类似，可以使用指针指向对象。

Student s1;
Student* ptr = &s1;
ptr->name = "王五";
ptr->age = 22;

使用 -> 运算符访问对象的成员。

也可以使用 new 创建动态对象：

Student* stu = new Student;
stu->name = "赵六";
stu->age = 18;
delete stu; // 释放内存

(2)对象引用

引用可以直接操作已有对象：

Student s1;
Student& ref = s1;
ref.name = "张三";

引用不会创建新对象，只是为已有对象取别名。

6. 对象的拷贝与赋值

当我们用一个对象初始化另一个对象时，会自动调用拷贝构造函数。

class Box {
public:
    int width;
    Box(int w) : width(w) {}
    Box(const Box& b) { // 拷贝构造函数
        width = b.width;
        std::cout << "Copy constructor called\n";
    }
};

int main() {
    Box b1(10);
    Box b2 = b1; // 调用拷贝构造函数
}

赋值操作调用的是赋值运算符（operator=），而不是拷贝构造。

7. const 对象

可以将对象声明为常量，使其内容不可被修改：

class Point {
public:
    int x, y;
    void show() const {
        std::cout << x << ", " << y << std::endl;
    }
};

int main() {
    const Point p = {1, 2};
    p.show();
    // p.x = 5; // 错误：常对象不可修改成员
}

常对象只能调用常成员函数（即声明为 void func() const 的函数）。

8. 对象之间的比较与赋值

对象可以相互赋值：

Student s1, s2;
s1.name = "A";
s2 = s1; // 成员变量逐个拷贝

但若希望对象间的比较（==、< 等）有意义，需要重载运算符（进阶内容，后续讲述）。

9. 对象与内存模型

每个对象在内存中都有独立的成员变量副本：

Student s1 ──► name="张三", age=20
Student s2 ──► name="李四", age=21

而静态成员在所有对象间共享。

三、完整示例

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

class Student {
public:
    string name;
    int age;

    Student(string n = "未知", int a = 0) : name(n), age(a) {
        cout << "Constructed: " << name << endl;
    }

    ~Student() {
        cout << "Destructed: " << name << endl;
    }

    void show() const {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

int main() {
    Student s1("张三", 20);
    Student s2("李四", 21);

    s1.show();
    s2.show();

    Student* p = new Student("王五", 22);
    p->show();
    delete p;  // 手动释放动态对象
}

输出：

Constructed: 张三
Constructed: 李四
Constructed: 王五
Name: 张三, Age: 20
Name: 李四, Age: 21
Name: 王五, Age: 22
Destructed: 王五
Destructed: 李四
Destructed: 张三

四、面向对象的三大特征

面向对象编程（OOP）的核心思想可以概括为三大特征：封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。这三大特征是 C++ 类与对象设计的基础，也是理解和应用面向对象程序设计的关键。

继承与多态的内容属于C++面向对象进阶内容。

1. 封装（Encapsulation）

封装是面向对象最基本的特征之一，也是类和对象概念的核心。

封装的核心思想是将对象的状态（数据）和行为（函数）组合到一个整体——类中，并通过访问控制机制对外部可见性进行限制和保护，对受保护的私有数据仅可以使用成员函数进行操作。

作用：

1. 对内部数据进行保护，只允许可信的方法或对象访问；
2. 隐藏实现细节，使类的使用者无需了解内部工作原理；
3. 提供统一接口，提高模块化和可维护性。

示例：

class Student {
private:
    std::string name; // 私有成员，外部无法直接访问
    int age;

public:
    void setInfo(const std::string& n, int a) { // 提供接口修改数据
        name = n;
        age = a;
    }

    void display() const { // 提供接口访问数据
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

在上例中，name 和 age 仅能通过 setInfo 和 display 访问和修改，这就是封装的典型应用。

封装就是把客观事物封装成抽象类，并控制外部访问权限，保护数据安全并提高代码可维护性。

2. 继承（Inheritance）

继承允许新建的类复用已有类的属性和行为，并在此基础上扩展。被继承的类称为基类（Base Class）或父类，从基类继承的类称为派生类（Derived Class）或子类。

按继承方式不同，基类成员在派生类中的访问级别会发生变化：

class Person {
protected:
    std::string name;
public:
    void setName(const std::string& n) { name = n; }
};

class Student : public Person {   // Student 继承 Person
private:
    int grade;
public:
    void setGrade(int g) { grade = g; }
    void showInfo() const {
        std::cout << "Name: " << name << ", Grade: " << grade << std::endl;
    }
};

Student 复用了 Person 的 name，同时扩展了 grade。继承的主要作用是代码复用和构建类层次结构，它也是实现运行时多态的前提。

继承的完整规则——构造与析构顺序、多重继承、菱形继承与虚继承、using 声明改变访问级别等——见 继承。

需要说明的是，继承并非复用的唯一手段。当类之间是「has-a」（拥有）关系而非「is-a」（是）关系时，应当使用组合：在类中包含另一个类的对象作为成员。设计原则是优先使用组合，而非继承。

3. 多态（Polymorphism）

多态指同一个操作作用于不同对象时表现出不同的行为。C++ 中的多态分为两类：

运行时多态通过基类指针或引用调用虚函数实现：

class Animal {
public:
    virtual void speak() const { std::cout << "Animal sound" << std::endl; }
};

class Dog : public Animal {
public:
    void speak() const override { std::cout << "Woof!" << std::endl; }
};

int main() {
    Animal* a = new Dog();
    a->speak();   // 输出 "Woof!"，根据实际对象类型调用
    delete a;
}

关键在于 speak 被声明为 virtual：通过基类指针调用时，实际执行的是派生类的版本。多态使统一接口处理不同对象成为可能，提高了程序的灵活性和可扩展性。

虚函数的工作机制（虚函数表、动态绑定）、虚析构函数的必要性、纯虚函数与抽象类、override 与 final 等，见 虚函数与多态。

五、小结

封装、继承、多态构成了面向对象设计的基础：

• 封装把数据和操作数据的方法组织在一起，并通过访问控制保护内部状态，本章已完整介绍；
• 继承实现代码复用和类层次结构，深入内容见 继承；
• 多态让统一接口能够处理不同对象，深入内容见 虚函数与多态。

关于运算符重载、友元、拷贝控制、模板高级应用等面向对象的进阶主题，见 面向对象进阶。

模板 (Template)

模板是C++中实现泛型编程的基础工具，泛型编程即以一种独立于任何特定类型的方式编写代码。模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。它允许我们编写与类型无关的代码（如类或函数），从而提高代码的重用性。编译器在编译时会根据用户提供的类型参数，从模板生成具体的类型或函数，这个过程称为模板实例化（Template Instantiation）。

一、模板的基本类型

C++主要有两种模板：

1. 函数模板 (Function Template)

用于创建可处理不同数据类型的函数。

语法:

template <typename T>
T minimum(const T& lhs, const T& rhs) {
    return lhs < rhs ? lhs : rhs;
}

// 或使用 class 关键字，效果等同于 typename
template <class T>
T maximum(const T& lhs, const T& rhs) {
    return lhs > rhs ? lhs : rhs;
}

使用:

int a = 10, b = 20;
int min_val = minimum(a, b);         // 编译器推导 T 为 int
double x = 3.14, y = 1.618;
double max_val = maximum<double>(x, y); // 显式指定 T 为 double

2. 类模板 (Class Template)

用于创建可处理不同数据类型的类，常用于实现容器（如 std::vector、std::pair）。

语法:

template <typename T1, typename T2>
class Pair {
public:
    T1 first;
    T2 second;
    Pair(T1 f, T2 s) : first(f), second(s) {}
    // 成员函数也可以使用模板参数
    void print() const;
};

template <typename T1, typename T2>
void Pair<T1, T2>::print() const {
    // ... 实现细节
}

使用:

Pair<int, double> p(10, 3.14); // 实例化 Pair<int, double> 类

二、模板参数 (Template Parameters)

模板参数可以是以下几种类型：

默认模板参数:

模板参数可以拥有默认值（从C++11开始，函数模板也可以拥有默认模板参数）。

template <typename T, size_t N = 10> // N 的默认值为 10
struct Array { T arr[N]; };
Array<int> a; // N 默认为 10
Array<double, 5> b; // N 显式指定为 5

三、模板特化 (Template Specialization)

模板特化允许为特定的类型参数提供一个不同的实现，以优化性能或处理通用模板无法处理的情况。

1. 完全特化 (Full Specialization)

为模板的所有参数提供具体的类型或值。

语法:

// 原始函数模板
template <typename T>
T process(T value) { /* 通用实现 */ }

// int 类型的完全特化
template <> // 尖括号内为空
int process<int>(int value) {
    // 针对 int 类型的优化或特殊实现
    return value * 2;
}

2. 部分特化 (Partial Specialization)

只对模板的部分参数进行特化，或对参数的形式进行限制（例如，特化为指针类型）。注意：只有类模板可以进行部分特化，函数模板不能。

语法 (类模板):

// 原始类模板
template <typename T1, typename T2>
class MyPair { /* 通用实现 */ };

// 部分特化：当第二个参数为 int 时
template <typename T1>
class MyPair<T1, int> { /* T2 固定为 int 的实现 */ };

// 部分特化：当两个参数都是指针时
template <typename T1, typename T2>
class MyPair<T1*, T2*> { /* 两个参数都是指针的实现 */ };

四、关键字 typename

typename 关键字有两个主要用途：

1. 在模板参数列表中，指示一个模板参数是一个类型参数（等同于 class）。

   template <typename T> // 或 template <class T>
   

2. 在模板定义内部，用于显式告诉编译器一个依赖于模板参数的嵌套名称是一个类型。 这是因为在编译时，编译器无法确定依赖名称是否是一个类型或静态成员。

   template <typename T>
   void func(T value) {
       // 假设 T::InnerType 是 T 内部定义的类型
       typename T::InnerType *ptr; // 必须加 typename
   }
   

五、模板参数推导 (Argument Deduction)

1. 函数模板参数推导

调用函数模板时，编译器通常可以根据传递的实参类型自动推导出模板参数的类型。

template <typename T> void print(T val) { /* ... */ }
print(42);   // 编译器推导 T 为 int
print("abc"); // 编译器推导 T 为 const char*

2. 类模板参数推导 (CTAD, C++17)

从 C++17 开始，类模板的实例化也可以进行类型推导，无需显式指定模板参数。

// 假设 Pair 是一个类模板
// C++17 之前:
Pair<int, double> p1(1, 2.3);

// C++17 之后:
Pair p2(1, 2.3); // 编译器推导为 Pair<int, double>

六、后续内容

本章介绍的是模板的基础语法：函数模板与类模板的定义、模板参数、特化以及类型推导。

模板的进阶应用——SFINAE、可变参数模板、模板元编程、Concepts（C++20）、模板与继承的结合，以及如何用模板替代虚函数获得更高性能——见 类模板与函数模板高级应用。

C++进阶知识

C++进阶部分将深入语言内部机制与底层实现，理解编译器如何处理对象模型、内存布局、虚函数表、模板实例化以及异常机制等。

本部分不再局限于语法层面的使用，而是关注性能、抽象与控制力。内容包括高级内存管理、面向对象、多线程与并发、智能指针等内容。

只有理解语言设计背后的思想，真正做到“以C++思考”，才能具备面向底层系统优化与大型工程开发的能力。

本章内容

C++ 内存管理

内存管理是 C++ 编程中的核心概念之一，它直接影响程序的性能、可靠性和稳定性。C++ 提供了灵活且高效的内存管理机制，这也使得开发者能够更精细地控制程序的内存使用。C++ 中的内存管理分为两大类：静态内存管理和动态内存管理。

在 C++ 中，静态内存管理主要涉及由编译器管理的栈内存，通常用于存储局部变量和函数调用的相关信息。与此不同，动态内存管理则涉及到程序运行时动态分配的内存区域，这通常需要程序员显式地分配和释放内存。

C++ 提供了一些工具来帮助开发者更高效地管理内存，避免内存泄漏、悬空指针和野指针等常见问题。在传统的内存管理方式中，开发者需要通过 new 和 delete 来手动管理动态内存的分配和释放。而为了提高开发效率和安全性，C++11 引入了智能指针，如 std::unique_ptr、std::shared_ptr 和 std::weak_ptr，它们自动管理内存的生命周期，减少了人为错误的可能性。

此外，C++ 还提供了内存池和内存对齐等更底层的内存管理技术，使得开发者可以根据需要进一步优化程序的内存使用。

本章内容

几条经验

在展开细节之前，先把结论摆在这里。后面各章基本都是在解释这几条为什么成立：

• 能用栈就别用堆。栈上分配几乎零成本，而且天然异常安全。只有当对象需要活过当前作用域、或者体积过大时，才考虑堆。
• 不要手写 delete。用 RAII 把资源交给对象管理，让析构函数去释放。手动 delete 的代码在异常路径上几乎必然出错。
• 所有权要明确。一个资源归谁管、什么时候释放，应该在类型上就能看出来。unique_ptr 表示独占，shared_ptr 表示共享，裸指针只表示「我不负责释放」。
• 先想清楚生命周期，再想性能。绝大多数内存 bug 都源于生命周期没理顺，而不是分配次数太多。

内存布局与模型

C++ 程序的内存管理建立在计算机的存储模型(Memory Model)之上。理解程序在内存中的布局，是掌握变量生命周期、作用域、动态分配与释放机制的基础。 一个典型的 C++ 程序在运行时会被划分为多个区域，每个区域负责存储不同类型的数据，并具有各自的生命周期与访问特性。

一、程序的五个内存区域

一个进程的地址空间大致可以分成五块：

高地址
┌──────────────────┐
│      栈 Stack     │  ← 向下增长
├──────────────────┤
│        ↓         │
│                  │
│        ↑         │
├──────────────────┤
│      堆 Heap      │  ← 向上增长
├──────────────────┤
│  BSS 段（未初始化） │
├──────────────────┤
│  Data 段（已初始化）│
├──────────────────┤
│   常量区 .rodata   │
├──────────────────┤
│   代码段 .text     │
└──────────────────┘
低地址

看一段代码，把变量对号入座：

int global_init = 42;        // Data 段
int global_uninit;           // BSS 段
const char* msg = "hello";   // 指针在 Data 段，"hello" 在常量区

void func()
{
    int local = 1;                    // 栈
    static int static_local = 2;      // Data 段（只初始化一次）
    const char* p = "world";          // 指针在栈，"world" 在常量区

    int* heap = new int(3);           // 指针在栈，对象在堆
    delete heap;
}

常量区的字符串是只读的。"hello"[0] = 'H' 是未定义行为，在多数平台上会直接段错误。

二、栈

栈由编译器自动管理，分配和释放只是移动栈指针，因此极快——通常就是一条指令。

栈帧

每次函数调用都会在栈上压入一个栈帧（stack frame），包含：

高地址
┌──────────────────┐
│   调用者的局部变量  │
├──────────────────┤
│   函数参数         │
├──────────────────┤
│   返回地址         │
├──────────────────┤
│   保存的寄存器      │
├──────────────────┤
│   被调用者的局部变量 │
└──────────────────┘
低地址

函数返回时整个栈帧被弹出，其中的局部对象按逆序析构。

栈溢出

栈空间有限（Linux 默认 8 MB），以下情况会导致栈溢出：

void recurse(int n)
{
    int buffer[10000];   // 每次调用占用 40 KB 栈空间
    recurse(n + 1);      // 无限递归，很快耗尽栈
}

int main()
{
    int huge[10'000'000];   // 约 40 MB，直接溢出
}

大数组应该放到堆上，或者用 std::vector：

std::vector<int> huge(10'000'000);   // 数据在堆上，安全

栈上的对象天然异常安全

栈对象的析构由编译器插入，无论函数是正常返回还是异常退出，析构都会执行。这是 RAII 能成立的前提。

三、堆

堆是程序运行时可以自由申请的内存区域。它的大小只受限于系统可用内存，代价是：

• 分配慢：需要在空闲链表中找合适的块，可能触发系统调用
• 需要手动管理：必须显式释放，否则泄漏
• 容易碎片化：反复分配释放不同大小的块，会留下难以利用的空洞

int* p = new int(42);   // 分配
// ... 使用
delete p;               // 释放，忘记这步就泄漏了

堆的分配器实现相当复杂（glibc 的 malloc 有几千行），但基本思路是维护若干空闲链表，按大小分类管理。

四、对象的内存布局

1. 成员排布与填充

编译器会按成员声明顺序排布，但为了对齐，可能插入填充字节：

struct A
{
    char  c;   // 1 字节
    // 3 字节填充
    int   i;   // 4 字节
    char  d;   // 1 字节
    // 3 字节填充（尾部对齐到 4 的倍数）
};
// sizeof(A) == 12，而不是 6

调整成员顺序可以减小体积：

struct B
{
    int   i;   // 4
    char  c;   // 1
    char  d;   // 1
    // 2 字节填充
};
// sizeof(B) == 8

2. 对齐规则

每个类型都有一个对齐要求（alignof(T)），通常是其大小的约数。规则是：

• 成员的偏移量必须是其对齐值的整数倍
• 结构体的总大小必须是最大成员对齐值的整数倍

std::cout << alignof(int)    << '\n';   // 4
std::cout << alignof(double) << '\n';   // 8
std::cout << alignof(char)   << '\n';   // 1

C++11 起可以用 alignas 强制指定对齐：

struct alignas(16) Vec4
{
    float x, y, z, w;   // 16 字节，正好对齐到 SIMD 寄存器宽度
};

3. 空类与继承

空类的大小是 1 而不是 0——因为每个对象必须有唯一地址：

struct Empty {};
std::cout << sizeof(Empty);   // 1

但空基类优化（EBO）可以让空基类不占空间：

struct Empty {};

struct WithMember : Empty
{
    int x;
};
std::cout << sizeof(WithMember);   // 4，Empty 被优化掉了

4. 虚函数与虚表指针

含有虚函数的类，对象里会多一个虚表指针（vptr），指向该类的虚函数表：

struct Base
{
    virtual void f();
    int x;
};

std::cout << sizeof(Base);   // 16（64 位系统：8 字节 vptr + 4 字节 int + 4 填充）

多个虚函数不会增加对象大小——它们共享同一张虚表。

5. 查看实际布局

offsetof 可以查看成员偏移：

#include <cstddef>

struct A { char c; int i; };

std::cout << offsetof(A, c) << '\n';   // 0
std::cout << offsetof(A, i) << '\n';   // 4

五、字节序

多字节整数在内存中的排列顺序有两种：

int x = 0x12345678;

// 小端内存布局（从低地址到高地址）：
// 78 56 34 12

C++20 提供了 std::endian 检测：

#include <bit>

if constexpr (std::endian::native == std::endian::little)
    std::cout << "小端\n";

字节序只在跨平台传输数据时才需要关心。同一平台内的内存操作不受影响。

六、常见误区

「栈比堆快，所以尽量用栈」 —— 分配本身确实是栈快，但如果对象很大，栈的拷贝成本可能更高。而且栈空间有限，几十 MB 的数组只能放堆上。

「sizeof 就是成员大小之和」 —— 忽略了填充。结构体大小取决于成员顺序和对齐要求。

「指针大小等于所指向对象的大小」 —— 指针大小固定（64 位系统上是 8 字节），与指向什么无关。

「new 一定返回连续内存」 —— 单次 new T[n] 是连续的，但多次 new 之间没有任何位置保证。

「局部变量的地址可以返回」 —— 函数返回后栈帧被回收，返回局部变量的指针或引用是悬垂引用。

七、相关章节

• 动态内存分配：new / delete 的细节
• RAII 与资源管理：利用栈对象的析构自动释放资源
• 内存调试与诊断：越界、泄漏等问题的排查
• C++ 内存模型（并发）：多线程下的内存可见性

动态内存分配

栈上的对象由编译器管理，出了作用域就自动销毁。但有些对象必须活得更久——比如跨函数传递的数据、大小在运行时才能确定的数组。这类对象需要放在堆上，由程序员（或封装好的工具）负责申请和释放。

这一章讲 new / delete 到底做了什么，以及它们有哪些容易踩的地方。

一、new 和 delete 做了什么

很多人以为 new 就是「分配内存」，其实它做两件事：

1. 调用 operator new 分配原始内存
2. 在这块内存上构造对象（调用构造函数）

delete 同样做两件事，顺序相反：

1. 调用对象的析构函数
2. 调用 operator delete 释放内存

MyClass* p = new MyClass(42);
// 等价于：
// void* mem = operator new(sizeof(MyClass));
// MyClass* p = new (mem) MyClass(42);   // placement new

delete p;
// 等价于：
// p->~MyClass();
// operator delete(p);

理解这个分解很重要，后面几个话题都建立在它之上。

二、operator new 与 operator delete

operator new 是可以重载的全局函数，默认实现就是调用 malloc：

// 全局 operator new 的签名
void* operator new(std::size_t size);
void* operator new[](std::size_t size);

void operator delete(void* ptr) noexcept;
void operator delete[](void* ptr) noexcept;

重载它们可以接管整个程序的堆分配：

void* operator new(std::size_t size)
{
    std::cout << "分配 " << size << " 字节\n";
    if (void* p = std::malloc(size))
        return p;
    throw std::bad_alloc();
}

void operator delete(void* ptr) noexcept
{
    std::free(ptr);
}

也可以只为某个类重载：

class Pooled
{
public:
    static void* operator new(std::size_t size);
    static void operator delete(void* ptr) noexcept;
};

这常用于对象池、内存追踪等场景。

new 失败时默认抛 std::bad_alloc。如果希望像 malloc 那样返回 nullptr，可以用 new (std::nothrow) T。

三、placement new

placement new 允许在已分配的内存上构造对象，不分配新内存：

#include <new>

// 1. 先分配原始内存
void* buffer = std::malloc(sizeof(MyClass));

// 2. 在已有内存上构造对象
MyClass* p = new (buffer) MyClass(42);

// 3. 手动析构（不能 delete！）
p->~MyClass();

// 4. 释放原始内存
std::free(buffer);

这里绝对不能调用 delete p——因为内存不是 operator new 分配的，delete 会试图释放一块不属于它的内存。必须手动调用析构函数，再自己释放缓冲区。

标准库容器正是这样实现的：std::vector 先分配一块原始内存，再用 placement new 逐个构造元素。

四、new[] 与 delete[]

数组版本的 new 会在内存头部额外记录元素个数，delete[] 需要这个信息来逐个调用析构函数：

MyClass* arr = new MyClass[10];
delete[] arr;   // 正确：析构 10 个对象
// delete arr;  // 错误：只析构 1 个，且释放方式不匹配

必须配对使用。用 new[] 分配却用 delete 释放（或反之）是未定义行为。

对于没有析构函数的类型（如 int），编译器通常不会额外记录长度，但混用仍然是未定义行为，不要依赖这一点。

现代 C++ 中，几乎不需要手写 new[]——用 std::vector 或 std::make_unique<T[]> 更安全：

auto arr = std::make_unique<int[]>(10);   // 自动管理

五、内存对齐

有些类型要求内存地址必须是某个值的整数倍。比如 SIMD 类型通常要求 16 或 32 字节对齐。

C++17 起，new 会自动处理过度对齐类型：

struct alignas(64) CacheLine
{
    char data[64];
};

CacheLine* p = new CacheLine;   // C++17 保证 64 字节对齐

C++17 之前需要手动指定：

void* mem = aligned_alloc(64, sizeof(CacheLine));

如果需要手动管理对齐内存：

#include <memory>

// 分配 64 字节对齐、能放下 10 个 CacheLine 的内存
void* mem = std::aligned_alloc(64, sizeof(CacheLine) * 10);
std::free(mem);

六、常见错误

1. 忘记释放

void leak()
{
    int* p = new int(42);
    // 忘记 delete p
}

短命程序里泄漏可能无所谓，但长期运行的服务会慢慢吃光内存。

2. 重复释放

int* p = new int(42);
delete p;
delete p;   // 未定义行为，通常直接崩溃

释放后应该把指针置空，或者干脆用智能指针：

delete p;
p = nullptr;   // 至少让第二次 delete 变成安全的空操作

3. 释放后继续使用

int* p = new int(42);
delete p;
std::cout << *p;   // 悬垂指针，未定义行为

这块内存可能已被重新分配给别的对象，读到的值无法预料。

4. 释放非堆内存

int local = 42;
int* p = &local;
delete p;   // 灾难：试图释放栈内存

5. 混用 malloc/free 与 new/delete

int* p = (int*)std::malloc(sizeof(int));
delete p;   // 错误：malloc 配 free，new 配 delete

int* q = new int(42);
std::free(q);   // 错误

两套机制的内存管理方式不同，混用是未定义行为。

七、异常安全

new 可能抛出 std::bad_alloc，这让手动管理内存更容易出错：

void risky()
{
    MyClass* a = new MyClass();
    MyClass* b = new MyClass();   // 如果这里抛异常，a 就泄漏了

    // ... 使用

    delete b;
    delete a;
}

如果第二个 new 失败，a 指向的内存永远不会被释放。正确做法是用 RAII：

void safe()
{
    auto a = std::make_unique<MyClass>();
    auto b = std::make_unique<MyClass>();   // 抛异常时 a 会自动释放
}

这是「不要手写 delete」这条建议的核心理由——异常路径上的清理太容易遗漏了。

八、什么时候该用堆

堆分配有成本，不是所有对象都该放堆上：

一个经验法则：如果对象的生命周期不需要超出当前作用域，就别放堆上。

九、相关章节

• 内存布局与模型：栈与堆的区别
• RAII 与资源管理：用对象管理资源，避免手写 delete
• 智能指针：unique_ptr 与 shared_ptr
• 自定义内存管理：内存池与分配器
• 内存调试与诊断：泄漏与越界的排查

Smart Pointer

智能指针是 RAII 在内存管理上的标准实现。它把「指向对象的指针」和「负责释放」这两件事绑在一起，让堆对象的生命周期由对象自己管理，而不是靠程序员记得写 delete。

C++11 引入了三种智能指针，各有明确的使用场景：

此外还有 std::auto_ptr，它是 C++98 的产物，因为拷贝时隐式转移所有权这一设计缺陷，在 C++11 被弃用、C++17 被移除。现在只作为历史知识了解即可，见 auto_ptr。

怎么选

大部分情况下答案很简单：

• 优先用 unique_ptr。它没有额外开销（大小和裸指针一样），语义清晰。需要转移所有权时用 std::move。
• 确实需要共享时才用 shared_ptr。它要维护控制块和引用计数，有原子操作开销。
• 出现循环引用时用 weak_ptr 打破。它不增加引用计数，只观察对象是否还活着。

一个常见的误区是「shared_ptr 更安全所以都用它」。实际上共享所有权会让生命周期变得难以推理——你不知道对象什么时候被销毁。能用独占就用独占。

本章内容

• unique_ptr：独占所有权、自定义删除器、工厂函数
• shared_ptr：引用计数、控制块、线程安全、enable_shared_from_this
• weak_ptr：打破循环引用、缓存场景、lock() 用法
• auto_ptr：被移除的旧智能指针，以及它为什么被移除

std::auto_ptr

std::auto_ptr 是 C++98 中引入的智能指针类型，它提供了一种自动管理动态内存的方式。其主要功能是通过自动销毁对象来避免内存泄漏。然而，由于其所有权转移的语义问题（例如，拷贝操作时所有权隐式转移），std::auto_ptr 在 C++11 中被 弃用，并且在 C++17 中被 完全移除。因此，建议开发者使用 std::unique_ptr 来替代 std::auto_ptr。

1. 定义

std::auto_ptr 的模板定义如下：

template<class T>
class auto_ptr;

它是一个模板类，接受一个类型 T，并提供对该类型的自动内存管理。

std::auto_ptr 还有一个专用的模板版本：

template<>
class auto_ptr<void>;

这个版本用于不处理任何具体类型的 void 指针，但它通常不用于常规编程中，因为它并没有实际的意义。

2. 基本功能

std::auto_ptr 自动管理其指向的动态内存资源。其基本特点是：

• 在 auto_ptr 被销毁时，自动释放其指向的对象。
• 所有权转移：当 auto_ptr 被拷贝时，源 auto_ptr 的所有权被转移到目标 auto_ptr，这意味着源指针不再持有资源。这一行为可能会导致意外的内存管理问题。

3. 重要特点

• 所有权转移：

  • std::auto_ptr 的最具争议的特性就是它的 所有权转移。在拷贝构造函数或拷贝赋值运算符中，auto_ptr 会转移所有权（即源指针将失去对对象的所有权，而目标指针会成为新的所有者）。这种行为与 C++ 中其他类型的智能指针（如 std::unique_ptr）不同，容易导致不易察觉的 bug，尤其是在多次使用相同的对象时。

• 析构时自动释放资源：

  • 在 auto_ptr 被销毁时，它会自动释放它持有的内存。其析构函数会调用所管理对象的析构函数来释放资源，因此，开发者不需要显式地调用 delete。

• 不支持复制语义：

  • 由于所有权转移，std::auto_ptr 不支持复制操作（即不支持拷贝构造和拷贝赋值），它只支持移动语义。

4. 使用示例

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor\n"; }
    ~MyClass() { std::cout << "MyClass destructor\n"; }
};

int main() {
    // 创建一个 auto_ptr 指向 MyClass
    std::auto_ptr<MyClass> ptr1(new MyClass());

    // 通过拷贝构造将 ptr1 的所有权转移到 ptr2
    std::auto_ptr<MyClass> ptr2 = ptr1; // ptr1 的所有权转移给 ptr2

    // ptr1 现在为空，不能再使用它
    if (!ptr1) {
        std::cout << "ptr1 is now null.\n";
    }

    // ptr2 仍然拥有 MyClass 的资源
    // 在程序结束时，ptr2 将自动释放 MyClass 对象
    return 0;
}

5. 为什么 std::auto_ptr 被弃用

• 所有权转移的问题： std::auto_ptr 的一个关键问题是它的拷贝构造函数和拷贝赋值运算符会隐式地转移所有权，这会导致意外的行为和 bug。开发者可能会错误地认为一个对象仍然拥有资源，而实际上的资源已经被转移给另一个对象，导致悬空指针或多次释放同一资源。

• 现代 C++ 的替代方案： 在 C++11 中，std::unique_ptr 被引入作为 std::auto_ptr 的替代品。与 std::auto_ptr 不同，std::unique_ptr 不允许拷贝操作，只允许移动操作，避免了隐式所有权转移的风险，从而更符合现代 C++ 的设计理念。

• 移动语义： std::unique_ptr 支持移动语义，它允许资源的所有权在不同对象间转移，而不会引起混淆或潜在错误。

6. 替代品

• std::unique_ptr： std::unique_ptr 是 std::auto_ptr 的现代替代品，它通过明确的所有权控制来避免潜在的错误。std::unique_ptr 不允许拷贝，只支持通过 std::move 转移所有权，因此避免了所有权转移时产生的问题。

• std::shared_ptr： 对于共享所有权的场景，std::shared_ptr 可以提供引用计数功能，使得多个指针可以共同拥有资源，而在最后一个指针被销毁时释放资源。

std::unique_ptr

std::unique_ptr 是 C++11 引入的智能指针，表示对资源的独占所有权。它应该是你管理堆对象时的默认选择——没有额外开销，语义清晰，不会出现「不知道谁负责释放」的问题。

一、基本用法

#include <memory>

// 推荐：用 make_unique 创建（C++14）
auto p = std::make_unique<MyClass>(42);

// 也可以用裸指针构造（C++11）
std::unique_ptr<MyClass> p2(new MyClass(42));

p->doSomething();   // 像普通指针一样使用
(*p).doSomething();

unique_ptr 的大小和裸指针一样（64 位系统上 8 字节），因为它不需要存引用计数之类的额外信息——所有权是唯一的，销毁时机在编译期就确定了。

优先用 std::make_unique 而不是 new。除了更简洁，它还能避免一个微妙的异常安全问题：

// 危险：如果 MyClass 构造抛异常，或者 g() 抛异常，
// 都可能让 new 出来的内存泄漏
f(std::unique_ptr<MyClass>(new MyClass()), g());

// 安全
f(std::make_unique<MyClass>(), g());

二、所有权转移

unique_ptr 不能拷贝，只能移动：

auto p1 = std::make_unique<MyClass>();
// auto p2 = p1;                 // 编译错误：不能拷贝
auto p2 = std::move(p1);         // 正确：转移所有权

// 此时 p1 变为 nullptr
if (!p1)
    std::cout << "p1 已失去所有权\n";

这个限制是有意设计的。如果允许拷贝，两个 unique_ptr 会指向同一对象，销毁时就会重复释放。用 std::move 显式转移，代码里所有权流转一目了然。

作为函数参数与返回值

// 接管所有权：调用者不能再使用
void takeOwnership(std::unique_ptr<MyClass> p);

// 只借用：不涉及所有权转移
void useObject(const MyClass& obj);
void useObject(MyClass* obj);

// 返回所有权：把资源交给调用者
std::unique_ptr<MyClass> create()
{
    return std::make_unique<MyClass>();   // 移动语义，无拷贝开销
}

函数返回局部 unique_ptr 时不需要写 std::move，编译器会自动应用移动（NRVO 或隐式移动）。

三、常用接口

auto p = std::make_unique<int>(42);

int* raw = p.get();          // 只读，p 仍然拥有

p.reset();                   // 释放对象，p 变为空
p.reset(new int(100));       // 释放旧的，接管新的

if (p)                       // 判空
    std::cout << *p << '\n';

release() 要小心使用——它把所有权交还给裸指针，之后必须自己 delete：

auto p = std::make_unique<int>(42);
int* raw = p.release();   // p 变空，raw 需要手动管理
delete raw;               // 别忘了

它主要用于与 C 风格接口交接所有权。

四、数组支持

unique_ptr 有数组特化版本 unique_ptr<T[]>，它使用 delete[] 而非 delete：

auto arr = std::make_unique<int[]>(10);   // 10 个 int

arr[0] = 1;      // 支持 operator[]
arr[9] = 10;
// 自动 delete[]，无需手动管理

不过大多数情况下 std::vector 是更好的选择——它知道自己的大小，支持迭代器和算法。

五、自定义删除器

unique_ptr 的第二个模板参数是删除器，可以自定义释放方式：

template<class T, class Deleter = std::default_delete<T>>
class unique_ptr;

这让 unique_ptr 能管理任何「需要释放」的资源，不限于 new 出来的内存：

// 管理文件
auto fileDeleter = [](FILE* f) { if (f) fclose(f); };
std::unique_ptr<FILE, decltype(fileDeleter)> file(fopen("a.txt", "r"), fileDeleter);

// 管理 malloc 的内存
std::unique_ptr<int, decltype(&std::free)> buf(
    (int*)std::malloc(sizeof(int) * 10), &std::free);

// 管理 socket
auto socketDeleter = [](int* fd) { if (*fd >= 0) close(*fd); delete fd; };
std::unique_ptr<int, decltype(socketDeleter)> sock(new int(fd), socketDeleter);

注意：使用自定义删除器后，unique_ptr 的大小可能变大（需要存储删除器对象）。无状态的删除器（如函数指针、无捕获 lambda）通常不增加大小，因为编译器可以做空基类优化。

六、作为类成员

unique_ptr 常用于实现 Pimpl 惯用法（Pointer to Implementation），把实现细节隐藏起来：

// widget.h
class Widget
{
public:
    Widget();
    ~Widget();                          // 必须在 .cpp 中定义
    Widget(Widget&&) noexcept;          // 同上
    Widget& operator=(Widget&&) noexcept;

    void doSomething();

private:
    struct Impl;
    std::unique_ptr<Impl> impl_;        // 只暴露前置声明
};

// widget.cpp
struct Widget::Impl
{
    std::string data;
    // 复杂的实现细节
};

Widget::Widget() : impl_(std::make_unique<Impl>()) {}
Widget::~Widget() = default;            // Impl 在这里才是完整类型

这样做的好处：

• 头文件不需要包含实现依赖，加快编译
• 修改实现不会导致使用方重新编译
• 保持 ABI 稳定

注意析构函数必须在 .cpp 中定义——因为在头文件里 Impl 还是不完整类型，unique_ptr 的析构需要完整类型。

七、作为工厂函数返回值

工厂函数返回 unique_ptr 是标准做法，把所有权明确交给调用者：

class Shape
{
public:
    virtual ~Shape() = default;
    virtual void draw() const = 0;
};

std::unique_ptr<Shape> createShape(const std::string& type)
{
    if (type == "circle")
        return std::make_unique<Circle>();
    if (type == "square")
        return std::make_unique<Square>();
    return nullptr;
}

// 使用
auto shape = createShape("circle");
if (shape)
    shape->draw();

这里基类的析构函数必须是 virtual，否则通过基类指针删除派生类对象是未定义行为。

八、常见误区

「unique_ptr 不能放进容器」 —— 可以，但容器需要支持移动。std::vector<std::unique_ptr<T>> 是合法的，只是不能用需要拷贝的操作（如 std::copy）。

「返回 unique_ptr 一定要写 std::move」 —— 返回局部变量时不需要，编译器会隐式移动。写 std::move 反而可能阻止 NRVO 优化。

「get() 返回的指针可以随便用」 —— get() 只是借用，unique_ptr 销毁后该指针立刻悬垂。不要保存它。

「release() 之后 unique_ptr 还会释放」 —— 不会。release() 就是放弃所有权，之后必须自己管理。

「自定义删除器不影响大小」 —— 有状态的删除器会增加 unique_ptr 的大小。无状态删除器通常不增加。

「unique_ptr 可以拷贝到 shared_ptr」 —— 可以，用移动：std::shared_ptr<T> sp = std::move(up);。这是把独占所有权升级为共享所有权的唯一方式。

九、相关章节

• 智能指针：三种智能指针的对比与选择
• shared_ptr：需要共享所有权时
• RAII 与资源管理：unique_ptr 背后的设计思想
• 拷贝控制：移动语义与 Rule of Five

std::shared_ptr

std::shared_ptr 表示共享所有权：多个 shared_ptr 可以指向同一个对象，引用计数降到 0 时对象才被销毁。

它解决的是「这个对象到底该由谁释放」的问题——当多个模块都需要访问同一个对象，又无法确定谁活得最久时，共享所有权是自然的答案。代价是额外的控制块和原子操作开销。

一、基本用法

#include <memory>

// 推荐：用 make_shared 创建
auto p1 = std::make_shared<MyClass>(42);

// 也可以从裸指针构造
std::shared_ptr<MyClass> p2(new MyClass(42));

// 拷贝：引用计数增加
auto p3 = p1;
std::cout << p1.use_count();   // 3

p1.reset();                    // 计数减到 2
p3 = nullptr;                  // 计数减到 1
// p2 销毁时计数归零，对象被释放

shared_ptr 的大小通常是裸指针的两倍（16 字节）——一个指向对象，一个指向控制块。

二、引用计数与控制块

shared_ptr 内部维护一个控制块，记录：

• 强引用计数（shared_ptr 的数量）
• 弱引用计数（weak_ptr 的数量）
• 删除器
• 分配器

对象在强引用计数归零时销毁，控制块在强弱引用计数都归零时才释放。

shared_ptr p1 ──┐
                ├──→ 控制块 ──→ 对象
shared_ptr p2 ──┘    ├─ 强引用: 2
                     ├─ 弱引用: 0
                     └─ 删除器

make_shared 与 new 的差别

auto p1 = std::make_shared<MyClass>();              // 一次分配
std::shared_ptr<MyClass> p2(new MyClass());         // 两次分配

make_shared 把对象和控制块放在同一块内存里，只分配一次。这更快，缓存局部性也更好。

但它有个副作用：对象的内存要等控制块也释放后才能回收。如果存在 weak_ptr 长期观察，对象已经析构但内存不会归还。

另外，make_shared 无法指定自定义删除器。需要自定义删除器时只能用 new 构造。

三、线程安全

这是最容易误解的一点。shared_ptr 的线程安全性要分两个层面看：

引用计数本身是原子的，所以「拷贝/销毁不同的 shared_ptr 实例」是安全的。但如果多个线程同时读写同一个 shared_ptr 变量（比如一个线程 reset()，另一个线程拷贝），就会产生数据竞争。

std::shared_ptr<Data> g_data;

// 线程 A
g_data = std::make_shared<Data>();   // 写

// 线程 B
auto local = g_data;                 // 读 —— 与 A 竞争！

正确做法是加锁，或者用 std::atomic<std::shared_ptr<T>>（C++20）：

std::atomic<std::shared_ptr<Data>> g_data;

g_data.store(std::make_shared<Data>());   // 原子写
auto local = g_data.load();               // 原子读

注意：std::atomic<std::shared_ptr<T>> 在 C++20 才被正式支持。在此之前只能用 std::atomic_load / std::atomic_store 这些自由函数。

至于对象内容的访问，shared_ptr 完全不提供保护。多个线程同时修改同一个对象，仍然需要 mutex 等同步手段。

四、循环引用

shared_ptr 最经典的坑是循环引用：

struct Node
{
    std::shared_ptr<Node> next;
    ~Node() { std::cout << "销毁\n"; }
};

void leak()
{
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();

    a->next = b;   // b 的计数 = 2
    b->next = a;   // a 的计数 = 2
}
// 函数结束，a 和 b 各自减 1，计数都是 1
// 对象永远不会销毁，析构函数不会调用

两个对象互相持有对方的 shared_ptr，计数永远降不到 0。

解决办法是把其中一条边改成 weak_ptr：

struct Node
{
    std::weak_ptr<Node> next;   // 不增加计数
    ~Node() { std::cout << "销毁\n"; }
};

现在 b->next 不影响 a 的计数，函数结束时两个对象都能正常销毁。

判断原则：如果两个对象是「父子」或「主从」关系，让子/从指向父/主用 weak_ptr。如果确实需要双向强引用，说明设计可能有问题。

五、enable_shared_from_this

有时类内部需要返回指向自己的 shared_ptr：

class Widget
{
public:
    std::shared_ptr<Widget> getSelf()
    {
        return std::shared_ptr<Widget>(this);   // 错误！
    }
};

这样写会创建第二个控制块，导致同一个对象被释放两次。

正确做法是继承 enable_shared_from_this：

class Widget : public std::enable_shared_from_this<Widget>
{
public:
    std::shared_ptr<Widget> getSelf()
    {
        return shared_from_this();   // 复用已有的控制块
    }
};

使用时必须确保对象已经由 shared_ptr 管理：

auto p = std::make_shared<Widget>();
auto q = p->getSelf();   // 正确，q 和 p 共享控制块

Widget w;
auto bad = w.getSelf();  // 错误：w 不是 shared_ptr 管理的，抛 bad_weak_ptr

这个模式在异步回调中很常见——回调需要持有 this 的 shared_ptr 以保证对象存活。

六、常用接口

auto p = std::make_shared<int>(42);

std::cout << p.use_count() << '\n';   // 1

auto q = p;
std::cout << p.use_count() << '\n';   // 2

p.reset();
std::cout << q.use_count() << '\n';   // 1

use_count() 只应用于调试。多线程环境下它的返回值随时可能失效，不要用它做逻辑判断。

七、类型转换

shared_ptr 之间的转换需要专用函数，不能用 static_cast：

std::shared_ptr<Base> base = std::make_shared<Derived>();

// 向下转换
auto derived = std::dynamic_pointer_cast<Derived>(base);   // 失败返回 nullptr
if (derived)
    derived->derivedMethod();

// 静态转换
auto d2 = std::static_pointer_cast<Derived>(base);

// const 转换
auto c = std::const_pointer_cast<Derived>(base);

这些函数会共享控制块，引用计数正确维护。直接用 static_cast 得到裸指针再构造新的 shared_ptr 会导致双重释放。

八、什么时候不该用

shared_ptr 很方便，但共享所有权会让生命周期推理变难：

• 对象什么时候销毁？ —— 计数归零时，但归零的时机可能很晚，甚至超出你的预期。
• 谁在持有？ —— 需要看所有拷贝点，代码量一大就很难追踪。

因此：

不要把 shared_ptr 当默认选择。它应该用在确实需要共享所有权的地方，而不是「懒得想清楚生命周期」时。

九、常见误区

「shared_ptr 是线程安全的」 —— 只有引用计数是原子的。同一个 shared_ptr 对象的并发读写、以及对象内容的并发访问都不安全。

「use_count() 可以用来判断是否独占」 —— 多线程下不可靠，标准明确说它只用于调试。

「make_shared 总是更好」 —— 它无法指定自定义删除器，且在有 weak_ptr 长期存在时会延迟内存回收。

「用 get() 得到的指针可以构造新的 shared_ptr」 —— 会创建独立控制块，导致双重释放。要用 enable_shared_from_this 或 shared_ptr 的别名构造函数。

「shared_ptr 可以替代 unique_ptr」 —— 技术上可以，但会带来不必要的开销和难以推理的生命周期。能用独占就用独占。

「两个 shared_ptr 指向同一对象就共享控制块」 —— 只有通过拷贝或 make_shared 才共享。分别用同一个裸指针构造两次，会得到两个独立控制块。

十、相关章节

• 智能指针：三种智能指针的对比与选择
• unique_ptr：独占所有权，默认选择
• weak_ptr：打破循环引用
• RAII 与资源管理：共享所有权的设计思想
• 多线程与并发：shared_ptr 在并发中的正确用法

std::weak_ptr

std::weak_ptr 是对 shared_ptr 管理对象的弱引用。它能看到对象，但不参与所有权——不增加强引用计数，因此不会阻止对象被销毁。

它主要解决两个问题：打破 shared_ptr 的循环引用，以及在缓存等场景中安全地观察对象是否还活着。

一、基本用法

weak_ptr 不能直接构造，必须从 shared_ptr 得到：

auto sp = std::make_shared<MyClass>();
std::weak_ptr<MyClass> wp = sp;      // 从 shared_ptr 构造

std::cout << sp.use_count() << '\n';   // 1，weak_ptr 不影响计数

访问对象必须先转成 shared_ptr：

if (auto locked = wp.lock())     // 尝试提升
{
    locked->doSomething();       // 对象还活着
}
else
{
    // 对象已被销毁
}

lock() 是唯一的访问途径，这个设计是刻意的——它把「检查是否存在」和「使用对象」合成一个原子操作，避免了先检查后使用之间的竞态。

二、解决循环引用

这是 weak_ptr 最经典的用途。看一个双向链表或树结构：

struct Node
{
    std::shared_ptr<Node> parent;      // 指向父节点
    std::vector<std::shared_ptr<Node>> children;
    ~Node() { std::cout << "销毁节点\n"; }
};

void leak()
{
    auto parent = std::make_shared<Node>();
    auto child = std::make_shared<Node>();

    parent->children.push_back(child);   // child 计数 = 2
    child->parent = parent;              // parent 计数 = 2
}
// 函数结束，两个计数都停在 1，对象永不销毁

父节点持有子节点，子节点又持有父节点，形成环。解决办法是把「反向」的那条边改成弱引用：

struct Node
{
    std::weak_ptr<Node> parent;          // 改成 weak_ptr
    std::vector<std::shared_ptr<Node>> children;
    ~Node() { std::cout << "销毁节点\n"; }
};

现在 child->parent 不影响 parent 的计数，函数结束时两个对象都能正常销毁。

怎么判断哪条边该用 weak_ptr？

• 树结构：父持有子用 shared_ptr，子指回父用 weak_ptr
• 观察者模式：被观察者持有观察者用 shared_ptr，观察者持有被观察者用 weak_ptr
• 一般原则：让「拥有」的方向用强引用，「引用」的方向用弱引用

如果两个对象确实需要互相强引用，通常说明设计本身有问题——考虑能否提取出第三个对象来持有它们。

三、常用接口

auto sp = std::make_shared<int>(42);
std::weak_ptr<int> wp = sp;

std::cout << wp.expired() << '\n';   // false
std::cout << wp.use_count() << '\n'; // 1

sp.reset();
std::cout << wp.expired() << '\n';   // true
std::cout << wp.lock() << '\n';      // 空指针

expired() 和 use_count() 在多线程下都不可靠——返回值可能立刻失效。要访问对象，永远用 lock() 再判断。

四、缓存场景

weak_ptr 的另一个常见用途是缓存：缓存不应该决定对象的生命周期，只应该「顺便记住」还活着的对象。

class ImageCache
{
public:
    std::shared_ptr<Image> get(const std::string& path)
    {
        auto it = cache_.find(path);
        if (it != cache_.end())
        {
            if (auto img = it->second.lock())   // 缓存还有效
                return img;
            cache_.erase(it);                    // 已失效，清掉
        }

        auto img = loadImage(path);              // 重新加载
        cache_[path] = img;                      // 存弱引用
        return img;
    }

private:
    std::unordered_map<std::string, std::weak_ptr<Image>> cache_;
};

如果缓存用 shared_ptr，那么只要缓存还在，图片就永远不会被释放——缓存变成了内存泄漏。用 weak_ptr 则不会：没人用图片时它自然销毁，缓存项随之失效。

这个模式也适用于对象池、连接池等场景。

五、观察者模式

观察者需要知道被观察者是否还活着，但不应该影响它的生命周期：

class Subject;

class Observer
{
public:
    virtual void onNotify() = 0;
};

class Subject
{
public:
    void subscribe(std::shared_ptr<Observer> obs)
    {
        observers_.push_back(obs);
    }

    void notify()
    {
        // 清理已销毁的观察者，同时通知存活的
        std::erase_if(observers_, [](auto& wp) {
            if (auto obs = wp.lock()) {
                obs->onNotify();
                return false;
            }
            return true;   // 已失效，移除
        });
    }

private:
    std::vector<std::weak_ptr<Observer>> observers_;
};

如果这里用 shared_ptr，被观察者会一直持有观察者，导致观察者无法销毁。

六、与 shared_ptr 的关系

理解两者关系的关键是控制块：

shared_ptr ──┐
             ├──→ 控制块 ──→ 对象
weak_ptr ────┘    ├─ 强引用: 1
                  ├─ 弱引用: 1
                  └─ 删除器

• 强引用归零 → 对象被销毁（析构函数调用）
• 强引用和弱引用都归零 → 控制块被释放

所以只要还有 weak_ptr 在观察，控制块就不会释放。这也是 make_shared 的一个副作用：对象和控制块在同一块内存里，控制块不释放，对象的内存也就无法归还给系统。

auto sp = std::make_shared<BigObject>();
std::weak_ptr<BigObject> wp = sp;

sp.reset();   // BigObject 析构，但内存还没还给系统
wp.reset();   // 现在控制块也释放了，内存才真正回收

对象大小较大、且存在长期 weak_ptr 时，用 shared_ptr<T>(new T) 可能比 make_shared 更合适。

七、常见误区

「weak_ptr 可以直接解引用」 —— 不行，没有 operator* 和 operator->。必须先 lock()。

「expired() 返回 false 就可以安全使用」 —— 不行。检查和使用之间对象可能被销毁，这是典型的竞态。要用 lock() 一次完成。

「weak_ptr 会增加引用计数」 —— 不增加强引用计数，只增加弱引用计数。对象该销毁时照样销毁。

「use_count() 可以用来判断对象是否存活」 —— 多线程下不可靠。判断存活用 lock() 或 expired()，且前者更安全。

「循环引用只能靠 weak_ptr 解决」 —— 也可以重新设计对象关系，比如用非拥有指针（裸指针、引用）替代。weak_ptr 只是最方便的方案。

「weak_ptr 可以独立存在」 —— 它必须从 shared_ptr 或另一个 weak_ptr 构造。凭空创建的 weak_ptr 是空的。

八、相关章节

• 智能指针：三种智能指针的对比与选择
• shared_ptr：引用计数与控制块
• unique_ptr：独占所有权
• RAII 与资源管理：所有权设计的一般原则

std::shared_ptr<MyClass> ptr = wp.lock();  // 转换为 shared_ptr
if (ptr) {
    // 使用 ptr 来访问 MyClass 对象
}

通过这种方式，我们可以在必要时访问由 std::weak_ptr 管理的对象，但前提是该对象仍然存在。

自定义内存管理

前面几章讲的都是「怎么正确使用内存」。这一章讲另一件事：怎么让内存分配更快、更可控。

标准库的 new 和 malloc 是通用分配器，要应付各种大小、各种模式，因此实现复杂、开销不小。如果你的程序有明确的分配模式（比如大量相同大小的小对象、频繁创建销毁），自己管理内存可以带来数量级的提升。

不过要先说清楚：绝大多数程序不需要自定义分配器。先用 profiler 确认分配真的是瓶颈，再考虑优化。

一、通用分配器的问题

malloc 的典型开销：

• 查找空闲块：维护多个大小类别的空闲链表，需要遍历
• 加锁：多线程下要保护堆结构，即使用了 thread-local cache 也有开销
• 元数据：每块内存前面有头部，记录大小等信息
• 碎片化：反复分配释放不同大小的块，会留下难以利用的空洞
• 缓存不友好：对象分散在堆各处，遍历时 cache miss 频繁

一个具体例子：分配 100 万个 32 字节的小对象，malloc 实际可能占用 48 字节/个（含头部和对齐），而且每次分配都是一次函数调用加链表操作。

二、分配器接口

标准库容器允许指定分配器，接口定义在 <memory>：

template<class T>
class MyAllocator
{
public:
    using value_type = T;

    MyAllocator() = default;

    template<class U>
    MyAllocator(const MyAllocator<U>&) noexcept {}

    T* allocate(std::size_t n);
    void deallocate(T* p, std::size_t n);

    // C++11 起，相等比较决定分配器能否互换
    bool operator==(const MyAllocator&) const noexcept { return true; }
    bool operator!=(const MyAllocator&) const noexcept { return false; }
};

一个最小实现：

template<class T>
T* MyAllocator<T>::allocate(std::size_t n)
{
    if (n > std::numeric_limits<std::size_t>::max() / sizeof(T))
        throw std::bad_alloc();
    if (auto p = static_cast<T*>(std::malloc(n * sizeof(T))))
        return p;
    throw std::bad_alloc();
}

template<class T>
void MyAllocator<T>::deallocate(T* p, std::size_t) noexcept
{
    std::free(p);
}

用法：

std::vector<int, MyAllocator<int>> v;

注意：分配器的 allocate 只分配原始内存，不构造对象。构造由容器通过 allocator_traits::construct（内部是 placement new）完成。

三、内存池

内存池的思路很简单：一次申请一大块，之后从里面切分。

1. 固定大小内存池

适合「大量相同大小的对象」场景：

class FixedPool
{
public:
    explicit FixedPool(std::size_t blockSize, std::size_t blockCount)
        : blockSize_(std::max(blockSize, sizeof(void*)))
    {
        // 一次分配所有内存
        storage_ = std::malloc(blockSize_ * blockCount);

        // 把空闲块串成链表
        for (std::size_t i = 0; i < blockCount; ++i)
        {
            void* block = static_cast<char*>(storage_) + i * blockSize_;
            *static_cast<void**>(block) = freeList_;   // 用块本身存 next 指针
            freeList_ = block;
        }
    }

    ~FixedPool() { std::free(storage_); }

    void* allocate()
    {
        if (!freeList_)
            throw std::bad_alloc();

        void* block = freeList_;
        freeList_ = *static_cast<void**>(freeList_);   // 取出下一个
        return block;
    }

    void deallocate(void* p) noexcept
    {
        *static_cast<void**>(p) = freeList_;   // 头插回空闲链表
        freeList_ = p;
    }

private:
    void* storage_ = nullptr;
    void* freeList_ = nullptr;
    std::size_t blockSize_;
};

分配和释放都只是链表操作，是常数时间，而且没有锁、没有元数据开销。

这个技巧叫 free list，用一个空闲块的前几个字节存下一个空闲块的地址——反正空闲块里的数据已经没用了。

2. 内存池的代价

• 不能释放单块给系统：整个池要一起释放
• 块大小固定：需要不同大小就得建多个池
• 可能浪费：如果块大小不匹配，会有内部碎片

所以内存池适合生命周期一致、大小固定的对象，不适合通用场景。

四、对象池

内存池管理原始内存，对象池则管理已构造的对象，常用于需要频繁创建销毁的场景：

template<class T>
class ObjectPool
{
public:
    template<class... Args>
    T* create(Args&&... args)
    {
        void* mem = pool_.allocate();
        return new (mem) T(std::forward<Args>(args)...);   // placement new
    }

    void destroy(T* obj)
    {
        obj->~T();                  // 显式析构
        pool_.deallocate(obj);
    }

private:
    FixedPool pool_{sizeof(T), 1024};
};

这在游戏开发中很常见——子弹、粒子这类对象每秒创建销毁上千次，用对象池可以避免反复的堆分配。

五、pmr：多态内存资源

C++17 引入了 <memory_resource>，提供了一套运行时多态的分配器机制。它解决了传统分配器的一个痛点：分配器类型是容器类型的一部分，改分配器就要改类型。

#include <memory_resource>

// 传统方式：分配器写进类型
std::vector<int, MyAllocator<int>> v1;

// pmr 方式：分配器是构造参数
std::pmr::vector<int> v2{&myResource};

std::pmr::vector<T> 就是 std::vector<T, std::pmr::polymorphic_allocator<T>> 的别名。

内置的内存资源

monotonic_buffer_resource

这是最实用的一个。它在一块预分配的内存上单调递增地分配，不支持单独释放，直到整个资源销毁：

// 用栈上的缓冲区，避免任何堆分配
std::array<std::byte, 4096> buffer;
std::pmr::monotonic_buffer_resource pool{buffer.data(), buffer.size()};

std::pmr::vector<int> v{&pool};
v.push_back(1);   // 从 buffer 分配，不碰堆

典型用法是「处理一批数据，用完整体丢弃」：

void processRequest(const Request& req)
{
    std::pmr::monotonic_buffer_resource pool;

    // 这一堆临时对象都从 pool 分配
    std::pmr::vector<Item> items{&pool};
    std::pmr::string name{&pool};
    std::pmr::map<int, Detail> details{&pool};

    // ... 处理

}   // pool 析构，所有内存一次性释放

这样避免了多次 new / delete，也避免了内存碎片。

六、对齐分配

有时需要特定对齐的内存，比如 SIMD 类型要求 16 或 32 字节对齐。

C++17 提供了对齐版本的分配：

void* p = operator new(size, std::align_val_t{64});
operator delete(p, std::align_val_t{64});

C 风格接口：

// C11 / C++17
void* p = std::aligned_alloc(64, size);
std::free(p);

或者用 C++11 的 std::align 手动调整：

void* ptr = buffer;
std::size_t space = sizeof(buffer);
void* aligned = std::align(64, size, ptr, space);

七、什么时候值得自定义分配

先测量再优化。用 profiler 看分配热点，确认 malloc 真的占了可观的时间，再考虑动手。

一个常见的误判是「我的程序分配很频繁，所以需要内存池」。但如果每次分配只花 50 纳秒，100 万次也才 50 毫秒——可能根本不是瓶颈。

八、常见误区

「自定义分配器一定更快」 —— 通用分配器经过几十年优化，对一般场景已经很好。自定义分配器的优势来自针对特定模式的优化，模式不匹配反而更慢。

「内存池可以随便释放单块」 —— 大多数池不支持单独归还给系统，只能整池释放。需要单独释放就得用更复杂的结构（如 slab 分配器）。

「allocate 会构造对象」 —— 不会。它只给原始内存，构造由容器负责。

「pmr 比普通分配器慢」 —— 多一层虚函数调用，但省去了分配器类型污染。在批处理场景下，monotonic_buffer_resource 通常比默认分配快得多。

「内存池不会有碎片」 —— 固定大小池不会有外部碎片，但可能有内部碎片（块大小不匹配）。而且池本身如果长期运行、反复分配释放，空闲链表也可能变得分散。

九、相关章节

• 动态内存分配：new / delete 与 operator new
• 内存布局与模型：对齐与对象布局
• 内存调试与诊断：分配器的调试支持
• RAII 与资源管理：分配器也需要 RAII 封装

RAII 与资源管理

RAII 是 Resource Acquisition Is Initialization 的缩写，直译是「资源获取即初始化」。这个名字起得不太好——它听起来像是在讲初始化，实际上讲的是析构。

它的核心思想只有一句话：把资源的生命周期绑定到对象的生命周期上。资源在构造函数里获取，在析构函数里释放。由于栈对象的析构是编译器自动插入的，无论函数是正常返回、提前 return 还是抛异常，资源都会被正确释放。

这是 C++ 区别于大多数语言的核心特性，也是整个标准库的设计基石。

一、为什么需要 RAII

先看一段没有 RAII 的代码：

void process()
{
    FILE* f = fopen("data.txt", "r");
    if (!f) return;

    char* buffer = (char*)malloc(1024);
    if (!buffer) {
        fclose(f);          // 每个错误分支都要手动清理
        return;
    }

    if (parse(f, buffer) < 0) {
        free(buffer);       // 又一处
        fclose(f);
        return;
    }

    free(buffer);
    fclose(f);
}

问题很明显：

• 每个提前返回的分支都要重复写清理代码，漏一个就泄漏
• 如果 parse 抛出异常，两处清理都不会执行
• 清理顺序必须和获取顺序相反，容易写错

用 RAII 改写：

void process()
{
    std::ifstream file("data.txt");      // 构造时打开
    if (!file) return;                   // 自动关闭

    std::vector<char> buffer(1024);      // 构造时分配

    parse(file, buffer);                 // 抛异常也没关系
}   // 离开作用域，buffer 和 file 自动释放

清理代码消失了，因为编译器会在每个退出路径上插入析构调用。

二、RAII 的完整形态

一个 RAII 类通常包含四部分：

class FileHandle
{
public:
    // 1. 构造函数获取资源
    explicit FileHandle(const char* path)
        : file_(fopen(path, "r"))
    {
        if (!file_)
            throw std::runtime_error("打开文件失败");
    }

    // 2. 析构函数释放资源
    ~FileHandle()
    {
        if (file_)
            fclose(file_);
    }

    // 3. 禁止拷贝（否则会双重释放）
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;

    // 4. 允许移动（转移所有权）
    FileHandle(FileHandle&& other) noexcept
        : file_(other.file_)
    {
        other.file_ = nullptr;
    }

    FileHandle& operator=(FileHandle&& other) noexcept
    {
        if (this != &other) {
            if (file_) fclose(file_);
            file_ = other.file_;
            other.file_ = nullptr;
        }
        return *this;
    }

    FILE* get() const { return file_; }

private:
    FILE* file_;
};

这四步是 RAII 类的标准模板：获取、释放、禁拷贝、允许移动。

三、RAII 的常见形态

RAII 不只用于内存，任何「获取后必须释放」的资源都适用。

1. 锁

std::mutex mtx;

void safe_increment()
{
    std::lock_guard<std::mutex> lock(mtx);   // 构造时加锁
    ++shared_counter;
}   // 析构时自动解锁，异常也安全

手写 lock() / unlock() 的话，中间任何异常都会导致死锁。

2. 文件与流

{
    std::ofstream out("log.txt");
    out << "写点东西\n";
}   // 自动关闭并 flush

3. 数据库连接、网络连接

class Connection
{
public:
    Connection(const std::string& url) : conn_(connect(url)) {}
    ~Connection() { disconnect(conn_); }
    // ...
};

4. 临时状态恢复

RAII 也可以用来「保证状态被还原」：

class ScopedFlag
{
public:
    ScopedFlag(bool& flag) : flag_(flag), old_(flag) { flag_ = true; }
    ~ScopedFlag() { flag_ = old_; }
private:
    bool& flag_;
    bool old_;
};

void process()
{
    ScopedFlag guard(is_processing);   // 进入时设为 true
    // ... 无论怎么退出，都会恢复原值
}

5. 性能计时

class Timer
{
public:
    Timer(const char* name)
        : name_(name), start_(std::chrono::steady_clock::now()) {}

    ~Timer()
    {
        auto end = std::chrono::steady_clock::now();
        auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start_);
        std::cout << name_ << " 耗时 " << ms.count() << " ms\n";
    }

private:
    const char* name_;
    std::chrono::steady_clock::time_point start_;
};

void work()
{
    Timer t("work");   // 离开作用域自动打印耗时
    // ...
}

四、RAII 与异常安全

RAII 之所以重要，是因为它让异常安全变得可行。

考虑这个函数：

void bad()
{
    Resource* r1 = acquire();
    Resource* r2 = acquire();   // 抛异常 → r1 泄漏

    use(r1, r2);

    release(r2);
    release(r1);
}

改成 RAII：

void good()
{
    auto r1 = acquire();        // 返回 RAII 对象
    auto r2 = acquire();        // 抛异常 → r1 自动释放

    use(r1, r2);
}

不需要写 try / catch，资源也不会泄漏。这就是为什么标准库的异常安全保证能够成立——它建立在 RAII 之上。

析构函数不能抛异常

栈展开过程中，如果某个析构函数又抛出异常，而此时已有异常在传播，程序会直接调用 std::terminate。

~Bad()
{
    throw std::runtime_error("oops");   // 危险
}

C++11 起析构函数默认是 noexcept 的，在其中抛异常会导致终止。如果析构中确实可能失败（比如 fclose 返回值），应该吞掉异常或记录下来，而不是往外抛。

五、RAII 与所有权

RAII 的核心是「谁负责释放」。这引出了所有权的概念：

设计接口时应该明确表达所有权：

// 明确：函数接管所有权
void take(std::unique_ptr<Widget> w);

// 明确：函数只借用，不负责释放
void use(const Widget& w);
void use(Widget* w);   // 也常见，但不如引用清晰

// 明确：函数共享所有权
void share(std::shared_ptr<Widget> w);

裸指针作为参数本身没有错，但要清楚它表示「不拥有」——调用者负责保证对象在调用期间存活。

六、Rule of Three / Five / Zero

RAII 类需要正确处理拷贝和移动，这引出了几个经验法则。

Rule of Three（C++98）

如果类需要自定义析构函数、拷贝构造函数、拷贝赋值运算符中的任何一个，那么通常三个都需要。

原因：需要自定义析构，说明持有需要手动释放的资源；那么默认的拷贝行为（浅拷贝指针）会导致双重释放，必须一并处理。

Rule of Five（C++11）

加上移动构造函数和移动赋值运算符，变成五个：

class Buffer
{
public:
    Buffer(const Buffer&);              // 拷贝构造
    Buffer& operator=(const Buffer&);   // 拷贝赋值
    Buffer(Buffer&&) noexcept;          // 移动构造
    Buffer& operator=(Buffer&&) noexcept;  // 移动赋值
    ~Buffer();                          // 析构
};

如果定义了拷贝操作但没定义移动操作，编译器不会自动生成移动版本——此时「移动」会退化为拷贝，损失性能。

Rule of Zero

最好的做法是一个都不写。

用现成的 RAII 类型作为成员，编译器生成的默认操作就已经正确了：

class Widget
{
    std::string name_;                    // 自己管理内存
    std::vector<int> data_;               // 自己管理内存
    std::unique_ptr<Impl> impl_;          // 独占所有权
    std::shared_ptr<Config> config_;      // 共享所有权
};
// 不需要写析构、拷贝、移动——编译器生成的都对

这是现代 C++ 推荐的风格：让成员类型去管理资源，自己只管组合。

七、常见误区

「RAII 就是智能指针」 —— 智能指针只是 RAII 的一种应用。锁、文件、连接、临时状态恢复都是 RAII。

「RAII 会拖慢程序」 —— 析构调用是编译期确定的，和手写 delete 没有性能差异。反而因为减少了错误分支，代码往往更快。

「析构函数里可以随便做事」 —— 析构函数不能抛异常，也不应该做可能失败的操作。复杂的清理逻辑应该提供显式的 close() 方法，析构只做兜底。

「移动后源对象不能再用」 —— 移动后的对象处于「有效但未指定」状态，可以重新赋值或析构，但不能假设它的内容。

「拷贝构造和移动构造可以只写一个」 —— 定义了拷贝构造后，移动构造不会自动生成，此时移动会退化为拷贝。反之亦然。

八、相关章节

• 动态内存分配：为什么不该手写 delete
• 智能指针：RAII 在内存管理上的标准实现
• 异常处理：栈展开与异常安全保证
• 拷贝控制：Rule of Three / Five / Zero 的细节
• 多线程与并发：lock_guard 等 RAII 锁

内存调试与诊断

内存错误的特点是症状和原因往往离得很远。程序可能在一个完全无关的地方崩溃，或者运行几小时后才慢慢泄漏光内存。这一章讲几类常见错误的成因，以及怎么把它们揪出来。

一、常见内存错误

1. 内存泄漏

分配了内存却忘记释放：

void leak()
{
    int* p = new int(42);
    // 忘记 delete
}

后果是进程内存持续增长。短命程序可能无所谓，但服务端程序会慢慢吃光内存。

隐蔽的泄漏往往来自异常路径：

void subtleLeak()
{
    auto* a = new Resource();
    auto* b = new Resource();   // 如果这里抛异常，a 泄漏了
    // ...
    delete b;
    delete a;
}

还有一种是逻辑泄漏——内存还被引用着，但已经没用了：

std::vector<Connection> connections;

void cleanup()
{
    connections.clear();   // 如果 Connection 持有裸指针，指针指向的资源泄漏了
}

2. 悬垂指针

指针指向的对象已经销毁：

int* dangling()
{
    int local = 42;
    return &local;   // 栈帧已回收
}

int* p = dangling();
std::cout << *p;     // 未定义行为

堆上的版本更隐蔽：

int* p = new int(42);
int* q = p;
delete p;
std::cout << *q;   // q 悬垂

释放后内存可能被重新分配给别的对象，读到的值无法预料。这类 bug 在测试环境常常「看起来正常」，上线后才爆发。

3. 缓冲区越界

读写超出分配范围：

int* arr = new int[10];
arr[10] = 1;        // 越界写，破坏了相邻内存

char buf[8];
strcpy(buf, "这是一个很长的字符串");   // 栈溢出

越界写会破坏相邻对象的元数据或内容，症状可能在很久之后才出现。

std::vector 的 operator[] 不做检查，at() 会检查并抛异常：

std::vector<int> v(10);
v[10] = 1;      // 未定义行为
v.at(10) = 1;   // 抛 std::out_of_range

4. 重复释放

int* p = new int(42);
delete p;
delete p;   // 未定义行为

如果两个指针指向同一块内存，各自都以为该由自己释放：

void bad(std::unique_ptr<int> a, int* raw)
{
    // raw 是 a.get()，函数结束时 a 释放了内存
}
// 调用者又 delete raw → 重复释放

5. 释放方式不匹配

int* p1 = new int[10];
delete p1;          // 应该用 delete[]

int* p2 = (int*)malloc(sizeof(int));
delete p2;          // 应该用 free

int* p3 = new int(42);
free(p3);           // 应该用 delete

6. 未初始化内存

int* p = new int;      // 未初始化
std::cout << *p;       // 读到垃圾值

int arr[10];
std::cout << arr[0];   // 同上

用 new int() 或 new int{} 可以值初始化：

int* p = new int();    // 初始化为 0
int* q = new int{};    // 同上

二、检测工具

1. AddressSanitizer（ASan）

最推荐的入门工具，GCC 和 Clang 都内置：

g++ -fsanitize=address -g main.cpp -o main
./main

它能检测：

• 堆缓冲区越界
• 栈缓冲区越界
• 释放后使用（use-after-free）
• 重复释放
• 内存泄漏（配合 -fsanitize=leak）

输出示例：

==12345==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000000018
WRITE of size 4 at 0x602000000018 thread T0
    #0 0x400abc in main main.cpp:5

ASan 会给出精确的出错位置和调用栈，代价是程序变慢 2~3 倍、内存占用增加。适合在测试环境常开。

2. UndefinedBehaviorSanitizer（UBSan）

检测未定义行为：

g++ -fsanitize=undefined -g main.cpp -o main

能捕获整数溢出、空指针解引用、越界移位等。可以和 ASan 一起用：

g++ -fsanitize=address,undefined -g main.cpp -o main

3. Valgrind

老牌工具，不需要重新编译：

valgrind --leak-check=full ./main

输出：

==12345== HEAP SUMMARY:
==12345==     in use at exit: 4 bytes in 1 blocks
==12345==   total heap usage: 1 allocs, 0 frees, 4 bytes allocated
==12345==
==12345== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==12345==    at 0x4C2A2BB: operator new(unsigned long) (vg_replace_malloc.c:334)
==12345==    by 0x400ABC: main (main.cpp:4)

优点是能检测「可能泄漏」（still reachable）等 ASan 不报的情况，缺点是慢 10~50 倍。

4. 工具对比

建议：日常开发用 ASan + UBSan，CI 里跑一遍 Valgrind 兜底，多线程代码用 TSan。

5. ThreadSanitizer（TSan）

专门检测数据竞争：

g++ -fsanitize=thread -g main.cpp -o main -pthread

输出会指出竞争的两个位置：

WARNING: ThreadSanitizer: data race
  Write of size 4 at 0x7b0400000000 by thread T1:
    #0 increment() main.cpp:8
  Previous read of size 4 at 0x7b0400000000 by main thread:
    #0 main main.cpp:15

注意 TSan 和 ASan 不能同时使用，需要分开跑。

三、静态分析

编译器的警告是第一道防线，务必打开：

g++ -Wall -Wextra -Wpedantic -Wshadow -Wconversion main.cpp

Clang 的静态分析器能发现更深的问题：

clang++ --analyze main.cpp

它能识别出「分配后未释放」「空指针解引用」等模式，不需要运行程序。

四、自己写分配器钩子

重载全局 operator new / operator delete 可以记录所有分配：

#include <cstdlib>
#include <iostream>
#include <map>
#include <mutex>

namespace {
std::mutex g_mutex;
std::map<void*, std::size_t> g_allocations;
}

void* operator new(std::size_t size)
{
    void* p = std::malloc(size);
    if (!p) throw std::bad_alloc();

    std::lock_guard<std::mutex> lock(g_mutex);
    g_allocations[p] = size;
    return p;
}

void operator delete(void* p) noexcept
{
    if (!p) return;

    std::lock_guard<std::mutex> lock(g_mutex);
    g_allocations.erase(p);
    std::free(p);
}

// 程序退出时打印未释放的分配
struct Reporter
{
    ~Reporter()
    {
        if (!g_allocations.empty())
        {
            std::cerr << "泄漏 " << g_allocations.size() << " 处分配:\n";
            for (const auto& [p, size] : g_allocations)
                std::cerr << "  " << p << " (" << size << " 字节)\n";
        }
    }
};
Reporter g_reporter;

这个简易追踪器能告诉你有没有泄漏、泄漏了多少处，但拿不到调用栈。生产级的实现（如 ASan）会记录栈回溯。

五、预防措施

工具能帮你抓 bug，但更好的做法是让 bug 写不出来。

1. 用智能指针

// 容易出错
Widget* w = new Widget();
// ...
delete w;

// 不可能忘记释放
auto w = std::make_unique<Widget>();

2. 用容器代替裸数组

// 容易越界
int* arr = new int[n];
arr[i] = 1;
delete[] arr;

// 有边界检查（at）、自动管理
std::vector<int> arr(n);
arr.at(i) = 1;

3. 用 string 代替 char*

// 容易溢出
char buf[100];
strcpy(buf, input.c_str());

// 自动扩容
std::string buf = input;

4. 遵循 Rule of Zero

让成员类型管理资源，自己不写析构和拷贝：

class Widget
{
    std::string name_;
    std::vector<int> data_;
    std::unique_ptr<Impl> impl_;
    // 不需要写析构、拷贝、移动
};

5. 编译期检查

// 数组大小用常量表达式
constexpr std::size_t N = 10;
std::array<int, N> arr;

// 用 span 传递数组，避免退化成指针丢失大小
void process(std::span<int> data);

六、排查思路

遇到内存问题时，按这个顺序排查：

1. 打开所有警告，先看编译器报什么
2. 跑 ASan，多数越界和 UAF 会立即暴露
3. 跑 Valgrind，看有没有泄漏和未初始化读取
4. 如果是并发问题，跑 TSan
5. 如果还找不到，用 operator new 钩子记录分配，缩小范围
6. 最后手段：二分注释代码，定位问题区间

一个实用技巧：崩溃位置往往不是出错位置。如果 ASan 报告「堆缓冲区溢出」，重点看那块内存是谁分配的、谁写的，而不是崩溃的那一行。

七、常见误区

「测试通过就没内存问题」 —— 内存错误高度依赖具体的内存布局和执行时序，测试环境跑通不代表生产环境安全。

「用 delete 后置空就没问题了」 —— 置空只防止重复释放，防止不了其他指针的悬垂。

「ASan 太慢不能常开」 —— 在 CI 和本地测试环境开启完全可行，代价远小于线上排查一个内存 bug。

「Valgrind 能替代 ASan」 —— 两者互补。Valgrind 不需要重编译、能检测未初始化读取；ASan 更快、栈信息更准。

「内存泄漏只影响内存」 —— 泄漏的往往不只是内存。文件描述符、socket、锁、数据库连接泄漏同样致命。

「智能指针能解决所有问题」 —— 智能指针解决的是「忘记释放」，解决不了循环引用、逻辑泄漏、越界访问。

八、相关章节

• 动态内存分配：new / delete 的常见错误
• RAII 与资源管理：从设计上避免泄漏
• 智能指针：自动内存管理
• 自定义内存管理：分配器中的调试钩子
• C++ 内存模型（并发）：数据竞争与 TSan

C++ 内存模型（并发）

单线程程序里，「代码按顺序执行」是理所当然的。但在多线程环境下，编译器会重排指令、CPU 会乱序执行、缓存会让不同核心看到不同的值——你以为的顺序，在硬件层面完全不存在。

C++11 引入的内存模型（memory model）就是用来约束这些行为的：它规定了多线程程序在什么条件下能观察到什么值。理解它是写出正确并发代码的前提。

这一章偏理论，但每个概念都会落到实际用法上。

一、数据竞争

数据竞争（data race）的定义很明确：

两个线程同时访问同一内存位置，其中至少一个是写操作，且没有同步措施。

数据竞争的后果是未定义行为——不是「读到旧值」这么简单，而是编译器可以做任何假设，程序行为完全不可预测。

int counter = 0;   // 普通 int

void increment()
{
    for (int i = 0; i < 100000; ++i)
        ++counter;    // 数据竞争
}

int main()
{
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();

    std::cout << counter << '\n';   // 大概率不是 200000
}

++counter 实际是「读-改-写」三步，两个线程可能同时读到相同的值，导致丢失更新。

消除数据竞争只有两条路：加锁或用原子操作。

二、happens-before 关系

内存模型的核心概念是 happens-before。如果操作 A happens-before 操作 B，那么 A 的所有内存写入对 B 都可见。

happens-before 由几种关系组合而成：

1. 同线程内的顺序

同一线程中，前面的语句 happens-before 后面的语句：

int x = 1;      // A
int y = x + 1;  // B：A happens-before B

2. 锁的同步

一个线程解锁，另一个线程加同一个锁，则解锁 happens-before 加锁：

std::mutex mtx;
int data = 0;

// 线程 A
{
    std::lock_guard<std::mutex> lock(mtx);
    data = 42;          // 写
}                       // 解锁

// 线程 B
{
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << data;  // 保证读到 42
}                       // 加锁

这是互斥量能保证可见性的原因——它不只是「互斥」，还建立了同步关系。

3. 原子操作的同步

原子操作可以建立跨线程的 happens-before：

std::atomic<bool> ready{false};
int data = 0;

// 线程 A
data = 42;
ready.store(true, std::memory_order_release);   // 释放

// 线程 B
while (!ready.load(std::memory_order_acquire)) { }  // 获取
std::cout << data;   // 保证读到 42

release 和 acquire 配对，建立起 A 到 B 的同步关系。

4. 传递性

happens-before 具有传递性：如果 A → B 且 B → C，那么 A → C。

三、内存序

原子操作默认使用 std::memory_order_seq_cst（顺序一致），这是最严格也最慢的。C++ 提供了六种内存序：

1. relaxed：只要原子性

std::atomic<int> counter{0};

void increment()
{
    for (int i = 0; i < 100000; ++i)
        counter.fetch_add(1, std::memory_order_relaxed);
}
// 结果是确定的 200000，但不保证与其他变量的顺序关系

relaxed 只保证「计数不会丢失」，不建立任何同步。适合纯粹的计数器。

2. acquire / release：建立同步

这是最常用的一对，用于「生产者写完数据，通知消费者」：

std::atomic<bool> ready{false};
int payload = 0;

// 生产者
void produce()
{
    payload = 42;                                    // 先写数据
    ready.store(true, std::memory_order_release);    // 再发布
}

// 消费者
void consume()
{
    while (!ready.load(std::memory_order_acquire)) { }  // 等待发布
    std::cout << payload;   // 保证看到 42
}

关键点：release 之前的写入，对执行 acquire 的线程可见。如果这里用 relaxed，消费者可能看到 ready == true 但 payload 还是 0。

3. seq_cst：全局一致顺序

std::atomic<bool> x{false}, y{false};
std::atomic<int> z{0};

// 线程 A
x.store(true);   // 默认 seq_cst

// 线程 B
y.store(true);

// 线程 C
while (!x.load()) { }
if (y.load())
    ++z;

seq_cst 保证所有线程看到同一个全局操作顺序。这让推理变简单，但代价是需要内存屏障，性能比 acquire/release 差。

建议：默认用 seq_cst，确认是瓶颈后再降级到 acquire/release。

四、内存屏障

有时需要在没有原子操作的情况下插入同步点：

std::atomic_thread_fence(std::memory_order_release);

屏障本身不操作数据，只是限制重排。典型用法：

// 生产者
payload = 42;
std::atomic_thread_fence(std::memory_order_release);
flag.store(true, std::memory_order_relaxed);   // 用 relaxed 存

效果和直接在 store 上用 release 类似，但把同步点独立出来了。实际代码中很少需要，直接用 acquire/release 更清晰。

五、volatile 不是同步手段

这是最经典的误解。volatile 在 C++ 中的含义是：

• 告诉编译器「这个变量可能被外部修改」，不要优化掉对它的访问
• 不提供任何原子性
• 不提供任何线程间同步
• 不建立 happens-before 关系

volatile int counter = 0;

void increment()
{
    ++counter;   // 仍然是数据竞争！
}

volatile 的正确用途是访问内存映射的硬件寄存器，或者配合 setjmp/longjmp。多线程同步必须用 std::atomic 或互斥量。

六、实际应用

1. 双重检查锁定

单例模式中常见的写法，但很容易写错：

class Singleton
{
public:
    static Singleton& instance()
    {
        if (!instance_)                              // 第一次检查（无锁）
        {
            std::lock_guard<std::mutex> lock(mtx_);
            if (!instance_)                          // 第二次检查
                instance_ = std::make_unique<Singleton>();
        }
        return *instance_;
    }

private:
    static std::unique_ptr<Singleton> instance_;
    static std::mutex mtx_;
};

这里的 instance_ 是普通指针，第一次检查是数据竞争。正确做法是用原子指针：

static std::atomic<Singleton*> instance_;

static Singleton& instance()
{
    Singleton* p = instance_.load(std::memory_order_acquire);
    if (!p)
    {
        std::lock_guard<std::mutex> lock(mtx_);
        p = instance_.load(std::memory_order_relaxed);
        if (!p)
        {
            p = new Singleton();
            instance_.store(p, std::memory_order_release);
        }
    }
    return *p;
}

不过更简单的做法是用 C++11 的局部静态变量——标准保证它是线程安全的：

static Singleton& instance()
{
    static Singleton inst;   // 线程安全的初始化
    return inst;
}

2. 无锁队列

用原子操作实现的生产者-消费者队列，核心是 CAS 循环：

template<class T>
class LockFreeStack
{
    struct Node
    {
        T data;
        Node* next;
    };

    std::atomic<Node*> head_{nullptr};

public:
    void push(T value)
    {
        Node* newNode = new Node{std::move(value), nullptr};
        newNode->next = head_.load(std::memory_order_relaxed);

        // CAS 循环：如果 head_ 还是 newNode->next，就换成 newNode
        while (!head_.compare_exchange_weak(newNode->next, newNode,
                                            std::memory_order_release,
                                            std::memory_order_relaxed))
        { }
    }
};

无锁编程极其困难，上面这个栈还有 ABA 问题。除非有明确的性能需求，否则用互斥量。

3. 原子计数器

最简单的场景：

std::atomic<std::size_t> requestCount{0};

void handleRequest()
{
    requestCount.fetch_add(1, std::memory_order_relaxed);   // 只需原子性
    // ...
}

这里 relaxed 就够了——我们只关心计数正确，不关心它和其他变量的顺序。

七、常见误区

「volatile 可以用于多线程同步」 —— 不能。它不提供原子性，也不建立 happens-before。这是 Java 程序员最常带入 C++ 的错误。

「原子操作就是无锁」 —— 不一定。std::atomic<T> 对某些类型可能内部用锁实现，可以用 is_lock_free() 检查。

「relaxed 是没用的」 —— 它保证了原子性，适合纯计数器场景，性能最好。

「seq_cst 太慢，应该都用 acquire/release」 —— 在 x86 上两者性能差异很小，在 ARM 上才明显。先保证正确性，再考虑优化。

「atomic 变量的所有操作都是原子的」 —— 单个操作是原子的，但复合操作不是：

std::atomic<int> x{0};

if (x > 0)      // 原子读
    x--;        // 原子写
// 但「检查再减」整体不是原子的，中间可能被插入

「多个原子变量之间有一致性」 —— 没有。两个独立的原子变量之间不保证任何顺序关系，除非用 seq_cst 或显式同步。

八、相关章节

• 多线程与并发：线程、互斥量、条件变量的使用
• 内存布局与模型：单线程视角的内存布局
• 内存调试与诊断：用 TSan 检测数据竞争
• 智能指针：shared_ptr 的线程安全性

面向对象进阶

在这一阶段，需要解决的问题不再是“能不能用类”，而是“如何让类体系设计得更合理、更高效、更安全”。

这一部分的核心是深入理解对象间的关系与行为机制，理解编译器在背后为我们做了什么，从而能在面对复杂系统时，自信地控制对象生命周期、类型转换和继承结构。

1. 运算符重载： 对象能否像内置类型一样使用 +、==、[] 等运算符？怎样定义它们才能符合直觉又不出错？特别是赋值运算符、比较运算符的语义要与类设计保持一致。

2. 继承与派生结构： 为什么要继承？什么时候该用继承、什么时候该用组合？多继承会引发哪些问题（比如二义性和菱形继承）？虚继承又是如何解决的？

3. 虚函数与多态： 运行时多态是如何实现的？虚表（vtable）是怎么工作的？析构函数为什么要定义为虚函数？什么场景下多态反而会带来性能或逻辑问题？

4. 友元与类关系： 当类之间需要共享私有数据时，友元机制如何使用？为什么要谨慎使用友元？在大型项目中，友元往往是“设计不合理”的信号还是必要的桥梁？

5. 模板高级应用： 模板不只是泛型编程，它还能实现多态、类型推导、SFINAE 等复杂行为。要理解模板与继承、多态的结合——如何用模板替代虚函数以获得更高性能。

6. 类型转换与转换运算符： 从基本类型到类类型的转换（构造函数隐式转换），从类类型到基本类型（转换运算符）之间隐藏着哪些风险？如何避免意外转换或歧义？

7. 拷贝控制： 拷贝构造、赋值运算符、移动构造、移动赋值和析构函数的完整语义——RAII 的核心。理解“拷贝与移动”意味着理解对象的完整生命周期。

8. C++新特性在面向对象中的影响： 现代C++（C++11及之后）的特性，如智能指针、右值引用、override、final、=default、=delete 等，改变了我们对类设计的传统思维。要掌握如何用这些新特性强化封装性和安全性。

这一章的目标，不是单纯记住语法，而是要能回答：

“当我写下一个类、继承一个父类、重载一个函数时，编译器究竟在背后做了什么？”

本章内容

运算符重载（Operator Overloading）

一、概述

C++ 是一种支持面向对象编程的语言，在其类型系统中，除了内置类型（如 int、double）外，用户还可以自定义类（Class）来表示复杂数据结构。 然而，类的对象默认并不能像内置类型那样使用 +、==、<< 等运算符。为了让自定义类型具备直观、自然的操作方式，C++ 允许程序员重定义（overload）运算符的行为，使得运算符能作用于类的对象。

这种机制称为运算符重载（Operator Overloading）。它是 C++ 多态性的重要体现之一，使自定义类型可以拥有与内置类型一致的使用体验。

二、运算符重载的定义形式

运算符重载的本质是一个函数定义，它的函数名以 operator 开头，后接要重载的运算符符号。

基本形式如下：

返回类型 operator运算符(参数列表);

运算符重载函数既可以定义为类的成员函数，也可以定义为友元函数（friend function）。 对于成员函数形式，函数的第一个操作数是当前对象本身（通过隐式的 this 指针传递）； 对于友元函数形式，则需要显式地接收两个参数。

三、可重载与不可重载的运算符

并非所有运算符都可以被重载。C++ 出于语言安全性和可维护性的考虑，对部分运算符做出了限制。

此外，重载不会改变运算符的优先级和结合性，也不能引入新的运算符符号。

四、成员函数与友元函数重载的区别

1. 成员函数形式 适用于当左操作数是类对象时。例如：

   Complex a, b, c;
   c = a + b;     // 调用 a.operator+(b)
   

   在这种情况下，函数原型为：

   Complex operator+(const Complex& rhs) const;
   

2. 友元函数形式 当运算符左边不是该类的对象，或者需要访问私有成员时，使用友元函数更合适。

   friend Complex operator+(const Complex& lhs, const Complex& rhs);
   

3. 主要区别

这两种形式在使用时完全一致，可以直接使用a+b调用重载的符号。

五、算术运算符的重载

算术运算符（如 +、-、*、/）是最常见的重载形式之一。 下面以复数类 Complex 为例，说明如何重载加法运算符 +。

#include <iostream>
class Complex {
private:
    double real, imag;

public:
    Complex(double r=0, double i=0) : real(r), imag(i) {}

    Complex operator+(const Complex& rhs) const {
        return Complex(real + rhs.real, imag + rhs.imag);
    }

    void display() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};

int main() {
    Complex a(2.0, 3.0), b(1.5, 2.0);
    Complex c = a + b;      // 调用 a.operator+(b)
    c.display();            // 输出 3.5 + 5i
}

该示例中，运算符函数返回一个新的对象，不改变原操作数的内容。

六、比较运算符的重载

对象之间的比较并不会自动发生。若要实现“对象是否相等”的判断，需要重载比较运算符。

示例：

class Point {
private:
    int x, y;

public:
    Point(int a, int b) : x(a), y(b) {}

    bool operator==(const Point& rhs) const {
        return x == rhs.x && y == rhs.y;
    }

    bool operator!=(const Point& rhs) const {
        return !(*this == rhs);
    }
};

int main() {
    Point p1(1, 2), p2(1, 2), p3(2, 3);
    if (p1 == p2) std::cout << "p1 and p2 are equal" << std::endl;
    if (p1 != p3) std::cout << "p1 and p3 are not equal" << std::endl;
}

比较运算符通常返回布尔值，并应保证逻辑自洽性（如 == 和 != 应互为补充）。

七、赋值运算符的重载

C++ 默认会生成一个“浅拷贝”的赋值运算符，这在涉及动态内存管理的类中往往会引发问题。 因此，通常需要手动重载 operator=，以实现深拷贝（deep copy）。

#include <cstring>

class String {
private:
    char* data;

public:
    String(const char* s = "") {
        data = new char[strlen(s) + 1];
        strcpy(data, s);
    }

    String& operator=(const String& rhs) {
        if (this != &rhs) {                 // 防止自赋值
            delete[] data;
            data = new char[strlen(rhs.data) + 1];
            strcpy(data, rhs.data);
        }
        return *this;                       // 返回自身引用
    }

    ~String() { delete[] data; }
};

重载赋值运算符的注意事项：

1. 检查自赋值（防止对象赋给自己）。
2. 正确释放旧内存并重新分配。
3. 返回 *this 的引用以支持链式赋值。

八、输入输出运算符的重载

流插入运算符 << 和流提取运算符 >> 无法作为成员函数重载，因为左操作数通常是标准流对象（如 std::cout 或 std::cin）。 因此，通常将它们重载为友元函数。

#include <iostream>
using namespace std;

class Complex {
private:
    double real, imag;

public:
    Complex(double r=0, double i=0) : real(r), imag(i) {}

    friend ostream& operator<<(ostream& os, const Complex& c) {
        os << c.real << " + " << c.imag << "i";
        return os;
    }

    friend istream& operator>>(istream& is, Complex& c) {
        is >> c.real >> c.imag;
        return is;
    }
};

int main() {
    Complex c1;
    cin >> c1;
    cout << c1 << endl;
}

这种方式使得自定义类对象可以与标准输入输出流无缝交互。

九、自增与自减运算符的重载

C++ 区分前置与后置两种形式：

• 前置 ++a：函数无形参；
• 后置 a++：函数带一个虚拟的 int 形参，用于区分。

class Counter {
private:
    int value;

public:
    Counter(int v = 0) : value(v) {}

    Counter& operator++() {          // 前置 ++
        ++value;
        return *this;
    }

    Counter operator++(int) {        // 后置 ++
        Counter temp = *this;
        ++value;
        return temp;
    }

    int get() const { return value; }
};

继承

继承（Inheritance）是面向对象编程的三大特征之一（封装、继承、多态）之一，它使得我们可以在已有类的基础上创建新的类，从而实现代码复用与层次结构的抽象建模。

C++ 的继承机制极其灵活，既可以实现简单的单继承（Single Inheritance），也可以进行复杂的多继承（Multiple Inheritance），甚至支持通过**虚继承（Virtual Inheritance）**来解决多重继承带来的“菱形问题”。

一、继承的基本概念

继承是从一个已有的类（称为基类 / 父类 Base Class）派生出一个新的类（称为派生类 / 子类 Derived Class）。 派生类自动拥有基类的成员（数据与函数），并可以在此基础上新增成员或重写行为。

语法格式如下：

class 派生类名 : 继承方式 基类名 {
    // 派生类成员
};

二、基类构造与派生类构造顺序

派生类对象中包含了基类子对象，因此在创建派生类实例时，必须先调用基类构造函数来完成基类部分的初始化。

调用顺序如下：

1. 按声明顺序调用所有基类构造函数（从上到下）。
2. 再调用派生类自身构造函数。

销毁顺序则相反： 先调用派生类析构函数，再调用基类析构函数。

示例：

class Base {
public:
    Base() { std::cout << "Base constructed\n"; }
    ~Base() { std::cout << "Base destroyed\n"; }
};

class Derived : public Base {
public:
    Derived() { std::cout << "Derived constructed\n"; }
    ~Derived() { std::cout << "Derived destroyed\n"; }
};

int main() {
    Derived d;
}

输出结果为：

Base constructed
Derived constructed
Derived destroyed
Base destroyed

若基类构造函数需要参数，必须在派生类的构造函数初始化列表中显式调用：

class Base {
public:
    Base(int x) { std::cout << "Base(" << x << ")\n"; }
};

class Derived : public Base {
public:
    Derived(int x) : Base(x) {
        std::cout << "Derived(" << x << ")\n";
    }
};

构造函数调用顺序是从“上至下”，析构顺序是从“下至上”。 这种严格的顺序保证了对象的完整性和资源的正确释放。

三、访问控制与继承权限

访问控制是继承体系中非常重要的机制，它决定了哪些成员可以在派生类中被访问。

继承方式主要有三种：

1. public 成员

   • 在 public 继承中保持 public，外部依然可以访问。
   • 在 protected/private 继承中则变为不可外部访问。

2. protected 成员

   • 在 public/protected 继承中可被派生类访问。
   • 在 private 继承中仅在本类可访问。

3. private 成员

   • 永远不能被派生类直接访问。

class Base {
public:
    int a;
protected:
    int b;
private:
    int c;
};

class Derived : public Base {
public:
    void show() {
        a = 1;   // 可访问（public继承下保持public）
        b = 2;   // 可访问（protected继承下保持protected）
        // c = 3; // 不可访问（private成员永远不能被继承访问）
    }
};

在继承中，private 成员虽然被继承，但不可直接访问，只能通过基类的 public 或 protected 接口间接访问。

四、单继承与多继承

1. 单继承

最常见的继承方式，一个派生类只有一个直接基类：

class Animal {
public:
    void eat() { std::cout << "Eating\n"; }
};

class Dog : public Animal {
public:
    void bark() { std::cout << "Barking\n"; }
};

Dog 继承了 Animal 的所有非私有成员，因此：

Dog d;
d.eat();  // 继承自 Animal
d.bark(); // 自身成员

2. 多继承

C++ 支持一个类继承自多个基类，从而组合多种功能：

class A {
public:
    void funcA() { std::cout << "A\n"; }
};

class B {
public:
    void funcB() { std::cout << "B\n"; }
};

class C : public A, public B {
public:
    void funcC() { std::cout << "C\n"; }
};

C 同时拥有 A 和 B 的成员：

C obj;
obj.funcA();
obj.funcB();
obj.funcC();

但多继承容易引入命名冲突：

class A { public: void show() { std::cout << "A\n"; } };
class B { public: void show() { std::cout << "B\n"; } };
class C : public A, public B {};

C c;
c.show();  // 二义性错误：不知该调用 A::show 还是 B::show

需使用作用域限定符解决：

c.A::show();

五、多重继承的菱形问题

多继承中最著名的问题是“菱形继承问题（Diamond Problem）”。

示例：

class A {
public:
    int value = 1;
};

class B : public A {};
class C : public A {};
class D : public B, public C {};

继承关系如下：

    A
   / \
  B   C
   \ /
    D

此时，D 同时继承了两份 A，因此 value 出现二义性：

D d;
d.value = 10;   // 二义性：B::A::value 与 C::A::value 冲突

六、虚继承（Virtual Inheritance）

为解决菱形问题，C++ 引入了 虚继承（Virtual Inheritance）。

通过在继承声明前加上关键字 virtual，可以让共同的基类只保留一份共享副本。

修改上例：

class A {
public:
    int value = 1;
};

class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {};

此时：

D d;
d.value = 10;   // 不再二义性，A仅保留一份

在对象布局上，编译器会通过额外的“虚基表指针（vbptr）”来实现共享基类的唯一性。 因此，虚继承的对象模型更复杂，但解决了最棘手的多继承冲突问题。

Tip

虚基表指针(vbptr)如何实现共享基类的唯一性？

在普通多继承中，如果一个基类被多个派生类重复继承（如“菱形继承”结构），最底层派生类对象中会包含多份相同的基类成员，造成 数据冗余 和 二义性。

为了解决这一问题，C++ 提供了 虚继承（virtual inheritance）。编译器通过在对象中引入一套特殊的指针机制——虚基表指针（vbptr） 和 虚基表（vbtable），来确保所有派> 生路径最终共享同一个虚基类实例。

• 当一个类以 virtual 方式继承基类时，编译器会在该类的对象布局中添加一个隐藏成员：vbptr。
• vbptr 指向一张由编译器生成的 虚基表（vbtable）。
• vbtable 中记录了从当前对象地址到虚基类子对象地址的偏移量。
• 当程序访问虚基类的成员时，编译器通过 vbptr 查表计算出正确的虚基类位置，确保所有继承路径共享同一个虚基类实例。

class A { int x; };
class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {};

在 D 的对象布局中：

D
├── B 子对象（含 vbptr → 指向 B 的 vbtable）
├── C 子对象（含 vbptr → 指向 C 的 vbtable）
└── A 虚基类子对象（唯一一份）

访问 A::x 时：

• 若通过 B 或 C 访问，编译器都会通过 vbptr 找到唯一的 A 子对象；
• 从而避免了重复继承带来的“二义性”与“多份拷贝”问题。

虚继承常用于框架或接口设计中，尤其当多个中间层类共享同一顶层基类时。

虚函数与多态

多态（Polymorphism）是面向对象的核心特征之一，它让我们可以通过统一的接口来操作不同类型的对象。C++ 的多态是通过 虚函数（virtual function）机制 实现的，它使得函数调用在运行时（而非编译时）才确定具体执行哪个版本——这被称为 动态绑定（Dynamic Binding）。

一、虚函数表机制（vtable）

理解虚函数，必须先理解它背后的实现机制：虚函数表（Virtual Table）。

当一个类中包含虚函数时，编译器会为该类自动生成一张“虚函数表”，记录所有虚函数的地址。 每个含虚函数的对象中，会隐式包含一个指向这张表的指针（称为 vptr）。

1. 生成虚函数表（vtable）： 为该类自动生成一张只读表，其中记录了所有虚函数的地址。
2. 植入虚指针（vptr）： 每个含虚函数的对象中，会隐式包含一个指向这张表的指针（vptr）。在主流编译器中，vptr 通常是对象内存布局中的第一个成员。

换句话说，每个对象在内存中都携带一张“函数地址目录”，在调用虚函数时，程序会通过这张表找到该对象对应的函数实现。

一个典型的过程如下：

1. 为该类生成一张虚函数表（vtable）。
2. 每个对象内部会有一个指针（vptr），在构造函数中初始化，指向所属类的 vtable。
3. 当通过基类指针或引用调用虚函数时，程序会查找 vtable 来决定实际执行哪个函数。

例如：

class Base {
public:
    virtual void show() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived\n"; } // C++11 推荐使用 override
};

Base* p = new Derived();
p->show();  // 输出：Derived

编译器生成的伪逻辑相当于：

(*(p->vptr[0]))(p);  // 从 vtable[0] 取出函数指针并调用

这就是 动态绑定 的本质。

二、纯虚函数与抽象类

有时，基类只定义接口而不提供具体实现，这时就需要 纯虚函数（pure virtual function）。

纯虚函数的定义方式是在声明末尾加上 = 0：

class Shape {
public:
    // 纯虚函数，只提供接口，没有实现体
    virtual void draw() = 0;
};

当类中含有至少一个纯虚函数时，该类就成为 抽象类（Abstract Class）。

抽象类不能被实例化，只能被继承。

它的作用是定义一个统一的接口，让派生类去实现具体行为。

例如：

class Shape {
public:
    virtual void draw() = 0;
};

class Circle : public Shape {
public:
    void draw() override { std::cout << "Drawing Circle\n"; } // 必须实现 draw()
};

// Shape s; // 错误：不能实例化抽象类
Circle c;    // 正确：Circle 实现了所有纯虚函数

Shape 不能直接创建对象，但 Circle 可以，因为它实现了 draw()。

这种方式让我们能通过“基类接口”统一管理不同对象，实现真正意义上的多态。

三、动态绑定 vs 静态绑定

静态绑定（Static Binding） 是在编译阶段就决定函数调用的目标，依据是变量的声明类型。 动态绑定（Dynamic Binding） 则在运行时根据对象的实际类型决定调用哪个函数。

示例：

class Base {
public:
    void func() { std::cout << "Base::func\n"; }
    virtual void vfunc() { std::cout << "Base::vfunc\n"; }
};

class Derived : public Base {
public:
    void func() { std::cout << "Derived::func\n"; }
    void vfunc() override { std::cout << "Derived::vfunc\n"; }
};

Base* p = new Derived();
p->func();   // 静态绑定 -> 调用 Base::func (基类指针只能看到基类声明的非虚函数)
p->vfunc();  // 动态绑定 -> 调用 Derived::vfunc (通过 vtable 确定实际类型)

Tip

强烈建议在派生类中重写虚函数时使用 override 关键字。 override 显式告知编译器该函数意图是重写基类的虚函数。如果签名（函数名、参数、const 性）与基类不匹配，编译器将报错，从而避免了重写失败导致的行为错误。

四、析构函数的虚函数问题

一个常见的陷阱：基类的析构函数必须声明为虚函数。

否则当通过基类指针 delete 派生类对象时，如果析构函数不是虚函数，将发生静态绑定，只会调用基类的析构函数。 会导致派生类中特有的资源（如动态分配的内存、文件句柄等）将不会被释放，导致内存泄漏或资源泄漏。

class Base {
public:
    // 必须是虚函数，确保通过基类指针删除时能触发动态绑定
    virtual ~Base() { std::cout << "Base destroyed\n"; }
};

class Derived : public Base {
private:
    int* data;
public:
    Derived() : data(new int[10]) {}
    ~Derived() override {
        delete[] data; // 派生类特有的资源释放
        std::cout << "Derived destroyed\n";
    }
};

Base* p = new Derived();
delete p;  // 1. 动态绑定调用 Derived::~Derived() 2. 调用 Base::~Base()
// 保证了所有资源的正确释放

五、虚函数的开销

虚函数机制提供了强大的灵活性（多态），但它不是零代价的。使用虚函数会带来一定的性能和内存开销：

1. 空间开销 (对象层面)： 每个含有虚函数的对象，都会增加一个 vptr 指针的存储空间（在 64 位系统上通常是 8 字节）。
2. 空间开销 (类层面)： 每个含有虚函数的类都需要生成一张 vtable 来存储函数指针。
3. 时间开销： 虚函数的调用比普通函数（静态绑定）多了一步间接寻址（查找 vptr \(\to\) 访问 vtable \(\to\) 调用函数）。虽然开销微小，但在高度性能敏感的循环中，可能会产生可见的影响。

因此，只有当确实需要多态特性时，才应该将函数声明为虚函数。

友元与类关系

封装是面向对象的基础——把数据藏起来，只暴露必要的接口。但有时两个类确实需要共享内部状态，比如容器和它的迭代器、对象和它的工厂函数。

friend 就是为这种情况准备的：它允许指定的函数或类访问私有成员。但它的代价是打破封装，所以用之前要想清楚是不是真的必要。

这一章还讨论类之间的几种关系——组合、聚合、依赖——它们决定了对象之间该怎么互相持有。

一、友元函数

友元函数不是成员函数，但能访问类的私有成员：

class Point
{
private:
    double x_, y_;

public:
    Point(double x, double y) : x_(x), y_(y) {}

    // 声明友元
    friend double distance(const Point& a, const Point& b);
};

// 定义（不需要 friend 关键字）
double distance(const Point& a, const Point& b)
{
    double dx = a.x_ - b.x_;   // 可以访问私有成员
    double dy = a.y_ - b.y_;
    return std::sqrt(dx * dx + dy * dy);
}

什么时候需要友元函数

运算符重载是最常见的场景。当运算符的左操作数不是类对象时，必须用非成员函数：

class Complex
{
    double re_, im_;

public:
    Complex(double re, double im) : re_(re), im_(im) {}

    // 需要访问私有成员，所以声明为友元
    friend std::ostream& operator<<(std::ostream& os, const Complex& c);
    friend Complex operator+(double lhs, const Complex& rhs);
};

std::ostream& operator<<(std::ostream& os, const Complex& c)
{
    return os << c.re_ << "+" << c.im_ << "i";
}

// 支持 2.0 + complex，而不仅仅是 complex + 2.0
Complex operator+(double lhs, const Complex& rhs)
{
    return Complex(lhs + rhs.re_, rhs.im_);
}

operator<< 的左操作数是 ostream，double + Complex 的左操作数是 double——都不是 Complex 对象，所以不能定义为成员函数。

友元的几个特性

• 友元关系不可传递：A 是 B 的友元，B 是 C 的友元，不代表 A 是 C 的友元
• 友元关系不可继承：基类的友元不能访问派生类的私有成员
• 友元声明不受访问控制影响：可以放在 private、protected 或 public 区域，效果相同
• 友元不是成员：不受 this 指针影响，调用方式与普通函数一致

二、友元类

整个类都可以成为友元：

class Matrix
{
private:
    double* data_;
    int rows_, cols_;

    friend class MatrixIterator;   // 迭代器需要访问内部数据
    friend class MatrixFactory;    // 工厂需要直接构造
};

友元类中的所有成员函数都能访问对方的私有成员。

一个典型场景是迭代器：

class Container
{
    int* data_;
    std::size_t size_;

public:
    class Iterator
    {
        int* ptr_;
    public:
        int& operator*() { return *ptr_; }
        Iterator& operator++() { ++ptr_; return *this; }
        // ...
    };

    Iterator begin() { return Iterator{data_}; }
    Iterator end()   { return Iterator{data_ + size_}; }
};

这里迭代器用嵌套类实现，作为成员类天然可以访问外部类的私有成员，不需要 friend。