内存管理常见陷阱与排查

#include <iostream>
#include <memory>
#include <string>
#include <vector>

struct User {
    int id;
    std::string name;

    User(int i, std::string n) : id(i), name(std::move(n)) {}
};

// ❌ 危险代码：返回裸指针
User* createUserBad(int id, const std::string& name) {
    User u(id, name);
    return &u;  // ❌ 返回局部变量的地址！悬空指针
}

// ✅ 安全代码：返回智能指针
std::unique_ptr<User> createUserSafe(int id, const std::string& name) {
    return std::make_unique<User>(id, name);
}

// ❌ 危险代码：裸指针容器
void rawPointerTrap() {
    std::vector<User*> users;
    users.push_back(new User(1, "大翔"));
    users.push_back(new User(2, "白歌"));

    // 若此处抛异常，下方 delete 不会执行 → 泄漏
    for (auto* u : users)
        delete u;  // 手动释放，容易遗忘
}

// ✅ 安全代码：智能指针容器
void smartPointerSafe() {
    std::vector<std::unique_ptr<User>> users;
    users.push_back(std::make_unique<User>(1, "大翔"));
    users.push_back(std::make_unique<User>(2, "白歌"));
    // 自动释放，即使异常也安全
}

int main() {
    std::cout << "=== 飞翔科技内存安全审查 ===\n\n";

    // 1. 悬挂指针检测
    std::cout << "--- 悬挂指针 ---\n";
    auto u = createUserSafe(100, "孔蓝");
    std::cout << "用户: " << u->name << " (ID:" << u->id << ")\n\n";

    // 2. 双重释放陷阱
    std::cout << "--- 双重释放 ---\n";
    {
        auto p = std::make_unique<int>(42);
        // p 离开作用域自动释放，不可能双重释放
        std::cout << "unique_ptr 自动管理，不会双重释放\n";
    }

    // 3. 内存泄漏对比
    std::cout << "\n--- 内存泄漏 ---\n";
    // ❌ 裸指针容易遗忘 delete
    // int* leaked = new int[1000];
    // 如果提前返回或抛异常，这 1000 个 int 泄漏

    // ✅ RAII 保证释放
    auto safe = std::make_unique<int[]>(1000);
    std::cout << "make_unique 保证即使在异常路径也释放\n";

    // 4. 循环引用陷阱
    std::cout << "\n--- 循环引用 ---\n";
    struct Group;
    struct Member {
        std::string name;
        std::shared_ptr<Group> group;   // 可能引起循环引用
        ~Member() { std::cout << "  释放成员 " << name << "\n"; }
    };
    struct Group {
        std::string name;
        std::vector<std::shared_ptr<Member>> members;
        ~Group() { std::cout << "  释放群组 " << name << "\n"; }
    };

    {
        auto group = std::make_shared<Group>();
        group->name = "飞翔技术群";

        auto member = std::make_shared<Member>();
        member->name = "大翔";
        member->group = group;      // member 持有 group
        group->members.push_back(member);  // group 持有 member
        // 离开作用域：group 和 member 互相持有，永不释放！
    }
    std::cout << "  (注意：上面两个对象未被释放——循环引用)\n";

    // 5. 解决方案：weak_ptr 打破循环
    std::cout << "\n--- 修复：weak_ptr ---\n";
    struct FixedMember {
        std::string name;
        std::weak_ptr<Group> group;  // 弱引用不增加计数
        ~FixedMember() { std::cout << "  释放成员 " << name << "\n"; }
    };
    // 其他相同... 使用 weak_ptr 即可打破循环
}

// 编译: g++ -fsanitize=address -g -O1 main.cpp
// 运行时会自动检测内存错误

#include <iostream>
#include <cstring>

void heapBufferOverflow() {
    int* arr = new int[3]{1, 2, 3};
    arr[3] = 42;    // ❌ 越界写入！ASan 会报告
    delete[] arr;
}

void useAfterFree() {
    int* p = new int(42);
    delete p;
    std::cout << *p;  // ❌ heap-use-after-free！ASan 会报告
}

void stackBufferOverflow() {
    int arr[3] = {1, 2, 3};
    arr[3] = 42;  // ❌ 栈缓冲区溢出！ASan 会报告
}

int main() {
    // 取消注释以下调用以触发 ASan 报告
    // heapBufferOverflow();
    // useAfterFree();
    // stackBufferOverflow();

    std::cout << "=== ASan 内存错误检测 ===\n\n";
    std::cout << "编译: g++ -fsanitize=address -g main.cpp\n";
    std::cout << "运行时会自动检测:\n";
    std::cout << "  - heap-buffer-overflow\n";
    std::cout << "  - heap-use-after-free\n";
    std::cout << "  - stack-buffer-overflow\n";
    std::cout << "  - memory leak\n";
    std::cout << "\nASan 报告包含: 错误类型、文件名、行号、内存分配位置\n";
}

void leak() {
    auto* p = new int[100];
    if (condition) return;  // ❌ 提前返回，泄漏！
    delete[] p;
}
// 解决：auto p = std::make_unique<int[]>(100);

class Bad {
    int* p1;
    int* p2;
public:
    Bad() : p1(new int), p2(new int) {
        throw std::runtime_error("oops");  // ❌ p1 泄漏！
    }
};
// 解决：使用智能指针或 try-catch