C++weak_ptr与事件回调结合使用技巧

weak_ptr

shared_ptr

std::weak_ptr

weak_ptr

std::shared_ptr

lock()

shared_ptr

lock()

nullptr

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

// 模拟一个事件发布者
class EventPublisher {
public:
    using Callback = std::function<void()>;
    void registerCallback(Callback cb) {
        callbacks_.push_back(std::move(cb));
    }
    void notify() {
        std::cout << "Publisher: Notifying subscribers..." << std::endl;
        // 实际应用中可能需要清理已失效的回调，这里简化处理
        for (const auto& cb : callbacks_) {
            cb();
        }
    }
private:
    std::vector<Callback> callbacks_;
};

// 模拟一个事件订阅者
class EventSubscriber : public std::enable_shared_from_this<EventSubscriber> {
public:
    EventSubscriber(const std::string& name) : name_(name) {
        std::cout << name_ << ": Created." << std::endl;
    }

    ~EventSubscriber() {
        std::cout << name_ << ": Destroyed." << std::endl;
    }

    void onEvent() {
        std::cout << name_ << ": Event received and processed!" << std::endl;
    }

    // 订阅事件的方法
    void subscribeTo(EventPublisher& publisher) {
        // 捕获一个weak_ptr到自身
        // shared_from_this() 要求类继承 std::enable_shared_from_this
        std::weak_ptr<EventSubscriber> weak_self = shared_from_this();

        publisher.registerCallback([weak_self]() {
            // 在回调内部尝试锁定weak_ptr
            if (std::shared_ptr<EventSubscriber> strong_self = weak_self.lock()) {
                // 对象仍然存活，安全调用其成员方法
                strong_self->onEvent();
            } else {
                // 对象已经销毁，回调安全地什么都不做
                std::cout << "Callback: Subscriber already destroyed, ignoring event." << std::endl;
            }
        });
        std::cout << name_ << ": Subscribed to publisher." << std::endl;
    }

private:
    std::string name_;
};

/*
int main() {
    EventPublisher publisher;

    { // 模拟一个作用域，Subscriber A 在这里创建和销毁
        std::shared_ptr<EventSubscriber> subA = std::make_shared<EventSubscriber>("Subscriber A");
        subA->subscribeTo(publisher);

        std::shared_ptr<EventSubscriber> subB = std::make_shared<EventSubscriber>("Subscriber B");
        subB->subscribeTo(publisher);

        publisher.notify(); // 两个订阅者都收到事件

        std::cout << "\n--- Subscriber A goes out of scope ---\n" << std::endl;
    } // subA 在这里被销毁，其 shared_ptr 引用计数归零

    publisher.notify(); // 此时，subA 的回调会检测到对象已销毁，subB 正常收到事件

    std::cout << "\n--- Program end ---\n" << std::endl;
    return 0;
}
*/

EventSubscriber

weak_ptr::lock()

T*

std::shared_ptr

shared_ptr

std::vector<std::function<void()>>

shared_ptr

shared_ptr

shared_ptr

shared_ptr

shared_ptr

weak_ptr

shared_ptr

weak_ptr::lock()

shared_ptr

lock()

nullptr

weak_ptr

weak_ptr

shared_ptr

lock()

weak_ptr

shared_ptr

std::mutex

std::atomic

weak_ptr

weak_ptr

shared_ptr

shared_ptr

shared_ptr

weak_ptr

weak_ptr

shared_ptr

std::enable_shared_from_this

shared_ptr

weak_ptr

shared_from_this()