C++ 基础知识整理

01编译与链接基础P5-P7

理解 C++ 代码如何从源文件变成可执行程序，是学习后续所有内容的前置知识。

翻译单元（Translation Unit）

一个 .cpp 源文件经过预处理（展开 #include、替换宏）后，得到的单个文本就是翻译单元。编译器以翻译单元为单位进行编译，每个翻译单元独立编译为一个 .obj（目标文件）。

编译流程

// 编译器的工作流程：
// 1. 预处理：展开 #include、替换 #define、处理 #if/#ifdef
// 2. 生成抽象语法树（AST）
// 3. 生成汇编代码
// 4. 生成目标文件（.obj / .o）

// 单独编译一个文件：Ctrl+F7（VS）
// 编译整个项目：Build（会触发链接）

链接（Linking）

链接器将所有目标文件合并为一个可执行文件（.exe）。它的核心任务是找到每个符号（函数、变量）的定义，将调用处与定义处连接起来。

// main.cpp 中调用了 Log()，但 Log() 定义在 Log.cpp 中
// 编译时：main.cpp 只需要 Log() 的声明
// 链接时：链接器在 Log.obj 中找到 Log() 的定义并连接

// 声明（告诉编译器这个函数存在）
void Log(const char* message);

int main() {
    Log("Hello");  // 链接器负责找到 Log 的定义
}

常见链接错误

02变量与数据类型P8

C++ 基本数据类型按整数和小数两大类划分，不同类型占用不同字节数，取值范围也不同。

unsigned 修饰符

unsigned 表示无符号（仅非负数），取值范围从 0 开始。例如 unsigned char 范围为 0 ~ 255。可加在各整数类型前。

sizeof 运算符

使用 sizeof(类型) 可查看某类型占用的字节数：

// 查看类型大小
sizeof(int);     // 4
sizeof(char);    // 1
sizeof(double);  // 8
sizeof(long);     // Windows: 4, Linux/macOS: 8

03控制结构P12 · P37

条件判断语句根据条件的真假决定执行路径。

if 语句

条件为真时执行代码块。

if (条件) {
    // 条件为真时执行
}

if-else 语句

if (条件) {
    // ① 条件为真时执行
} else {
    // ② 条件为假时执行
}

三元运算符 ? :

条件表达式的简写形式：条件 ? 值A : 值B。常用于取最大值等场景：

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

switch-case 语句

多分支选择结构，根据变量值跳转到对应 case。每个 case 后需加 break 防止贯穿。

switch (变量) {
    case 1:
        // 执行操作 1
        break;
    case 2:
        // 执行操作 2
        break;
    default:
        // 默认操作
        break;
}

04循环结构P14

三种循环方式，适用于不同的重复执行场景。

// for 循环
for (int i = 0; i < 10; i++) {
    // 重复执行 10 次
}

// while 循环
while (条件) {
    // 条件为真时重复执行
}

// do-while 循环（至少执行一次）
do {
    // 代码块
} while (条件);  // 注意末尾分号

05流程控制关键字P15

用于在循环或函数中改变执行流程。

06指针P16

指针是存储变量内存地址的特殊变量，是 C/C++ 的核心概念之一。

核心运算符

使用示例

int var = 8;        // 声明变量
int* ptr = &var;      // 指针 ptr 存储 var 的地址

*ptr = 10;           // 通过指针修改变量的值
// 此时 var 的值变为 10

07引用P17

引用是已有变量的别名，本质上是一个"扩展的指针"，但使用更简洁。

基本用法

int a = 5;
int& ref = a;   // ref 是 a 的引用（别名）

ref = 3;        // 通过 ref 修改，a 也变为 3

08内存管理：new / deleteP39

使用 new 在堆上动态分配内存，使用完毕后必须用 delete 释放，避免内存泄漏。

// 动态分配字符数组
char* buffer = new char[8];

// 使用完毕后释放
delete[] buffer;

09函数基础P9

函数是将代码封装为可复用模块的基本单元。

函数结构

返回类型 函数名(参数列表) {
    // 函数体
    return 返回值;
}

示例：

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

void sayHello() {   // void 表示无返回值
    // 执行操作，不需要 return
}

• 返回类型：函数返回值的数据类型
• 函数名：调用时使用的标识符
• ()：参数列表，可为空
• {}：函数体，包含具体代码
• void：表示函数无返回值

10类与结构体P18-P19

类和结构体都是将变量（数据）和函数（方法）组合在一起的复合类型，区别在于默认访问权限。

class 类名 {
    // 默认 private
    int data;
public:
    void method();
};

struct 结构体名 {
    // 默认 public
    int data;
    void method();
};

11常用关键字P21 · P24 · P30 · P34

四个重要的类型与作用域相关关键字（后续章节有更深入的展开）。

// const 常量
const int a = 5;   // a 不可被修改

// enum 枚举
enum Color {
    RED,      // 0
    GREEN,    // 1
    BLUE      // 2
};

12static 关键字深入P21-P23

static 在不同上下文有不同含义：翻译单元内的内部链接、类级别的共享成员、函数内的持久局部变量。

类外的 static：内部链接（P21）

类或结构体之外的 static 表示该变量或函数的链接性为内部链接，即只对定义它的翻译单元（.cpp 文件）可见。链接器不会在其他翻译单元中寻找该符号。

// static.cpp —— 定义
static int s_variable = 8;  // 仅本翻译单元可见
static void function() { }

// main.cpp —— 另一个翻译单元
int s_variable = 5;  // 全局变量，与上面的 static 互不冲突
int main() {
    LOG(s_variable);  // 输出 5
}

类内的 static：共享成员（P22）

类或结构体内部的 static 变量在所有实例中只有一个副本。通过类实例引用静态变量没有意义，应通过 类名::变量名 引用。

struct Entity {
    static int x, y;
    static void Print() {
        std::cout << x << "," << y << std::endl;
    }
};

int Entity::x;  // 静态变量需在类外定义
int Entity::y;

int main() {
    Entity::x = 5;
    Entity::y = 8;
    Entity::Print();  // 输出 5,8
}

• 静态方法不需要通过实例调用，可通过 类名::方法名() 直接调用
• 静态方法不能访问非静态成员（没有 this 指针）
• 非静态方法必须与特定对象绑定才能调用

局部 static：持久局部变量（P23）

局部 static 变量的生存期等同于整个程序，但作用域仍限制在函数内。它只初始化一次，后续调用保留上一次的值。

// 使用 static —— 输出 0 1 2 3 4
void counter() {
    static int count = 0;  // 只初始化一次
    std::cout << count++ << std::endl;
}

// 不使用 static —— 输出 0 0 0 0 0
void counter_bad() {
    int count = 0;  // 每次调用都重新初始化
    std::cout << count++ << std::endl;
}

13构造函数P25

构造函数在创建对象时自动调用，用于初始化成员变量，确保对象创建时即处于有效状态。

class Entity {
public:
    float X, Y;

    Entity() {  // 默认构造函数
        X = 0.0f;
        Y = 0.0f;
    }

    Entity(float x, float y) {  // 带参数构造函数
        X = x;
        Y = y;
    }
};

int main() {
    Entity e;              // 调用默认构造函数
    Entity e2(5.0f, 6.0f);  // 调用带参数构造函数
}

• 构造函数名与类名一致，没有返回类型
• 如果不提供构造函数，编译器会生成一个空的默认构造函数
• 构造函数可以重载（多个不同参数的构造函数）
• 如果定义了带参数构造函数但没定义默认构造函数，则 Entity e; 会报错

14析构函数P26

析构函数在对象销毁时自动调用，用于清理内存和释放资源。以 ~ 标识，函数名与类名一致。

class Entity {
public:
    Entity() {
        std::cout << "Created Entity!" << std::endl;
    }

    ~Entity() {  // 析构函数
        std::cout << "Destroyed Entity!" << std::endl;
    }
};

• 栈上对象：离开作用域时自动调用析构
• 堆上对象：delete 时调用析构
• 如果类中用 new 分配了内存，必须在析构函数中 delete

15继承P27

继承允许子类从父类获得属性和方法，是减少代码重复的核心机制。

class Entity {  // 基类
public:
    float X, Y;
    void Move(float xa, float ya) {
        X += xa;
        Y += ya;
    }
};

class Player : public Entity {  // 派生类
public:
    const char* Name;
    void PrintName() {
        std::cout << Name << std::endl;
    }
};

int main() {
    Player player;
    player.Move(5, 5);    // 继承自 Entity
    player.X = 2;         // 继承的变量
    player.PrintName();   // Player 自己的方法
}

16虚函数P28

虚函数允许子类重写父类方法，实现运行时多态（动态绑定）。这是面向对象编程的核心机制。

class Entity {
public:
    virtual std::string GetName() { return "Entity"; }
    // virtual 告诉编译器：这个方法可能被重写
};

class Player : public Entity {
private:
    std::string m_Name;
public:
    Player(const std::string& name) : m_Name(name) {}
    std::string GetName() override { return m_Name; }
    // override 关键字（C++11）帮助编译器检查重写
};

int main() {
    Player* p = new Player("Cherno");
    Entity* entity = p;  // 向上转型

    // 如果没有 virtual，这里输出 "Entity"
    // 有 virtual，输出 "Cherno"（多态）
    std::cout << entity->GetName() << std::endl;
}

17纯虚函数与接口P29

纯虚函数是没有实现的虚函数，包含它的类成为抽象类（接口），不能被实例化。派生类必须实现所有纯虚函数。

class Printable {  // 接口：只包含纯虚函数
public:
    virtual std::string GetClassName() = 0;  // = 0 表示纯虚
};

class Entity : public Printable {
public:
    std::string GetClassName() override { return "Entity"; }
};

class Player : public Entity {
public:
    std::string GetClassName() override { return "Player"; }
};

void Print(Printable* obj) {  // 接受接口指针
    std::cout << obj->GetClassName() << std::endl;
}

int main() {
    Entity* e = new Entity();
    Player* p = new Player();
    Print(e);  // 输出 Entity
    Print(p);  // 输出 Player
    // Printable x;  // 错误！抽象类不能实例化
}

18可见性P30

可见性控制类成员谁能访问：public（所有人）、private（仅类内）、protected（类内和子类）。

class Entity {
public:
    int PublicVar;
protected:
    int ProtectedVar;
private:
    int PrivateVar;
};

class SubEntity : public Entity {
public:
    void Test() {
        PublicVar = 1;       // 可以
        ProtectedVar = 2;    // 可以（子类中）
        // PrivateVar = 3;   // 错误！
    }
};

int main() {
    Entity e;
    e.PublicVar = 1;         // 可以
    // e.ProtectedVar = 2;  // 错误！
    // e.PrivateVar = 3;    // 错误！
}

19数组P31

数组是连续内存中存储的一组相同类型元素。C++ 原生数组不记录自身大小，访问越界是未定义行为。

// 栈上数组
int array[5];
for (int i = 0; i < 5; i++) {
    array[i] = i * 2;
}

// 栈上数组初始化
int array2[5] = {1, 2, 3, 4, 5};

// 堆上数组
int* heapArray = new int[5];
delete[] heapArray;  // 必须用 delete[]

// 计算数组大小（仅对栈数组有效）
int size = sizeof(array) / sizeof(array[0]);  // 5

20字符串与字符串字面量P32-P33

C++ 有两种字符串：C 风格 const char*（以 \0 结尾）和 std::string（封装类）。

C 风格字符串与 std::string

// C 风格字符串
const char* name = "Cherno";
// 实际存储: {'C','h','e','r','n','o','\0'}，共 7 字节

// std::string
#include <string>
std::string str = "Cherno";
std::string concat = std::string("Hello") + " " + str;

// 传递给函数时用 const 引用避免拷贝
void PrintString(const std::string& str);

字符串字面量（P33）

字符串字面量存储在只读内存区域，不可修改。C++14 引入了 s 后缀可直接创建 std::string。

using namespace std::string_literals;  // C++14

std::string s1 = "Cherno"s;       // s 后缀 → std::string
const char* s2 = "Cherno";        // const char*

// 不同前缀对应不同编码
// "Hello"    → const char*      (ASCII)
// L"Hello"   → const wchar_t*   (宽字符)
// u8"Hello"  → const char*      (UTF-8)
// u"Hello"   → const char16_t*  (UTF-16)
// U"Hello"   → const char32_t*  (UTF-32)

21const 深入与 mutableP34-P35

const 承诺不会改变，mutable 允许在 const 方法中例外地修改特定成员。

const 与指针的三种组合

const int* a = new int;       // 指向的内容不能改，指针可以改
int* const b = new int;       // 指针不能改，指向的内容可以改
const int* const c = new int; // 都不能改

const 方法

class Entity {
private:
    int m_X, m_Y;
public:
    int GetX() const {  // const 方法：不修改成员
        // m_X = 2;  // 错误！
        return m_X;
    }
    void SetX(int x) { m_X = x; }
};

void PrintEntity(const Entity& e) {
    std::cout << e.GetX() << std::endl;
    // e.SetX(2);  // 错误！const 引用不能调用非 const 方法
}

mutable 关键字（P35）

mutable 允许在 const 方法中修改被修饰的成员变量。最常用的场景是缓存（lazy evaluation）：第一次调用时计算并缓存结果，后续直接返回缓存值。

class Entity {
private:
    std::string m_FirstName = "Cherno";
    std::string m_LastName = "Dev";
    mutable bool m_Cached = false;
    mutable std::string m_CachedFullName;
public:
    const std::string& GetFullName() const {
        if (!m_Cached) {
            m_CachedFullName = m_FirstName + " " + m_LastName;
            m_Cached = true;  // 可以！mutable 允许在 const 方法中修改
        }
        return m_CachedFullName;
    }
};

22成员初始化列表P36

在构造函数中用初始化列表直接初始化成员，比在函数体中赋值更高效。

Entity()
    : m_Name("Unknown"), m_Score(0)
{
    // 直接初始化
}

Entity() {
    m_Name = "Unknown";
    m_Score = 0;
    // 先默认构造，再赋值
}

23隐式转换与 explicitP40

单参数构造函数可被编译器用于隐式类型转换。explicit 禁止这种隐式转换，要求显式构造。

class Entity {
private:
    std::string m_Name;
    int m_Age;
public:
    Entity(int age) : m_Age(age) { }  // 可隐式转换
    Entity(const std::string& name) : m_Name(name) { }
};

void PrintEntity(const Entity& e) { }

int main() {
    PrintEntity(22);  // int 隐式转换为 Entity
    Entity a = 22;  // 隐式转换：int → Entity

    // 加 explicit 后：
    // explicit Entity(int age) : m_Age(age) { }
    // PrintEntity(22);      // 错误！
    // PrintEntity(Entity(22)); // 正确！显式构造
}

24运算符重载P41

运算符重载允许为自定义类型定义 +、==、[]、()、<< 等运算符的行为。运算符本质上是函数。

算术与比较运算符

struct Vector2 {
    float x, y;

    Vector2(float x, float y) : x(x), y(y) {}

    Vector2 operator+(const Vector2& other) const {
        return Vector2(x + other.x, y + other.y);
    }

    bool operator==(const Vector2& other) const {
        return x == other.x && y == other.y;
    }
};

// 重载 << 用于输出（非成员函数）
std::ostream& operator<<(std::ostream& stream, const Vector2& v) {
    stream << v.x << ", " << v.y;
    return stream;
}

下标运算符 operator[]

自定义容器类经常需要重载 []，使其像数组一样通过索引访问元素。

class IntArray {
    int m_Data[5];
public:
    int& operator[](int index) {
        return m_Data[index];  // 返回引用，允许赋值
    }
};

int main() {
    IntArray arr;
    arr[0] = 42;       // 通过 operator[] 赋值
    int val = arr[0];  // 通过 operator[] 读取
}

函数调用运算符 operator()

重载 () 使对象像函数一样可调用，这种对象称为仿函数（Functor）。

struct Multiplier {
    int factor;
    Multiplier(int f) : factor(f) {}

    int operator()(int value) const {
        return value * factor;
    }
};

int main() {
    Multiplier triple(3);
    int result = triple(5);  // 像函数一样调用，输出 15
}

25this 关键字P42

this 是指向当前对象的指针，在非静态成员方法中始终指向调用该方法的对象。

class Entity {
private:
    int x, y;
public:
    Entity(int x, int y) {
        this->x = x;  // 区分成员变量和参数
        this->y = y;
    }

    Entity& Add(const Entity& other) {
        x += other.x;
        y += other.y;
        return *this;  // 返回自身引用，支持链式调用
    }
};

int main() {
    Entity e(1, 2);
    e.Add(Entity(3, 4)).Add(Entity(5, 6));  // 链式调用
    // 结果: x=9, y=12
}

• this 用于区分同名成员变量和参数
• 返回 *this 实现链式调用
• 静态方法没有 this 指针（这也是静态方法不能访问非静态成员的原因）

26对象生命周期（栈作用域）P43

栈上对象的生命周期由作用域决定：进入作用域创建，离开作用域自动销毁。这是 RAII 模式的基础。

class Entity {
public:
    Entity() { std::cout << "Created" << std::endl; }
    ~Entity() { std::cout << "Destroyed" << std::endl; }
};

int main() {
    {
        Entity e;  // 输出 "Created"
    }  // 离开作用域，自动析构，输出 "Destroyed"
}

RAII：用栈对象管理堆资源

class ScopedArray {
    int* m_Array;
public:
    ScopedArray(int size) : m_Array(new int[size]) {}
    ~ScopedArray() { delete[] m_Array; }
    int& operator[](int index) { return m_Array[index]; }
};

int main() {
    {
        ScopedArray arr(50);
        arr[0] = 5;
    }  // 自动 delete[] m_Array，无需手动释放
}

27智能指针P44

智能指针是自动管理堆内存的类，使用 RAII 模式。需要 #include <memory>。三种主要类型各有不同所有权语义。

#include <memory>

// unique_ptr：独占所有权
{
    std::unique_ptr<Entity> entity = std::make_unique<Entity>();
    entity->Print();
    // 离开作用域自动 delete
    // std::unique_ptr<Entity> e2 = entity;  // 错误！不能复制
}

// shared_ptr：共享所有权，引用计数
{
    std::shared_ptr<Entity> sharedEntity = std::make_shared<Entity>();
    {
        std::shared_ptr<Entity> e2 = sharedEntity;  // 引用计数 +1 = 2
    }  // 引用计数 -1 = 1，不销毁
}  // 引用计数 = 0，销毁

// weak_ptr：不增加引用计数
{
    std::weak_ptr<Entity> weakEntity;
    {
        std::shared_ptr<Entity> sharedEntity = std::make_shared<Entity>();
        weakEntity = sharedEntity;  // 不增加引用计数
    }  // sharedEntity 销毁，weakEntity 失效
}

28拷贝构造与拷贝赋值P45

拷贝构造函数在创建新对象时调用，拷贝赋值运算符在已有对象之间赋值时调用。默认执行浅拷贝，如果类中有指针成员需要自定义深拷贝。

class String {
private:
    char* m_Buffer;
    unsigned int m_Size;
public:
    String(const char* string) {
        m_Size = strlen(string);
        m_Buffer = new char[m_Size + 1];
        memcpy(m_Buffer, string, m_Size + 1);
    }

    // ① 拷贝构造函数：创建新对象时调用
    String(const String& other) : m_Size(other.m_Size) {
        m_Buffer = new char[m_Size + 1];
        memcpy(m_Buffer, other.m_Buffer, m_Size + 1);
    }

    // ② 拷贝赋值运算符：已存在对象之间赋值时调用
    String& operator=(const String& other) {
        if (this != &other) {  // 防止自赋值
            delete[] m_Buffer;  // 释放旧内存
            m_Size = other.m_Size;
            m_Buffer = new char[m_Size + 1];
            memcpy(m_Buffer, other.m_Buffer, m_Size + 1);
        }
        return *this;
    }

    ~String() { delete[] m_Buffer; }

    char& operator[](unsigned int index) { return m_Buffer[index]; }
};

拷贝构造 vs 拷贝赋值

29模板P53

模板是编译器的"蓝图"，根据使用方式自动生成代码。模板本身不是真实代码，只有被实例化（使用）时才生成实际代码。

函数模板

template<typename T>
void Print(const T& value) {
    std::cout << value << std::endl;
}

int main() {
    Print(5);               // 隐式推断 T=int
    Print("Hello");         // 隐式推断 T=const char*
    Print<float>(5.5f);     // 显式指定 T=float
}

类模板（类型参数 + 非类型参数）

template<typename T, int N>
class MyArray {
private:
    T m_Array[N];  // 类型 T 和大小 N 都在编译时确定
public:
    int Length() const { return N; }
    T& operator[](int index) { return m_Array[index]; }
};

int main() {
    MyArray<int, 4> array;  // int 数组，大小为 4
    array[0] = 42;
    std::cout << array.Length() << std::endl;  // 4
}

模板特化（Specialization）

有时通用模板对某些特定类型不适用，需要为该类型提供特殊实现，这称为模板特化。

// 通用模板
template<typename T>
void Print(const T& value) {
    std::cout << value << std::endl;
}

// 全特化：为 bool 类型提供特殊实现
template<>
void Print<bool>(const bool& value) {
    std::cout << (value ? "true" : "false") << std::endl;
}

int main() {
    Print(5);       // 调用通用模板，输出 5
    Print(true);     // 调用特化版本，输出 "true"
}

30现代 C++ 特性P56 · P59-P60

C++11/14/17 引入的一系列特性，让代码更简洁、更安全、更高效。

// auto 类型推导
auto x = 5;              // int
auto name = std::string("Cherno");
auto& ref = x;            // 引用，避免拷贝

// nullptr 替代 NULL
int* ptr = nullptr;      // 类型安全
// int* ptr = NULL;      // 旧写法，NULL 可能被定义为 0，有歧义

// range-based for 循环
int arr[] = {1, 2, 3, 4, 5};
for (auto val : arr) {
    std::cout << val << std::endl;
}
for (auto& val : arr) {  // 引用，可修改原值
    val *= 2;
}

// constexpr 编译期常量
constexpr int SIZE = 10;  // 编译期确定
int buffer[SIZE];           // 可用作数组大小

31常见陷阱

C++ 学习过程中最容易踩的坑，每个开发者都应该知道。

32术语表

本笔记中出现的关键术语速查。

33移动语义P85 · P89-P90

移动语义是现代 C++ 最重要的性能优化手段之一：通过"偷取"临时对象的资源而非拷贝，避免不必要的内存分配和数据复制。

左值与右值（P85）

理解移动语义的前提是分清左值和右值。Cherno 的建议：不要纠结严格定义，知道它们是什么即可。

int GetValue() { return 10; }       // 返回右值
int& GetLValue() { static int v = 10; return v; } // 返回左值引用

void PrintName(std::string& name) { }    // 左值引用版本
void PrintName(std::string&& name) { }   // 右值引用版本（&&）

int main() {
    int i = 10;             // i 左值，10 右值
    int j = GetValue();    // GetValue() 是右值
    GetLValue() = 5;       // 返回左值引用，可赋值

    std::string first = "Yan", last = "Chernikov";
    PrintName(first);              // 调用左值引用版本
    PrintName(first + last);       // 调用右值引用版本（临时值）
}

移动构造函数（P89）

移动构造函数与拷贝构造函数的区别：拷贝需要分配新内存并复制数据（O(n)），移动直接接管源对象的指针（O(1)）。

String(const String& other) {
    m_Size = other.m_Size;
    m_Buffer = new char[m_Size];
    memcpy(m_Buffer, other.m_Buffer,
           m_Size);
    // O(n)：分配+复制
}

String(String&& other) noexcept {
    m_Size = other.m_Size;
    m_Buffer = other.m_Buffer;  // 直接接管！
    other.m_Size = 0;
    other.m_Buffer = nullptr;
    // O(1)：只改指针
}

std::move 与移动赋值（P90）

std::move 实际上并不移动任何东西，它只是把左值强制转换为右值引用（static_cast<T&&>）。真正的移动发生在移动构造/赋值函数接收这个右值时。

// 移动赋值运算符（给已存在的对象赋值）
String& operator=(String&& other) noexcept {
    if (this != &other) {       // 1. 防止自赋值
        delete[] m_Buffer;     // 2. 释放自身旧资源
        m_Size = other.m_Size;   // 3. 接管对方资源
        m_Buffer = other.m_Buffer;
        other.m_Size = 0;        // 4. 源对象置空
        other.m_Buffer = nullptr;
    }
    return *this;
}

int main() {
    String apple = "Apple";
    String dest = std::move(apple);  // 触发移动构造

    String banana = "Banana";
    String home;                     // 默认构造
    home = std::move(banana);           // 触发移动赋值
}

Rule of Five（五法则）

管理资源的类，C++11 后需要考虑五个特殊成员函数：

class Resource {
public:
    ~Resource();                              // ① 析构
    Resource(const Resource& other);          // ② 拷贝构造
    Resource& operator=(const Resource&);     // ③ 拷贝赋值
    Resource(Resource&& other) noexcept;      // ④ 移动构造
    Resource& operator=(Resource&&) noexcept; // ⑤ 移动赋值
};

常见错误

34STL 常用容器P47-P48 · P100

标准模板库（STL）提供了大量现成的数据结构，实际开发中天天使用。掌握 vector、map、string 的常用操作是必备技能。

std::vector — 动态数组

头文件 <vector>。连续内存，O(1) 随机访问，尾部插入 O(1)，中间插入 O(n)。

#include <vector>

// 初始化
std::vector<int> v1;                    // 空
std::vector<int> v2(5);                 // 5 个 0
std::vector<int> v3(5, 10);             // 5 个 10
std::vector<int> v4 = {1, 2, 3, 4, 5};  // 列表初始化（C++11）

// 增删访问
v1.push_back(42);         // 尾部插入
v1.pop_back();            // 删除尾部
v1[0] = 10;              // 下标访问（不检查越界）
v1.at(0) = 20;           // at 检查越界，抛 out_of_range
v1.front();               // 首元素
v1.back();                // 尾元素

// 大小与容量
v1.size();                // 当前元素个数
v1.capacity();            // 当前分配容量
v1.reserve(1000);        // 预分配，避免多次扩容（推荐！）
v1.clear();               // 清空（size=0，capacity 不变）

// 遍历
for (int x : v4) { }          // 范围 for（推荐）
for (auto& x : v4) { x *= 2; }  // 引用，可修改

// 中间插入/删除（O(n)）
v4.erase(v4.begin() + 1);   // 删除索引 1
v4.insert(v4.begin() + 1, 99); // 在索引 1 插入 99

std::map / std::unordered_map — 关联容器

std::map 底层是红黑树（有序，O(log n)）；std::unordered_map 底层是哈希表（无序，O(1) 平均）。

#include <map>
#include <unordered_map>
#include <string>

std::map<std::string, int> scores;

// 插入
scores["alice"] = 95;           // operator[]：不存在则插入，存在则覆盖
scores.insert({"bob", 87});    // insert：键已存在则不插入
scores.emplace("charlie", 92); // emplace：就地构造（最高效）

// 查找
auto it = scores.find("alice");
if (it != scores.end()) {
    std::cout << it->second;     // 95
}

// ⚠️ 访问不存在的键会插入默认值！
int v = scores["dave"];       // 输出 0，且 "dave" 被插入！

// 遍历（map 按键的字典序）
for (const auto& [name, score] : scores) {  // C++17 结构化绑定
    std::cout << name << ": " << score << '\n';
}

// 删除
scores.erase("dave");

std::string — 字符串

头文件 <string>。比 C 风格 char[] 更安全易用。

#include <string>

std::string s = "Hello";

// 长度
s.size();            // 5（与 length() 等价）
s.empty();           // false

// 增删改
s += " World";       // 追加 → "Hello World"
s.append("!!!");     // 追加
s.push_back('x');    // 追加单字符
s.insert(5, ",");     // 在位置 5 插入
s.erase(0, 2);        // 从位置 0 删除 2 个字符
s.substr(0, 5);       // 子串 "Hello"

// 查找
size_t pos = s.find("World");
if (pos != std::string::npos) { }  // 找到了

// 与 C 字符串互转
const char* c = s.c_str();   // 转 const char*

// 输入
std::getline(std::cin, s);  // 读整行（含空格，推荐）

35速查表（Cheat Sheet）

将 34 章精华压缩为极简参考，方便面试前或写代码时快速扫一眼。

指针 vs 引用

const 位置含义（从右往左读）

static 的三种用法

堆 vs 栈

智能指针选择

拷贝 vs 移动

访问权限速查

容器选择速查

Rule of Five 速查

// 管理资源的类需要自定义这 5 个函数：
~Resource();                           // ① 析构：释放资源
Resource(const Resource&);            // ② 拷贝构造：深拷贝
Resource& operator=(const Resource&);   // ③ 拷贝赋值：深拷贝
Resource(Resource&&) noexcept;          // ④ 移动构造：偷资源
Resource& operator=(Resource&&) noexcept; // ⑤ 移动赋值：偷资源