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

┌─────────────────┐  高地址
│     栈（Stack）    │  ← 局部变量、函数参数（编译器自动管理）
├─────────────────┤
│     堆（Heap）     │  ← new/malloc 分配（程序员手动管理）
├─────────────────┤
│  全局/静态存储区   │  ← 全局变量、static 变量
│  .data（已初始化） │
│  .bss（未初始化）  │
├─────────────────┤
│  常量存储区 .rodata│  ← 字符串常量、const 全局变量
├─────────────────┤
│   代码区 .text     │  ← 可执行机器指令
└─────────────────┘  低地址

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

// malloc/free：仅分配和释放内存
int* p = (int*)malloc(sizeof(int) * 10);
free(p);

// new/delete：分配内存 + 构造/析构对象
int* p = new int(42);           // 分配 + 初始化
delete p;                        // 析构 + 释放

Person* arr = new Person[10];   // 数组
delete[] arr;                    // 注意：数组必须用 delete[]

// 有了 malloc/free 为什么还需要 new/delete？
// 因为对于非内部数据类型，malloc/free 无法调用构造/析构函数
class Foo {
public:
    Foo() { cout << "构造"; }
    ~Foo() { cout << "析构"; }
};

Foo* p1 = (Foo*)malloc(sizeof(Foo));  // 不会调用构造函数
Foo* p2 = new Foo();                   // 会调用构造函数
delete p2;                             // 会调用析构函数

1
2
3
4
5
6
7

int* p;               // 野指针：未初始化
// *p = 10;           // 危险！

int* q = new int(5);
delete q;
// *q = 10;           // 空指针：内存已释放
q = nullptr;           // 安全：释放后置空

1
2
3

auto_ptr<string> p1(new string("hello"));
auto_ptr<string> p2;
p2 = p1;  // p1 失去所有权，再次访问 p1 会崩溃

1
2
3
4
5
6

unique_ptr<string> p1(new string("hello"));
// unique_ptr<string> p2 = p1;     // 编译错误！禁止拷贝
unique_ptr<string> p2 = move(p1);  // 转移所有权，p1 变为空

// 推荐：使用 make_unique（C++14）
auto p = make_unique<string>("hello");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

shared_ptr<int> p1 = make_shared<int>(42);
{
    shared_ptr<int> p2 = p1;  // 引用计数 +1
    cout << p1.use_count();   // 输出 2
}  // p2 析构，引用计数 -1
// p1 析构时引用计数归零，释放内存

// 引用计数存储在控制块（Control Block）中：
// - 强引用计数：shared_ptr 数量
// - 弱引用计数：weak_ptr 数量
// - 删除器、分配器

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

struct B;
struct A {
    shared_ptr<B> b_ptr;
    ~A() { cout << "A 析构"; }
};
struct B {
    // shared_ptr<A> a_ptr;  // 循环引用，导致内存泄漏
    weak_ptr<A> a_ptr;        // 使用 weak_ptr 打破循环
    ~B() { cout << "B 析构"; }
};

auto a = make_shared<A>();
auto b = make_shared<B>();
a->b_ptr = b;
b->a_ptr = a;  // weak_ptr 不会增加引用计数
// a 和 b 都能正常析构

// weak_ptr 通过 lock() 获取 shared_ptr
if (auto shared = weak.lock()) {
    // 安全访问
}

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

int a = 10;
int* p = &a;     // 指针：存储 a 的地址
int& r = a;      // 引用：a 的别名

*p = 20;         // 通过指针修改
r = 30;          // 通过引用修改（无需解引用）

// 引用参数传递：无需拷贝，直接操作原对象
void swap(int& a, int& b) {
    int t = a;
    a = b;
    b = t;
}

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

void byValue(int x) { x = 10; }        // 不影响实参
void byPointer(int* p) { *p = 10; }    // 修改实参
void byReference(int& r) { r = 10; }   // 修改实参

int a = 5;
byValue(a);      // a = 5
byPointer(&a);   // a = 10
byReference(a);  // a = 10

// 指针传参时，改变指针本身不影响外部
void changePtr(int* p) {
    p = new int(20);  // 只改了形参的指向，外部无影响
}
// 需要用指针的引用才能修改指针本身
void changePtrRef(int*& p) {
    p = new int(20);  // 外部指针也会改变
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class BankAccount {
private:
    double balance;  // 私有，外部不可直接访问

public:
    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
    double getBalance() const { return balance; }
};

1
2

构造函数顺序：基类 → 成员对象 → 派生类自身
析构函数顺序：派生类自身 → 成员对象 → 基类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Base {
public:
    virtual void func1() { cout << "Base::func1"; }
    virtual void func2() { cout << "Base::func2"; }
};

class Derived : public Base {
public:
    virtual void func1() override { cout << "Derived::func1"; }
    virtual void func3() { cout << "Derived::func3"; }
};

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

Base 对象：
┌─────────────┐
│ vptr → Base │  ← 指向 Base 的虚函数表
│ vtable      │
│   func1 ────┼──→ Base::func1
│   func2 ────┼──→ Base::func2
└─────────────┘

Derived 对象：
┌─────────────┐
│ vptr →Derived│  ← 指向 Derived 的虚函数表
│ vtable       │
│   func1 ─────┼──→ Derived::func1（重写，覆盖基类地址）
│   func2 ─────┼──→ Base::func2（未重写，保留基类地址）
│   func3 ─────┼──→ Derived::func3（新增）
└─────────────┘

1
2

Base* p = new Derived();
delete p;  // 如果析构函数不是虚函数，只会调用 Base 的析构，Derived 的资源泄漏

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

// 纯虚函数：在基类中声明但不实现，派生类必须重写
class Shape {
public:
    virtual double area() const = 0;  // 纯虚函数
    virtual void draw() const = 0;
};

// 含有纯虚函数的类称为抽象类，不能实例化
// Shape s;  // 编译错误！

class Circle : public Shape {
public:
    double area() const override { return 3.14 * r * r; }
    void draw() const override { cout << "画圆形"; }
private:
    double r;
};

1
2
3
4
5
6
7

class Print {
public:
    void show(int i) { cout << i; }
    void show(double d) { cout << d; }
    void show(string s) { cout << s; }
};
// 编译时根据参数确定调用哪个版本

1
2
3
4
5
6
7
8

class Base {
public:
    virtual void func() { cout << "Base"; }
};
class Derived : public Base {
public:
    void func() override { cout << "Derived"; }  // 重写
};

1
2
3
4
5
6

class Base final { };  // 禁止继承
// class Derived : Base { };  // 编译错误

class Base2 {
    virtual void func() final;  // 禁止重写
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Base {
public:
    void func(int x) { }
};
class Derived : public Base {
public:
    void func(string s) { }  // 隐藏了基类的 func(int)
};
// Derived d;
// d.func(10);      // 编译错误！因为 func(int) 被隐藏了
// d.Base::func(10); // 需通过基类作用域调用

1
2

const int MAX = 100;      // 常量
int const MIN = 0;        // 等价

1
2
3
4

const int* p = &a;  // 指向常量的指针（指针指向的内容不可变）
int* const p = &a;  // 常量指针（指针本身不可变，不能改指向）
const int* const p = &a;  // 指向常量的常量指针
// 左定值（const 在 * 左），右定向（const 在 * 右）

1

void print(const string& s);  // 不修改 s

1
2
3
4
5
6
7
8

class Person {
    int age;
public:
    int getAge() const { return age; }  // const 成员函数
    // 若需要修改某个成员，用 mutable
    mutable int cache;
    int getCache() const { return cache++; }  // mutable 可在 const 函数中修改
};

1
2
3
4
5

void func() {
    static int count = 0;  // 只初始化一次
    count++;
    cout << count;  // 多次调用时，count 会累加
}

1
2
3

// file1.cpp
static int x = 10;      // 只在 file1.cpp 中可见
static void helper() { } // 只在 file1.cpp 中可调用

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

class MyClass {
public:
    static int value;            // 静态成员变量（所有对象共享一份）
    static void func() { }       // 静态成员函数（无 this 指针）
};
int MyClass::value = 0;          // 必须在类外初始化

// 静态成员函数的特点：
// 1. 无 this 指针
// 2. 只能访问静态成员变量
// 3. 不能被 virtual 修饰
// 4. 通过 类名:: 调用

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

class String {
private:
    char* data;
public:
    // 浅拷贝（默认）：两个 String 的 data 指向同一块内存
    // String(const String& other) : data(other.data) { }

    // 深拷贝：分配新内存
    String(const String& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }

    ~String() {
        delete[] data;
    }

    // 赋值运算符也需要深拷贝
    String& operator=(const String& other) {
        if (this == &other) return *this;  // 自赋值检查
        delete[] data;
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
        return *this;
    }
};

1
2
3
4
5
6
7

void funcByValue(String s) { }     // 值传递：拷贝构造
String funcReturn() {
    String s("hello");
    return s;                       // 返回值：拷贝构造
}
String s1 = s2;                     // 初始化：拷贝构造
String s3(s2);                      // 直接构造：拷贝构造

1
2
3
4

// String(String other)  // 值传递 → 又需要拷贝构造来创建 other
// → 无限递归调用！

String(const String& other)  // 引用传递，避免递归

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

// 基本语法
auto lambda = [] { cout << "Hello"; };
lambda();

// 带参数
auto add = [](int a, int b) -> int { return a + b; };

// 捕获外部变量
int x = 10;
auto byValue = [x] { return x; };         // 值捕获
auto byRef = [&x] { return ++x; };        // 引用捕获
auto allValue = [=] { /* 值捕获所有 */ };
auto allRef = [&] { /* 引用捕获所有 */ };
auto mix = [=, &x] { /* 其余值捕获，x 引用捕获 */ };

// STL 算法中的 Lambda
vector<int> v = {1, 8, 5, 3, 6, 10};
int val = 3;
int count = count_if(v.begin(), v.end(), [val](int x) { return x > val; });

// mutable：允值捕获的变量在函数体内修改
auto mutableLambda = [x]() mutable { x++; return x; };

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

int&& rref = 42;  // 右值引用绑定到临时值

class Person {
    char* data;
public:
    // 移动构造函数：从右值中"偷"资源
    Person(Person&& other) noexcept {
        data = other.data;         // 偷取指针
        other.data = nullptr;      // 原对象置空，防止双重释放
    }

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

// std::move：将左值转为右值引用，触发移动语义
vector<int> v1 = {1, 2, 3};
vector<int> v2 = move(v1);  // v1 的资源被移动到 v2，v1 变为空

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

auto a = 10;                 // a 是 int
auto b = 3.14;               // b 是 double
auto c = "hello";            // c 是 const char*

vector<int> v = {1, 2, 3};
for (auto it = v.begin(); it != v.end(); ++it) { }  // 自动推导迭代器类型

decltype(a) d = 20;          // d 是 int
const int& ref = a;
decltype(ref) e = a;         // e 是 const int&

1
2
3
4
5
6
7

// C++03：NULL 是宏，可能被定义为 0 或 (void*)0
void func(int);       // #1
void func(char*);     // #2
func(NULL);           // 调用 #1（意外！）

// C++11：nullptr 是真正的空指针类型，安全
func(nullptr);        // 调用 #2（符合预期）

1
2
3
4
5
6

vector<int> v;
v.reserve(100);  // 预分配容量，避免多次扩容

// 扩容过程示意图：
// capacity=1 → push_back → capacity=2（分配新内存，移动元素）
// → push_back → capacity=4 → push_back → capacity=8 ...

1
2
3
4

int i = 10;
float f = static_cast<float>(i);                // 数值类型转换
Base* b = new Derived();
Derived* d = static_cast<Derived*>(b);          // 向下转换（不安全，不检查）

1
2
3
4
5
6

Base* b = new Derived();
Derived* d = dynamic_cast<Derived*>(b);  // 成功，返回有效指针
if (d) { /* 安全操作 */ }

Base* base = new Base();
Derived* d2 = dynamic_cast<Derived*>(base);  // 失败，返回 nullptr

1
2
3

const int ci = 10;
int& modifiable = const_cast<int&>(ci);  // 移除 const 属性
modifiable = 20;  // 如果原对象本质是 const，这是未定义行为

1
2

int* p = new int(65);
char* ch = reinterpret_cast<char*>(p);  // 指针类型强制转换

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

class MemoryPool {
private:
    struct Block {
        Block* next;
    };
    Block* freeList = nullptr;

public:
    MemoryPool(size_t blockSize, size_t count) {
        for (size_t i = 0; i < count; i++) {
            Block* block = reinterpret_cast<Block*>(new char[blockSize]);
            block->next = freeList;
            freeList = block;
        }
    }

    void* allocate() {
        if (!freeList) throw bad_alloc();
        Block* block = freeList;
        freeList = freeList->next;
        return block;
    }

    void deallocate(void* ptr) {
        Block* block = reinterpret_cast<Block*>(ptr);
        block->next = freeList;
        freeList = block;
    }
};

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

.cpp 文件
    ↓ 预处理（Preprocessing）
展开 #define、处理 #include、删除注释
    ↓
.i 文件
    ↓ 编译（Compilation）
词法分析 → 语法分析 → 语义分析 → 生成汇编代码
    ↓
.s 文件
    ↓ 汇编（Assembly）
汇编代码 → 机器指令
    ↓
.o 文件（目标文件）
    ↓ 链接（Linking）
符号解析 + 重定向 → 合并目标文件和库
    ↓
可执行文件（.exe / a.out）

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

class MyClass {
    int value;
public:
    MyClass& setValue(int value) {
        this->value = value;    // 区分成员变量和参数
        return *this;            // 链式调用
    }

    bool operator==(const MyClass& other) {
        return this == &other;  // 检查是否同一对象
    }
};
// 链式调用：obj.setValue(10).setValue(20);