用C++观察者模式实现LiveData类

#ifndef LIVE_DATA_H
#define LIVE_DATA_H

#include <mutex>
#include <vector>
#include <functional>

template <typename T>
class LiveData
{

public:
    LiveData(const T& initialValue) : m_Data(initialValue) {}

    // 注册观察者
    void observe(const std::function<void(const T&)>& observer) {
        std::lock_guard<std::mutex> lock(m_Mutex);
        m_Observers.push_back(observer);
    }

    // 取消观察
    void unobserve(const std::function<void(const T&)>& observer) {
        std::lock_guard<std::mutex> lock(m_Mutex);
        auto it = std::find(m_Observers.begin(), m_Observers.end(), observer);
        if (it != m_Observers.end()) {
            m_Observers.erase(it);
        }
    }

    // 更新数据
    void setValue(const T& newValue) {
        T localData;
        {
            std::lock_guard<std::mutex> lock(m_Mutex);
            m_Data = newValue;
            localData = newValue;
        }
        notifyObservers(localData);
    }

private:
    // 通知所有观察者
    void notifyObservers(T localData) {
        std::vector<std::function<void(const T&)>> localObservers;
        {
            std::lock_guard<std::mutex> lock(m_Mutex);
            localObservers = m_Observers;  // 复制观察者列表，减少锁的持有时间
        }
        for (const auto& observer : localObservers) {
            try {
                observer(localData);
            }
            catch (...) {
                //std::cerr << "Exception occurred while notifying observer." << std::endl;
            }
        }
    }

private:
    T m_Data{};
    std::vector<std::function<void(const T&)>> m_Observers{};
    mutable std::mutex m_Mutex{};

};

#endif // !LIVE_DATA_H

 

 

使用方法：

#include "LiveData.h"

#include <iostream>

// 全局函数作为观察者
void globalObserver(const int& value) {
    std::cout << "Global observer received new value: " << value << std::endl;
}

class ObserverClass {
public:
    // 类的静态函数作为观察者
    static void staticObserver(const int& value) {
        std::cout << "Static observer received new value: " << value << std::endl;
    }

    // 对象的普通函数作为观察者
    void memberObserver(const int& value) {
        std::cout << "Member observer received new value: " << value << std::endl;
    }
};

int main() {
    LiveData<int> observable(10);

    // 注册全局函数观察者
    observable.observe(globalObserver);

    // 注册类的静态函数观察者
    observable.observe(ObserverClass::staticObserver);

    // 创建类的对象
    ObserverClass observerObj;
    // 注册对象的普通函数观察者，需要使用 std::bind 绑定对象实例
    observable.observe(std::bind(&ObserverClass::memberObserver, &observerObj, std::placeholders::_1));

    // 定义 lambda 函数作为观察者
    auto lambdaObserver = [](const int& value) {
        std::cout << "Lambda observer received new value: " << value << std::endl;
    };
    observable.observe(lambdaObserver);

    // 更新数据
    observable.setValue(20);

    return 0;
}