内存管理 ⭐⭐⭐

#include <iostream>
 
// 一个简单的函数调用示例，用来观察栈帧的创建与销毁
int add(int a, int b) {       // 参数 a, b 被压入 add() 的栈帧
    int result = a + b;        // 局部变量 result 也在 add() 的栈帧中
    return result;             // 函数返回后，add() 的栈帧被弹出（pop）
}
 
int main() {                   // main() 的栈帧是最底层的用户栈帧
    int x = 10;                // x 存储在 main() 的栈帧中
    int y = 20;                // y 紧接着 x，也在 main() 的栈帧中
    int z = add(x, y);         // 调用 add()：新栈帧被压入栈顶
    // add() 返回后，其栈帧已被销毁，z 接收返回值
    std::cout << z << std::endl; // 输出 30
    return 0;                  // main() 返回后，其栈帧也被销毁
}

// ============ 栈内存布局（调用 add() 时的快照） ============
//
//        低地址 (栈顶方向)
//        ┌─────────────────────────┐
//        │   result = 30           │  ← add() 的局部变量
//        │   b = 20                │  ← add() 的参数
//        │   a = 10                │  ← add() 的参数
//        │   返回地址 (Return Addr) │  ← 返回到 main() 的哪一行
//        │   旧 EBP (帧指针)       │  ← 用于恢复 main() 的栈帧基址
//        ├─────────────────────────┤  ← ─── 栈帧边界 ───
//        │   z = ?  (尚未赋值)     │  ← main() 的局部变量
//        │   y = 20                │  ← main() 的局部变量
//        │   x = 10                │  ← main() 的局部变量
//        │   旧 EBP                │
//        │   ...                   │
//        └─────────────────────────┘
//        高地址 (栈底方向)

// 🚨 危险示例：无限递归导致栈溢出
void infiniteRecursion() {
    int bigArray[1024];           // 每次调用分配 4KB 局部数组
    infiniteRecursion();          // 不断压入新栈帧，直到栈空间耗尽
    // 最终触发 Stack Overflow → 程序崩溃 (Segmentation Fault)
}
 
// 🚨 危险示例：局部变量过大
void hugeLocalVariable() {
    int matrix[1000][1000];       // 约 4MB！可能直接撑爆默认栈空间
    // 如果需要这么大的数组，应该使用 堆（Heap） 分配
}

#include <iostream>
 
int main() {
    // ===== 堆上分配单个对象 =====
    int* p = new int(42);         // 在堆上分配 4 字节，存入值 42
                                   // p 本身（指针变量）存在栈上，占 8 字节（64位系统）
                                   // p 指向的数据存在堆上
 
    std::cout << *p << std::endl;  // 通过指针访问堆上的值：42
    std::cout << &p << std::endl;  // 打印 p 本身的地址（栈地址）
    std::cout << p << std::endl;   // 打印 p 指向的地址（堆地址）
 
    delete p;                      // 释放堆内存，归还给操作系统/内存分配器
    p = nullptr;                   // 良好习惯：释放后置空指针，防止悬垂指针
 
    // ===== 堆上分配对象 =====
    struct Point {                 // 定义一个简单的结构体
        double x, y;               // 两个 double 成员
    };
 
    Point* pt = new Point{3.14, 2.72};  // 堆上分配 Point，使用列表初始化
    std::cout << pt->x << std::endl;     // 通过箭头运算符访问成员
    delete pt;                           // 必须手动释放！忘记就会内存泄漏
    pt = nullptr;                        // 置空
 
    return 0;
}

// ============ 栈与堆的关系 ============
//
//   栈 (Stack)                堆 (Heap)
//   ┌──────────┐             ┌──────────┐
//   │  p ───────┼──────────→ │  42      │  (4 bytes)
//   │  (8 bytes)│             └──────────┘
//   └──────────┘              地址: 0x55A3...
//   地址: 0x7FFE...
//
//   p 是栈上的"遥控器"，堆上的 42 是被遥控的"电视机"
//   delete p → 销毁电视机
//   p = nullptr → 遥控器清零，不再指向已销毁的电视机

// ============ 堆碎片可视化 ============
//
//   分配后:  [A:16B][B:32B][C:16B][D:64B][E:16B]
//
//   释放 B 和 D 后:
//            [A:16B][空:32B][C:16B][空:64B][E:16B]
//                    ^^^^^^         ^^^^^^
//              两个空闲块总共 96B，但不连续！
//              此时请求分配 80B → 失败（最大连续空闲仅 64B）

#include <iostream>
 
// ===== 全局变量（.data 段 或 .bss 段）=====
int globalInit = 100;            // 已初始化 → 存入 .data 段
int globalUninit;                // 未初始化 → 存入 .bss 段（自动初始化为 0）
 
// ===== const 全局变量 =====
const int MAX_SIZE = 1024;       // 可能放在 .rodata（只读数据段）
 
void counter() {
    // ===== 静态局部变量 =====
    static int count = 0;        // 第一次调用时初始化，之后不再重新初始化
                                  // 存储在全局/静态区（.data 段），而非栈上
    count++;                      // 每次调用递增
    std::cout << "第 " << count << " 次调用" << std::endl;
}
 
class MyClass {
public:
    static int instanceCount;    // 静态成员变量声明（需在类外定义）
    MyClass() { instanceCount++; }  // 每次构造对象，计数加 1
    ~MyClass() { instanceCount--; } // 每次析构对象，计数减 1
};
 
int MyClass::instanceCount = 0;  // 静态成员变量定义 + 初始化 → .data 段
 
int main() {
    std::cout << globalInit << std::endl;   // 输出 100
    std::cout << globalUninit << std::endl;  // 输出 0（.bss 段保证清零）
 
    counter();  // 输出：第 1 次调用
    counter();  // 输出：第 2 次调用
    counter();  // 输出：第 3 次调用
    // 注意：static int count 没有被重新初始化为 0！
 
    {
        MyClass a, b, c;                            // 创建 3 个对象
        std::cout << MyClass::instanceCount << std::endl;  // 输出 3
    }  // a, b, c 离开作用域被析构
    std::cout << MyClass::instanceCount << std::endl;      // 输出 0
 
    return 0;
}

// Meyers' Singleton —— 利用 static 局部变量的线程安全初始化
class Singleton {
public:
    static Singleton& getInstance() {      // 返回单例的引用
        static Singleton instance;         // C++11 保证线程安全的初始化
                                            // 只在第一次调用时构造
        return instance;                   // 后续调用直接返回同一个对象
    }
 
    void doSomething() { /* ... */ }
 
private:
    Singleton() = default;                 // 构造函数私有化，禁止外部创建
    Singleton(const Singleton&) = delete;  // 禁止拷贝
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值
};

#include <iostream>
 
void greet() {                              // greet() 的机器码存在代码区
    std::cout << "Hello!" << std::endl;
}
 
int main() {
    // 函数指针指向代码区中 greet() 的起始地址
    void (*funcPtr)() = &greet;             // funcPtr 存储在栈上
                                             // funcPtr 的值是代码区的某个地址
    std::cout << "代码地址: " << (void*)funcPtr << std::endl;
    // 典型输出: 0x401136（低地址，属于代码区范围）
 
    funcPtr();                               // 通过函数指针调用 greet()
 
    return 0;
}

#include <iostream>
 
int main() {
    // 字符串字面量 "Hello" 存储在 .rodata 段
    const char* str = "Hello";      // str 是栈上的指针，指向 .rodata 段
    // str[0] = 'h';               // ❌ 未定义行为！试图修改只读数据
 
    // 两个相同的字符串字面量可能共享同一块内存（编译器优化：字符串池）
    const char* str2 = "Hello";     // str2 可能 == str（指向同一地址）
    std::cout << std::boolalpha << (str == str2) << std::endl;
    // 大多数编译器输出: true（字符串池优化生效）
 
    return 0;
}

#include <iostream>
#include <string>
 
// ==================== 内存区域标注示例 ====================
 
int g_data = 42;                   // 【全局/静态区 .data】已初始化全局变量
int g_bss;                         // 【全局/静态区 .bss】 未初始化全局变量 → 自动为 0
const char* g_str = "Global";      // g_str 在【.data】, "Global" 在【.rodata】
static int g_static = 7;           // 【全局/静态区 .data】静态全局变量
 
void demo() {                      // demo() 函数体在【代码区】
    int localVar = 10;             // 【栈区】局部变量
    static int callCount = 0;      // 【全局/静态区 .data】静态局部变量
    callCount++;
 
    int* heapPtr = new int(99);    // heapPtr 在【栈区】, *heapPtr 在【堆区】
    std::cout << *heapPtr << std::endl;
    delete heapPtr;                // 释放堆内存
}
 
int main() {                       // main() 函数体在【代码区】
    int a = 1;                     // 【栈区】
    double b = 3.14;               // 【栈区】
    const char* msg = "Hi";        // msg 在【栈区】, "Hi" 在【.rodata】
 
    demo();                        // 调用 demo()，压入新栈帧
    demo();                        // 再次调用，callCount 保持递增
 
    int* arr = new int[100];       // arr 在【栈区】, 100个int 在【堆区】
    delete[] arr;                  // 释放堆上的数组
 
    return 0;
}

int x = 10;                   // 全局作用域
void foo() {
    static int y = 20;
    int z = 30;
    int* p = new int(40);
    delete p;
}

#include <cstdlib>   // malloc, free
#include <cstring>   // memset
#include <iostream>
 
int main() {
    // 1. 申请：需要手动计算字节数，返回 void*，必须强制类型转换
    int* p = (int*)malloc(sizeof(int));  // 申请 4 字节（假设 int = 4B）
 
    if (p == NULL) {                      // 2. 必须手动检查是否申请成功
        std::cerr << "malloc failed!" << std::endl;
        return 1;
    }
 
    *p = 42;                              // 3. 手动赋值（malloc 不会初始化，内存是"脏"的）
    std::cout << *p << std::endl;         // 输出 42
 
    free(p);                              // 4. 释放内存
    p = nullptr;                          // 5. 良好习惯：释放后置空，防止悬空指针（dangling pointer）
 
    return 0;
}

#include <iostream>
 
int main() {
    // 1. new：分配内存 + 调用构造函数（一步到位）
    int* p = new int(42);        // 分配 sizeof(int) 字节，并初始化为 42
 
    std::cout << *p << std::endl; // 输出 42
 
    // 2. delete：调用析构函数 + 释放内存（一步到位）
    delete p;                     // 先析构（int 是 POD 类型，析构是空操作），再释放内存
    p = nullptr;                  // 良好习惯：置空
 
    return 0;
}

#include <iostream>
#include <string>
 
class Student {
public:
    std::string name;  // 成员：std::string 自身会在堆上管理字符数据
    int age;
 
    // 构造函数
    Student(const std::string& n, int a) : name(n), age(a) {
        std::cout << "Constructor: " << name << std::endl;  // 标记构造
    }
 
    // 析构函数
    ~Student() {
        std::cout << "Destructor: " << name << std::endl;   // 标记析构
    }
};
 
int main() {
    // new 做了两件事：① 分配 sizeof(Student) 字节 ② 调用 Student("Alice", 20)
    Student* s = new Student("Alice", 20);
 
    std::cout << s->name << " is " << s->age << std::endl;
 
    // delete 做了两件事：① 调用 ~Student()  ② 释放内存
    delete s;      // 输出 "Destructor: Alice"
    s = nullptr;
 
    return 0;
}

// 伪代码：编译器对 new 的展开
void* raw = operator new(sizeof(Student));  // 第一步：分配裸内存（底层通常调用 malloc）
Student* s = static_cast<Student*>(raw);    // 类型转换
s->Student("Alice", 20);                   // 第二步：在这块内存上调用构造函数（placement 语义）

// 伪代码：编译器对 delete 的展开
s->~Student();                // 第一步：调用析构函数，清理对象内部资源
operator delete(s);           // 第二步：释放裸内存（底层通常调用 free）

int* p = (int*)malloc(sizeof(int) * 1000000000L);  // 申请巨量内存
if (p == NULL) {                                     // 必须判空！
    std::cerr << "Allocation failed!" << std::endl;
    // 处理错误...
}

#include <iostream>
#include <new>       // std::bad_alloc
 
int main() {
    try {
        // 故意申请超大内存，触发失败
        int* p = new int[100000000000L];  // 可能抛出 std::bad_alloc
    }
    catch (const std::bad_alloc& e) {     // 捕获异常
        std::cerr << "new failed: " << e.what() << std::endl;
    }
 
    return 0;
}

#include <new>  // std::nothrow
 
int* p = new(std::nothrow) int[100000000000L];  // 失败时不抛异常
if (p == nullptr) {                              // 而是返回 nullptr，类似 malloc
    std::cerr << "Allocation failed (nothrow)" << std::endl;
}

// ❌ 错误示范：混用是未定义行为（Undefined Behavior）！
int* p1 = new int(10);
free(p1);             // 💥 UB! new 出来的必须用 delete
 
int* p2 = (int*)malloc(sizeof(int));
delete p2;            // 💥 UB! malloc 出来的必须用 free

// 内存布局示意（概念模型，实际因编译器而异）
 
// malloc 返回的指针直接指向可用区域：
// ┌──────────────────────┐
// │    用户可用内存区域     │ ← malloc 返回的 void*
// └──────────────────────┘
 
// new 可能在前面存储元数据（尤其是 new[]）：
// ┌──────────┬──────────────────────┐
// │ 元数据    │    用户可用内存区域     │ ← new 返回的 T*
// │ (如数组   │                       │
// │  长度等)  │                       │
// └──────────┴──────────────────────┘
//             ↑
//        operator new 实际分配的起始地址可能在更前面

#include <iostream>
#include <cstdlib>   // malloc, free
 
// 全局重载 operator new
void* operator new(std::size_t size) {
    std::cout << "[Global] Allocating " << size << " bytes" << std::endl;
    void* ptr = std::malloc(size);   // 底层仍然可以用 malloc
    if (!ptr) {
        throw std::bad_alloc();      // 分配失败时必须抛异常（遵循标准约定）
    }
    return ptr;                      // 返回裸内存指针
}
 
// 全局重载 operator delete
void operator delete(void* ptr) noexcept {
    std::cout << "[Global] Freeing memory" << std::endl;
    std::free(ptr);                  // 底层用 free 归还
}
 
int main() {
    int* p = new int(100);           // 触发自定义的 operator new
    std::cout << *p << std::endl;
    delete p;                        // 触发自定义的 operator delete
    return 0;
}

#include <iostream>
#include <cstdlib>
 
class Pool {
public:
    // 类内重载 operator new —— 仅对 Pool 类生效
    static void* operator new(std::size_t size) {
        std::cout << "[Pool] Custom alloc: " << size << " bytes" << std::endl;
        return std::malloc(size);    // 可替换为内存池分配
    }
 
    // 类内重载 operator delete
    static void operator delete(void* ptr) noexcept {
        std::cout << "[Pool] Custom free" << std::endl;
        std::free(ptr);              // 可替换为内存池回收
    }
 
    int data;
 
    Pool(int d) : data(d) {
        std::cout << "[Pool] Constructor" << std::endl;
    }
 
    ~Pool() {
        std::cout << "[Pool] Destructor" << std::endl;
    }
};
 
int main() {
    Pool* obj = new Pool(7);   // 调用 Pool::operator new → Pool::Pool(7)
    std::cout << obj->data << std::endl;
    delete obj;                // 调用 Pool::~Pool() → Pool::operator delete
 
    int* x = new int(5);      // 不受影响，走全局 operator new
    delete x;
 
    return 0;
}

#include <iostream>
#include <new>       // placement new 需要此头文件
 
class Widget {
public:
    int id;
    Widget(int i) : id(i) {
        std::cout << "Widget(" << id << ") constructed" << std::endl;
    }
    ~Widget() {
        std::cout << "Widget(" << id << ") destroyed" << std::endl;
    }
};
 
int main() {
    // 第一步：预先分配一块足够大的裸内存（这里用栈上的 buffer 演示）
    alignas(Widget) unsigned char buffer[sizeof(Widget)];  // 对齐 + 大小足够
 
    // 第二步：placement new —— 在 buffer 的地址上构造 Widget 对象
    Widget* w = new(buffer) Widget(42);  // 不分配内存！只调用构造函数
 
    std::cout << "Widget id = " << w->id << std::endl;
 
    // 第三步：必须手动调用析构函数（因为不能用 delete，内存不是 new 分配的）
    w->~Widget();  // 显式析构 —— 这是 C++ 中极少数需要手动调析构的场景
 
    // buffer 是栈上的，函数结束自动回收，无需 free/delete
    return 0;
}

// 陷阱 1：delete 后使用（Use After Free / Dangling Pointer）
int* p = new int(10);
delete p;
std::cout << *p;      // 💥 未定义行为！p 已经是悬空指针
 
// 陷阱 2：重复 delete（Double Free）
int* q = new int(20);
delete q;
delete q;              // 💥 未定义行为！同一块内存被释放两次
 
// 陷阱 3：delete 空指针 —— 这其实是安全的！
int* r = nullptr;
delete r;              // ✅ C++ 标准保证：delete nullptr 是空操作（no-op）
 
// 陷阱 4：用 delete 释放栈内存
int x = 5;
int* s = &x;
delete s;              // 💥 未定义行为！x 在栈上，不是 new 出来的
 
// 陷阱 5：new[] 配 delete（缺少 []）
int* arr = new int[10];
delete arr;            // 💥 未定义行为！应该用 delete[] arr;

#include <iostream>
 
class Foo {
public:
    Foo()  { std::cout << "C "; }
    ~Foo() { std::cout << "D "; }
};
 
int main() {
    Foo* p = (Foo*)malloc(sizeof(Foo));
    free(p);
    return 0;
}

// 动态分配一个包含 n 个 int 的数组，返回首元素指针
int* arr = new int[5];          // 5 个 int，值未初始化（内容不确定）
 
// 值初始化：所有元素被零初始化
int* arr2 = new int[5]();       // 5 个 int，全部为 0
 
// C++11 起支持列表初始化
int* arr3 = new int[5]{1, 2, 3, 4, 5};  // 逐个赋初值
 
// 动态分配自定义类型数组
std::string* strs = new std::string[3];  // 3 个 string，各自调用默认构造函数

int* arr = new int[100];       // 分配 100 个 int
// ... 使用 arr ...
delete[] arr;                  // 释放整个数组，注意方括号不可省略
arr = nullptr;                 // 良好习惯：释放后置空

class Widget {
public:
    Widget()  { std::cout << "构造 Widget" << std::endl; }  // 构造函数
    ~Widget() { std::cout << "析构 Widget" << std::endl; }  // 析构函数
};
 
int main() {
    Widget* w = new Widget[4];  // 分配 4 个 Widget，调用 4 次构造
    delete w;                   // ❌ 严重错误！应该用 delete[]
    return 0;
}

int main() {
    Widget* w = new Widget;     // 只分配 1 个 Widget
    delete[] w;                 // ❌ 未定义行为！
    return 0;
}

int main() {
    int* p = new int[100];  // 分配 100 个 int
    delete p;               // ❌ 仍是未定义行为！
    return 0;
}

#include <iostream>
 
class Tracer {
    int id_;                                          // 对象编号
public:
    Tracer(int id) : id_(id) {                        // 带参构造函数
        std::cout << "  构造 Tracer #" << id_ << std::endl;
    }
    ~Tracer() {                                       // 析构函数
        std::cout << "  析构 Tracer #" << id_ << std::endl;
    }
};
 
int main() {
    std::cout << "=== 分配阶段 ===" << std::endl;
    // C++11 列表初始化，按下标 0,1,2,3 依次构造
    Tracer* arr = new Tracer[4]{0, 1, 2, 3};
 
    std::cout << "=== 释放阶段 ===" << std::endl;
    // delete[] 按下标 3,2,1,0 逆序析构
    delete[] arr;
 
    return 0;
}

#include <iostream>
#include <stdexcept>
 
class Bomb {
    int id_;
public:
    Bomb(int id) : id_(id) {                                // 构造函数
        std::cout << "  构造 Bomb #" << id_ << std::endl;
        if (id_ == 2) {                                     // 第 3 个对象故意抛异常
            throw std::runtime_error("Bomb #2 爆炸了!");
        }
    }
    ~Bomb() {                                               // 析构函数
        std::cout << "  析构 Bomb #" << id_ << std::endl;
    }
};
 
int main() {
    try {
        // 尝试构造 4 个 Bomb，第 3 个 (id=2) 会抛异常
        Bomb* arr = new Bomb[4]{0, 1, 2, 3};
        delete[] arr;  // 这一行永远不会执行
    } catch (const std::exception& e) {
        // 捕获异常后的处理
        std::cout << "捕获异常: " << e.what() << std::endl;
    }
    return 0;
}

int rows = 3, cols = 4;
 
// 第一步：分配一个"指针数组"，包含 rows 个 int* 指针
int** matrix = new int*[rows];
 
// 第二步：为每一行分别分配 cols 个 int
for (int i = 0; i < rows; ++i) {
    matrix[i] = new int[cols]();   // 每行 cols 个 int，零初始化
}
 
// 使用：matrix[i][j] 访问
matrix[1][2] = 42;
 
// 释放：必须逐行释放，顺序与分配相反
for (int i = 0; i < rows; ++i) {
    delete[] matrix[i];            // 先释放每一行
}
delete[] matrix;                   // 再释放指针数组本身

int rows = 3, cols = 4;
 
// 一次性分配 rows * cols 个连续 int
int* matrix = new int[rows * cols]();  // 全部零初始化
 
// 访问 [i][j] → 手动计算偏移: i * cols + j
matrix[1 * cols + 2] = 42;            // 等价于 matrix[1][2]
 
// 释放：只需一次 delete[]
delete[] matrix;

#include <vector>
#include <memory>
#include <array>
 
// ✅ 方案一：std::vector（最常用）
std::vector<int> v(100, 0);         // 100 个 int，初始为 0
v.push_back(42);                    // 还能动态扩容
// 离开作用域自动释放，无需手动 delete
 
// ✅ 方案二：std::unique_ptr<T[]>（需要裸数组语义时）
std::unique_ptr<int[]> up(new int[100]());  // 持有动态数组
up[0] = 10;                                 // 支持下标访问
// 离开作用域自动调用 delete[]
 
// ✅ C++14 更优写法：
auto up2 = std::make_unique<int[]>(100);    // 无需直接写 new
 
// ✅ 方案三：编译期固定大小
std::array<int, 100> sa{};                  // 栈上分配，零初始化

class Resource {
public:
    Resource()  { std::cout << "ctor "; }
    ~Resource() { std::cout << "dtor "; }
};
 
int main() {
    Resource* p = new Resource[3];
    delete p;  // 注意这里没有 []
    return 0;
}

void leak_demo() {
    int* p = new int(42);   // 在堆上分配 4 字节，p 指向它
    p = nullptr;             // 指针被重置，原来那块内存的地址丢失了！
    // 此时：堆上的 4 字节永远无法被 delete，发生内存泄漏
}

void basic_leak() {
    int* arr = new int[1000];    // 分配 1000 个 int 的堆内存
    // ... 使用 arr 做一些计算 ...
    // 函数结束，arr 是栈上的局部变量，被自动销毁
    // 但 arr 指向的堆内存没有被 delete[]，泄漏了！
}

bool process_data() {
    char* buffer = new char[4096];   // 分配 4KB 缓冲区
 
    if (!read_file(buffer)) {
        return false;                // ⚠️ 提前返回！buffer 没有被 delete[]
    }
 
    if (!validate(buffer)) {
        return false;                // ⚠️ 又一个提前返回！同样泄漏
    }
 
    // 只有走到这里才会释放
    delete[] buffer;                 // 正常路径可以释放
    return true;
}

#include <memory>                             // 引入智能指针头文件
bool process_data_safe() {
    auto buffer = std::make_unique<char[]>(4096);  // RAII 管理内存
 
    if (!read_file(buffer.get())) {
        return false;                         // 安全！buffer 自动析构释放
    }
 
    if (!validate(buffer.get())) {
        return false;                         // 安全！同上
    }
 
    return true;                              // buffer 离开作用域，自动释放
}

void exception_leak() {
    int* data = new int[500];       // 分配堆内存
 
    risky_operation();               // ⚠️ 如果这个函数抛出异常...
 
    delete[] data;                   // 这一行永远不会被执行！
}

void overwrite_leak() {
    int* p = new int(10);     // p 指向第一块内存（值为 10）
    p = new int(20);          // p 指向第二块内存（值为 20）
                              // ⚠️ 第一块内存（值为 10）的地址丢失了！泄漏！
    delete p;                 // 只释放了第二块内存
}

// ===== 第一步：int* p = new int(10) =====
//
//   栈(Stack)          堆(Heap)
//  +--------+        +---------+
//  |  p ----+------->|   10    |   <-- 地址 0xA000
//  +--------+        +---------+
//
// ===== 第二步：p = new int(20)  (未先 delete) =====
//
//   栈(Stack)          堆(Heap)
//  +--------+        +---------+
//  |  p ----+--+     |   10    |   <-- 0xA000（泄漏！无人引用）
//  +--------+  |     +---------+
//              |     +---------+
//              +---->|   20    |   <-- 0xB000（p 现在指向这里）
//                    +---------+

#include <vector>
void container_leak() {
    std::vector<int*> vec;              // 存放 int* 的 vector
 
    for (int i = 0; i < 100; ++i) {
        vec.push_back(new int(i));      // 每次循环都 new 一个 int
    }
 
    // vec 离开作用域，vector 析构
    // vector 会销毁内部存的 100 个「指针值」
    // 但不会对每个指针调用 delete
    // ⚠️ 100 块堆内存全部泄漏！
}

#include <vector>
#include <memory>
void container_safe() {
    std::vector<std::unique_ptr<int>> vec;    // 存放 unique_ptr<int>
 
    for (int i = 0; i < 100; ++i) {
        vec.push_back(std::make_unique<int>(i)); // 用 make_unique 创建
    }
 
    // vec 析构时，会依次析构每个 unique_ptr
    // 每个 unique_ptr 的析构函数会自动 delete 管理的内存
    // ✅ 零泄漏
}

#include <memory>
#include <iostream>
 
struct Node {
    std::shared_ptr<Node> peer;           // 指向对方的 shared_ptr
    ~Node() { std::cout << "~Node\n"; }   // 析构时打印，用于验证
};
 
void circular_leak() {
    auto a = std::make_shared<Node>();    // a 的引用计数 = 1
    auto b = std::make_shared<Node>();    // b 的引用计数 = 1
 
    a->peer = b;                          // b 的引用计数 = 2
    b->peer = a;                          // a 的引用计数 = 2
 
    // 函数结束，局部变量 a、b 被销毁
    // a 引用计数 2 -> 1 (不为 0，不析构)
    // b 引用计数 2 -> 1 (不为 0，不析构)
    // ⚠️ 两个 Node 对象都不会被析构！析构信息不会打印！
}

struct NodeFixed {
    std::shared_ptr<NodeFixed> strong_peer;   // 一方用 shared_ptr（强引用）
    std::weak_ptr<NodeFixed>   weak_peer;     // 另一方用 weak_ptr（弱引用）
    ~NodeFixed() { std::cout << "~NodeFixed\n"; }
};
 
void no_circular_leak() {
    auto a = std::make_shared<NodeFixed>();    // a ref_count = 1
    auto b = std::make_shared<NodeFixed>();    // b ref_count = 1
 
    a->strong_peer = b;                       // b ref_count = 2
    b->weak_peer   = a;                       // a ref_count 仍为 1（weak_ptr 不加计数）
 
    // 函数结束：
    // a ref_count 1 -> 0 => Node A 析构 => 释放 strong_peer => b ref_count 2->1
    // b ref_count 1 -> 0 => Node B 析构
    // ✅ 两个对象都正常析构！
}

#include <iostream>
 
int g_alloc_count = 0;    // 全局分配计数器
 
// 重载全局 operator new
void* operator new(std::size_t size) {
    ++g_alloc_count;       // 每次 new，计数器 +1
    std::cout << "[new]  alloc " << size << " bytes, count=" 
              << g_alloc_count << "\n";
    void* ptr = std::malloc(size);   // 底层仍调用 malloc 分配
    if (!ptr) throw std::bad_alloc();// 分配失败抛异常
    return ptr;
}
 
// 重载全局 operator delete
void operator delete(void* ptr) noexcept {
    --g_alloc_count;       // 每次 delete，计数器 -1
    std::cout << "[del]  free, count=" << g_alloc_count << "\n";
    std::free(ptr);        // 底层调用 free 释放
}
 
// 程序结束时检查
struct LeakChecker {
    ~LeakChecker() {       // 利用全局对象析构，在 main 结束后执行
        if (g_alloc_count != 0) {
            std::cerr << "⚠️ LEAK DETECTED! Unfreed allocations: " 
                      << g_alloc_count << "\n";
        } else {
            std::cout << "✅ No memory leak.\n";
        }
    }
};
 
static LeakChecker checker; // 全局静态对象，析构在 main() 之后
 
int main() {
    int* a = new int(1);   // count: 0 -> 1
    int* b = new int(2);   // count: 1 -> 2
    delete a;               // count: 2 -> 1
    // 故意不 delete b      // count 最终为 1 => 检测到泄漏！
    return 0;
}

# 编译时加 -g 选项以保留调试符号（否则 Valgrind 无法显示源码行号）
g++ -g -o my_program my_program.cpp
 
# 使用 Valgrind 的 Memcheck 工具运行程序
valgrind --leak-check=full ./my_program

# 编译时添加 -fsanitize=address 和 -g 选项
g++ -fsanitize=address -g -o my_program my_program.cpp
 
# 直接运行（不需要额外工具包裹）
./my_program

# LSan 通常内嵌在 ASan 中，通过环境变量开启泄漏检测
ASAN_OPTIONS=detect_leaks=1 ./my_program

#define _CRTDBG_MAP_ALLOC          // 让 new/malloc 记录文件名和行号
#include <cstdlib>                  // 标准 C 头文件
#include <crtdbg.h>                 // CRT Debug 头文件
 
int main() {
    // 在 main 最开头设置：程序退出时自动输出泄漏报告
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
 
    int* leak = new int(42);        // 故意泄漏
    // 程序退出时，Output 窗口会自动打印泄漏详情
    return 0;
}

#include <vector>
#include <string>
#include <stdexcept>
 
class Image {
public:
    int* pixels;                                  // 裸指针成员
    int  width, height;
 
    Image(int w, int h) : width(w), height(h) {  // 构造函数
        pixels = new int[w * h];                  // 分配像素数组
    }
 
    // ⚠️ 没有定义析构函数！Rule of Three 被违反
    // 编译器默认析构不会 delete[] pixels
};
 
void process_images() {
    // ===== 泄漏点 1：容器存裸指针 =====
    std::vector<Image*> gallery;                  // 存 Image 裸指针
    for (int i = 0; i < 10; ++i) {
        gallery.push_back(new Image(100, 100));   // new 了 10 个 Image
    }
 
    // ===== 泄漏点 2：指针覆盖 =====
    Image* current = new Image(200, 200);         // 分配第 1 张大图
    current = new Image(300, 300);                // 覆盖！第 1 张大图泄漏
 
    // ===== 泄漏点 3：异常中断 =====
    Image* temp = new Image(50, 50);              // 分配临时图像
    if (temp->width < 100) {
        throw std::runtime_error("Image too small"); // 抛出异常！
    }
    delete temp;                                  // 永远不会执行
 
    // ===== 泄漏点 4：缺少析构函数 =====
    // 即使所有 Image* 都被 delete 了，Image 内部的 pixels 也不会被释放
    // 因为 Image 没有写析构函数 ~Image() { delete[] pixels; }
 
    delete current;
    for (auto* img : gallery) delete img;         // 这些代码也因异常到不了
}

#include <memory>
 
struct Node {
    std::shared_ptr<Node> next;
};
 
int main() {
    int* a = new int(1);                          // 语句 ①
    int* b = new int(2);                          // 语句 ②
    delete a;                                      // 语句 ③
 
    int* c = new int(3);                          // 语句 ④
    c = new int(4);                               // 语句 ⑤
 
    auto x = std::make_shared<Node>();            // 语句 ⑥
    auto y = std::make_shared<Node>();            // 语句 ⑦
    x->next = y;                                  // 语句 ⑧
    y->next = x;                                  // 语句 ⑨
 
    delete c;                                      // 语句 ⑩
    return 0;
}

void processFile(const std::string& filename) {
    FILE* fp = fopen(filename.c_str(), "r");  // 获取资源：打开文件
    if (!fp) return;                           // 打开失败，直接返回
 
    int* buffer = new int[1024];               // 获取资源：分配堆内存
 
    // ---- 中间有大量业务逻辑 ----
    if (someErrorCondition()) {
        // 😱 程序员记得关文件，但忘了 delete buffer！
        fclose(fp);
        return;                                // 内存泄漏！
    }
 
    if (anotherError()) {
        // 😱 程序员记得 delete buffer，但忘了关文件！
        delete[] buffer;
        return;                                // 文件句柄泄漏！
    }
 
    // 如果中间某行代码抛出异常（exception）...
    riskyOperation();                          // 💀 异常直接跳出函数
                                               // fclose 和 delete 全都不会执行！
 
    // ---- 正常路径 ----
    delete[] buffer;                           // 释放内存
    fclose(fp);                                // 关闭文件
}

#include <iostream>   // 引入标准输入输出
#include <cstddef>    // 引入 size_t
 
class IntBuffer {
private:
    int* data_;       // 底层裸指针，指向堆内存
    size_t size_;     // 缓冲区大小
 
public:
    // ========== 构造函数：获取资源 ==========
    explicit IntBuffer(size_t size)
        : data_(new int[size]{}),   // 在构造函数中 new 分配内存（RAII 的 "RA" 部分）
          size_(size)               // 记录大小
    {
        std::cout << "资源已获取: 分配了 " << size_ << " 个 int\n";
    }
 
    // ========== 析构函数：释放资源 ==========
    ~IntBuffer() {
        delete[] data_;             // 在析构函数中 delete 释放内存（RAII 的核心保证）
        std::cout << "资源已释放: 归还了 " << size_ << " 个 int 的内存\n";
    }
 
    // ========== 禁止拷贝（防止双重释放） ==========
    IntBuffer(const IntBuffer&) = delete;              // 禁用拷贝构造
    IntBuffer& operator=(const IntBuffer&) = delete;   // 禁用拷贝赋值
 
    // ========== 提供访问接口 ==========
    int& operator[](size_t index) {         // 重载下标运算符，方便使用
        return data_[index];                // 直接返回引用
    }
 
    size_t size() const { return size_; }   // 获取大小
};

void demo() {
    IntBuffer buf(10);     // 构造时自动分配 10 个 int 的堆内存
 
    buf[0] = 42;           // 像普通数组一样使用
    buf[1] = 100;          // 写入数据
 
    std::cout << buf[0] << std::endl;  // 输出 42
 
    if (true) {
        return;            // 提前返回——不用担心！析构函数照样会被调用 ✅
    }
 
    // 无论从哪条路径离开这个函数
    // buf 的析构函数 ~IntBuffer() 都会自动执行
    // delete[] data_ 一定会被调用，内存一定会被释放
}  // <-- buf 离开作用域，~IntBuffer() 在这里自动调用

void riskyWork() {
    IntBuffer a(100);     // ① 构造 a，分配 100 个 int
    IntBuffer b(200);     // ② 构造 b，分配 200 个 int
 
    throw std::runtime_error("出错了！");  // ③ 抛出异常！
 
    // 下面的代码不会执行，但不用担心：
    // 栈展开时，先析构 b（后构造的先析构），再析构 a
    // 内存全部自动释放，零泄漏 ✅
}
 
int main() {
    try {
        riskyWork();
    } catch (const std::exception& e) {
        std::cout << "捕获异常: " << e.what() << std::endl;
        // 此时 a 和 b 的内存早已被安全释放
    }
}

#include <memory>     // 智能指针头文件
#include <iostream>
 
class Monster {
public:
    std::string name;                              // 怪物名称
    Monster(std::string n) : name(std::move(n)) {  // 构造函数
        std::cout << name << " 诞生了!\n";
    }
    ~Monster() {                                   // 析构函数
        std::cout << name << " 被消灭了!\n";
    }
};
 
void battle() {
    // unique_ptr: 独占所有权的智能指针（最常用）
    // make_unique 在内部调用 new，返回一个 unique_ptr
    auto goblin = std::make_unique<Monster>("哥布林");
 
    // shared_ptr: 共享所有权的智能指针（引用计数）
    auto dragon = std::make_shared<Monster>("巨龙");
 
    std::cout << "战斗开始！\n";
 
    // 使用 -> 访问成员，和裸指针用法一致
    std::cout << goblin->name << " vs " << dragon->name << "\n";
 
    // 无需 delete！离开作用域时：
    // dragon 的引用计数降为 0，自动 delete
    // goblin 自动 delete
}  // <-- 析构函数自动调用，内存自动释放

#include <fstream>    // 文件流头文件
#include <string>
 
void readConfig() {
    // ifstream 构造时自动打开文件（资源获取）
    std::ifstream file("config.txt");
 
    if (!file.is_open()) {              // 检查是否打开成功
        std::cerr << "无法打开配置文件\n";
        return;                         // 即使这里 return，file 也会被正确析构
    }
 
    std::string line;
    while (std::getline(file, line)) {  // 逐行读取
        std::cout << line << "\n";      // 输出每一行
    }
 
    // 无需手动 file.close()！
    // ifstream 的析构函数会自动关闭文件句柄
}  // <-- ~ifstream() 自动调用 close()

#include <mutex>      // 互斥锁头文件
#include <iostream>
 
std::mutex mtx;       // 全局互斥锁
int shared_counter = 0;  // 共享计数器
 
void safeIncrement() {
    // lock_guard 构造时自动调用 mtx.lock()（获取锁资源）
    std::lock_guard<std::mutex> guard(mtx);
 
    // 临界区：此时只有一个线程能执行到这里
    ++shared_counter;                          // 安全地修改共享数据
    std::cout << "counter = " << shared_counter << "\n";
 
    if (shared_counter > 100) {
        return;   // 提前返回？没关系！guard 析构会自动 unlock ✅
    }
 
    // 如果这里抛异常？也没关系！栈展开会析构 guard，自动 unlock ✅
 
}  // <-- ~lock_guard() 自动调用 mtx.unlock()，绝不会忘记解锁

#include <functional>  // std::function
#include <iostream>
 
// ========== 通用 RAII 守卫类 ==========
class ScopeGuard {
private:
    std::function<void()> cleanup_;  // 存储清理函数（释放资源的操作）
    bool active_;                    // 标记是否需要执行清理
 
public:
    // 构造函数：接收一个"清理函数"
    explicit ScopeGuard(std::function<void()> cleanup)
        : cleanup_(std::move(cleanup)),  // 移动语义保存清理函数
          active_(true)                  // 默认激活
    {}
 
    // 析构函数：如果仍处于激活状态，执行清理
    ~ScopeGuard() {
        if (active_) {          // 只有激活状态才清理
            cleanup_();         // 调用清理函数（释放资源）
        }
    }
 
    // 手动取消清理（在某些场景下有用）
    void dismiss() {
        active_ = false;        // 标记为非激活，析构时不再清理
    }
 
    // 禁止拷贝
    ScopeGuard(const ScopeGuard&) = delete;
    ScopeGuard& operator=(const ScopeGuard&) = delete;
};

#include <cstdio>     // C 风格文件操作
 
void processWithCApi() {
    // 用 C API 打开文件
    FILE* fp = fopen("data.bin", "rb");          // C 风格打开文件
    if (!fp) return;                              // 打开失败则返回
 
    // 创建 RAII 守卫：无论函数怎么退出，都会执行 fclose
    ScopeGuard fileGuard([fp]() {                 // lambda 捕获 fp
        fclose(fp);                               // 清理操作：关闭文件
        std::cout << "文件已自动关闭\n";
    });
 
    // 分配 C 风格内存
    void* rawMem = malloc(4096);                  // C 风格分配内存
    ScopeGuard memGuard([rawMem]() {              // 再创建一个守卫
        free(rawMem);                             // 清理操作：释放内存
        std::cout << "内存已自动释放\n";
    });
 
    // ---- 大量业务逻辑 ----
    // 可以有任意多的 return、可以抛异常
    // 不需要在每条路径上手动释放资源
 
    if (ferror(fp)) {
        return;   // 提前返回：memGuard 先析构(free)，fileGuard 再析构(fclose) ✅
    }
 
    // 正常结束也一样安全
}  // <-- 离开作用域：两个 ScopeGuard 自动执行清理

// 策略一：禁止拷贝（最简单、最常用）
class NoCopy {
    int* p;
public:
    NoCopy() : p(new int(0)) {}           // 构造：获取资源
    ~NoCopy() { delete p; }               // 析构：释放资源
    NoCopy(const NoCopy&) = delete;       // 禁止拷贝构造
    NoCopy& operator=(const NoCopy&) = delete;  // 禁止拷贝赋值
    // 可以提供移动语义（转移所有权）
    NoCopy(NoCopy&& other) noexcept       // 移动构造
        : p(other.p) {                    // 接管对方的资源
        other.p = nullptr;                // 对方置空，避免双重释放
    }
};

class BadRAII {
public:
    ~BadRAII() {
        // ❌ 绝对不要在析构函数中抛异常！
        // throw std::runtime_error("析构出错");
 
        // ✅ 正确做法：捕获并处理/忽略异常
        try {
            riskyCleanup();        // 如果清理操作可能出错
        } catch (...) {
            // 记录日志，但不要重新抛出
            std::cerr << "清理时发生错误，已忽略\n";
        }
    }
};

class DatabaseConnection {
    Connection* conn_;              // 数据库连接句柄
public:
    DatabaseConnection(const std::string& url) {
        conn_ = db_connect(url.c_str());  // 尝试连接数据库
        if (!conn_) {
            // 获取资源失败，抛出异常
            // 由于构造未完成，~DatabaseConnection() 不会被调用
            throw std::runtime_error("数据库连接失败: " + url);
        }
    }
    ~DatabaseConnection() {
        db_disconnect(conn_);       // 只有构造成功才会执行到这里
    }
};

// ✅ Rule of Zero 的典范——完美的资源管理，零手写特殊函数
class GameWorld {
    std::unique_ptr<Player> player_;             // 独占所有权的玩家对象
    std::vector<std::shared_ptr<Monster>> monsters_;  // 共享所有权的怪物列表
    std::string worldName_;                      // 世界名称
 
    // 不需要写析构函数 —— unique_ptr 自动 delete Player
    // 不需要写拷贝/移动 —— unique_ptr 已禁止拷贝，移动自动生效
    // 一切都是自动的！
public:
    GameWorld(std::string name) : worldName_(std::move(name)) {}
    // ... 业务方法 ...
};

void loadTexture(const std::string& path) {
    int* pixels = new int[1024 * 1024];
    FILE* file = fopen(path.c_str(), "rb");
    if (!file) {
        delete[] pixels;
        return;
    }
    fread(pixels, sizeof(int), 1024 * 1024, file);
    processPixels(pixels);   // 可能抛出异常
    fclose(file);
    delete[] pixels;
}