C++中智能指针weak_ptr的原理及使用

struct controlblock {
    std::atomic<size_t> shared_count;  // 强引用计数
    std::atomic<size_t> weak_count;    // 弱引用计数
    // 其他元数据（删除器、分配器等）
};

// 创建 shared_ptr（控制块：shared=1, weak=0）
auto sp = std::make_shared<int>(42);

// 创建 weak_ptr（控制块：shared=1, weak=1）
std::weak_ptr<int> wp = sp;

// shared_ptr 析构（控制块：shared=0, weak=1）
sp.reset();

// 此时：
// - 管理的 int 对象已被销毁
// - 控制块仍然存在（weak_count=1）
// - wp.expired() == true

// weak_ptr 析构（控制块：shared=0, weak=0）
// 控制块被释放

// 从 shared_ptr 创建
auto sp = std::make_shared<myclass>();
std::weak_ptr<myclass> wp1(sp);

// 拷贝构造
std::weak_ptr<myclass> wp2(wp1);

// 赋值操作
std::weak_ptr<myclass> wp3;
wp3 = wp1;

// 检查对象是否有效
if (!wp.expired()) {
    // 尝试升级为 shared_ptr
    if (auto sp = wp.lock()) {
        // 使用 sp 安全访问对象
    }
}

// 监控资源释放
std::weak_ptr<myclass> wp;

{
    auto sp = std::make_shared<myclass>();
    wp = sp;
    // 对象存在
}

// 此时 wp.expired() == true

std::shared_ptr<int> sp = std::make_shared<int>(42);
std::weak_ptr<int> wp(sp);

// 线程1
if (auto local_sp = wp.lock()) {
    std::lock_guard<std::mutex> lock(mtx);
    *local_sp = 10;
}

// 线程2
if (auto local_sp = wp.lock()) {
    std::lock_guard<std::mutex> lock(mtx);
    int val = *local_sp;
}

class parent {
    std::shared_ptr<child> child;
};

class child {
    std::weak_ptr<parent> parent;  // 使用 weak_ptr 避免循环
};

class cache {
    std::unordered_map<key, std::weak_ptr<resource>> cache;
    
    std::shared_ptr<resource> get(key key) {
        if (auto it = cache.find(key); it != cache.end()) {
            if (auto sp = it->second.lock()) {
                return sp;  // 缓存命中
            }
            cache.erase(it);  // 清理过期缓存
        }
        // 缓存未命中，创建新资源
        auto sp = std::make_shared<resource>(key);
        cache[key] = sp;
        return sp;
    }
};

class subject {
    std::vector<std::weak_ptr<observer>> observers;
    
    void notify() {
        for (auto it = observers.begin(); it != observers.end(); ) {
            if (auto obs = it->lock()) {
                obs->update();
                ++it;
            } else {
                it = observers.erase(it);  // 移除无效观察者
            }
        }
    }
};

shared_ptr<t> lock() const noexcept {
    controlblock* cb = get_control_block();
    size_t sc = cb->shared_count.load();
    do {
        if (sc == 0) return nullptr;  // 对象已释放
        // 尝试增加 shared_count（cas操作）
    } while (!cb->shared_count.compare_exchange_weak(sc, sc + 1));
    
    return shared_ptr<t>(cb);  // 创建新的 shared_ptr
}

// 错误用法
// *wp;  // 编译错误

// 正确用法
if (auto sp = wp.lock()) {
    *sp = value;
}

// 不能直接从裸指针构造
// std::weak_ptr<int> wp(new int(42));  // 错误

// 必须从 shared_ptr 构造
auto sp = std::make_shared<int>(42);
std::weak_ptr<int> wp(sp);  // 正确

void process(std::weak_ptr<data> wp) {
    auto sp = wp.lock();  // 只调用一次 lock
    if (!sp) return;
    
    // 多次使用 sp 而不重复调用 lock
    sp->operation1();
    sp->operation2();
}

class myclass : public std::enable_shared_from_this<myclass> {
public:
    std::weak_ptr<myclass> get_weak() {
        return weak_from_this();  // 安全获取 weak_ptr
    }
};

auto obj = std::make_shared<myclass>();
auto wobj = obj->get_weak();  // 安全获取 weak_ptr

std::atomic<std::weak_ptr<int>> atomic_wp;
atomic_wp.store(wp, std::memory_order_release);
auto current = atomic_wp.load(std::memory_order_acquire);