C++ 智能指针：把 delete 交给对象的生命周期

void loadLevel() {
    Texture* wall = new Texture("wall.png");
    Texture* sky  = new Texture("sky.png");
    if (!sky->loaded()) {
        delete wall;                                    // 提前退出，记得补一个
        throw std::runtime_error("sky.png 加载失败");
    }
    buildScene(wall, sky);   // 若这里抛异常……
    delete wall;             // ……下面两行永远执行不到
    delete sky;
}

#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>

struct Texture {
    explicit Texture(std::string name) : name_(std::move(name)) {
        std::cout << "载入 " << name_ << '\n';
    }
    ~Texture() { std::cout << "释放 " << name_ << '\n'; }
    std::string name_;
};

void buildScene() { throw std::runtime_error("场景数据损坏"); }

void withSmartPointer() {
    auto wall = std::make_unique<Texture>("wall.png");
    buildScene();                        // 抛异常，函数从这里退出
    std::cout << "这行永远执行不到\n";
}

int main() {
    try {
        withSmartPointer();
    } catch (const std::exception& e) {
        std::cout << "捕获异常: " << e.what() << '\n';
    }
}

载入 wall.png
释放 wall.png
捕获异常: 场景数据损坏

auto wall  = std::make_unique<Texture>("wall.png");
auto twin  = wall;                        // 想复制一个"主人"
auto moved = std::move(wall);             // 正确转手：moved 接管，wall 变空
std::cout << (wall == nullptr) << '\n';

error: use of deleted function 'std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = Texture; _Dp = std::default_delete<Texture>]'

1

// 缝隙示意：new Texture 已执行、unique_ptr 还没接住时，
// 若 loadPalette() 抛异常，刚 new 的对象没人管——泄漏
render(std::unique_ptr<Texture>(new Texture("a.png")), loadPalette());

// make_unique 把「分配」与「接管」焊成一步，中间没有缝
render(std::make_unique<Texture>("a.png"), loadPalette());

#include <iostream>
#include <memory>

int main() {
    auto shared = std::make_shared<int>(42);
    std::cout << "创建后:    " << shared.use_count() << '\n';
    {
        auto copy1 = shared;                 // 拷贝：计数 +1
        auto copy2 = shared;
        std::cout << "拷贝两份后: " << shared.use_count() << '\n';
    }                                        // copy1、copy2 离开作用域：各 -1
    std::cout << "内层退出:  " << shared.use_count() << '\n';
    shared.reset();                          // 主动放弃所有权：-1
    std::cout << "reset 后:   " << shared.use_count() << '\n';
}

创建后:    1
拷贝两份后: 3
内层退出:  1
reset 后:   0

#include <iostream>
#include <memory>

struct Player;

struct Guild {
    std::shared_ptr<Player> leader;          // 公会持有队长
    ~Guild() { std::cout << "公会解散\n"; }
};

struct Player {
    std::shared_ptr<Guild> guild;            // 队长也持有公会——互相保活
    ~Player() { std::cout << "玩家下线\n"; }
};

int main() {
    auto guild  = std::make_shared<Guild>();
    auto player = std::make_shared<Player>();
    guild->leader = player;
    player->guild = guild;
    std::cout << "main 结束\n";
}

main 结束

==23305==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 64 byte(s) in 2 object(s) allocated from:
    #0 0x7f... in operator new(unsigned long)
    #1 0x7f... in main
SUMMARY: AddressSanitizer: 128 byte(s) leaked in 2 allocation(s).

#include <iostream>
#include <memory>

struct Player;

struct Guild {
    std::shared_ptr<Player> leader;          // 拥有方向：公会拥有队长
    ~Guild() { std::cout << "公会解散\n"; }
};

struct Player {
    std::weak_ptr<Guild> guild;              // 反向：玩家只观察公会
    ~Player() { std::cout << "玩家下线\n"; }
};

int main() {
    auto guild  = std::make_shared<Guild>();
    auto player = std::make_shared<Player>();
    guild->leader = player;
    player->guild = guild;
    std::cout << "guild 被强引用: " << player->guild.use_count() << '\n';
    std::cout << "main 结束\n";
}

guild 被强引用: 1
main 结束
公会解散
玩家下线

int* raw = new int(42);
std::shared_ptr<int> a(raw);
std::shared_ptr<int> b(raw);   // 第二个控制块！

==21013==ERROR: AddressSanitizer: attempting double-free on 0x602000000010 in thread T0
SUMMARY: AddressSanitizer: double-free

auto p = std::make_unique<int>(7);
auto q = std::move(p);
std::cout << *p << '\n';       // p 已变空

==21944==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000
SUMMARY: AddressSanitizer: SEGV

auto a = std::make_shared<int>(1);
auto b = a;
std::weak_ptr<int> w = a;
std::cout << a.use_count() << '\n';
b.reset();
std::cout << a.use_count() << '\n';
std::cout << w.expired() << '\n';

std::shared_ptr<int> getValue() {
    int value = 42;
    return std::shared_ptr<int>(&value);   // 问题在这里
}

==22551==ERROR: AddressSanitizer: attempting free on address which was not malloc()-ed: 0x7ffd... in thread T0
SUMMARY: AddressSanitizer: bad-free

预测题: 2 / 1 / 0 —— b.reset 后对象还活着，weak 未过期
修 Bug 题: 0x7ffd 开头是栈地址（120 篇讲过），bad-free 说明析构时对栈地址执行了
delete；shared_ptr 只能管 new 出来的对象。修法：return std::make_shared<int>(42);