使用单例模式+观察者模式实现参数配置实时更新

使用vector存储观察者列表

#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>

// 配置参数结构体
struct MyConfigStruct {
    int parameter1;
    std::string parameter2;
};

class Config {
public:
    using Observer = std::function<void(const MyConfigStruct&)>;

    static Config& getInstance() {
        static Config instance;
        return instance;
    }

    // 注册观察者
    void registerObserver(Observer observer) {
        observers_.push_back(observer);
    }

    // 移除观察者
    void removeObserver(Observer observer) {
        observers_.erase(std::remove_if(observers_.begin(), observers_.end(),
            [observer](const Observer& o) {
                return o.target_type() == observer.target_type();
            }), observers_.end());
    }
    /*
    void removeObserver(Observer observer) {
 auto it = std::find_if(observers_.begin(), observers_.end(),
            [observer](const Observer& o) {
                return &o == &observer;
            });
        if (it != observers_.end()) {
            observers_.erase(it);
        }

    }*/
    // Setter方法用于修改配置参数的值
    void setParameters(const MyConfigStruct& newParameters) {
        parameters_ = newParameters;
        notifyObservers();
    }

private:
    Config() {
        // 初始化配置参数
        parameters_ = { 0, "" };
    }

    // 配置参数
    MyConfigStruct parameters_;

    // 观察者集合
    std::vector<Observer> observers_;

    // 通知观察者
    void notifyObservers() {
        for (const auto& observer : observers_) {
            observer(parameters_);
        }
    }
};

// 模块A作为观察者，处理参数变化的通知
class ModuleA {
public:
    void handleConfigUpdate(const MyConfigStruct& config) {
        std::cout << "Module A: Parameter 1 = " << config.parameter1 << ", Parameter 2 = " << config.parameter2 << std::endl;
    }
};

// 模块B作为观察者，处理参数变化的通知
class ModuleB {
public:
    void handleConfigUpdate(const MyConfigStruct& config) {
        std::cout << "Module B: Parameter 1 = " << config.parameter1 << ", Parameter 2 = " << config.parameter2 << std::endl;
    }
};

int main() {
    // 创建配置实例和模块实例
    Config& config = Config::getInstance();
    ModuleA moduleA;
    ModuleB moduleB;

    // 注册观察者
    config.registerObserver([&moduleA](const MyConfigStruct& config) {
        moduleA.handleConfigUpdate(config);
    });
    config.registerObserver([&moduleB](const MyConfigStruct& config) {
        moduleB.handleConfigUpdate(config);
    });

    // 更新配置参数
    MyConfigStruct newParameters{ 42, "Hello World" };
    config.setParameters(newParameters);

    // 移除观察者
    config.removeObserver([&moduleA](const MyConfigStruct& config) {
        moduleA.handleConfigUpdate(config);
    });

    // 再次更新配置参数
    MyConfigStruct newParameters2{ 100, "Goodbye" };
    config.setParameters(newParameters2);

    return 0;
}

输出结果

Module A: Parameter 1 = 42, Parameter 2 = Hello World
Module B: Parameter 1 = 42, Parameter 2 = Hello World
Module A: Parameter 1 = 100, Parameter 2 = Goodbye
Module B: Parameter 1 = 100, Parameter 2 = Goodbye

在 removeObserver 方法中，我们使用了 std::remove_if 来查找并移除与指定观察者对象类型相同的观察者。通过比较 o.target_type() 和 observer.target_type() 可以判断两个观察者对象的类型是否相同。
在 C++ 中，std::function 是一个通用的函数封装器，可以包装任意可调用对象（如函数指针、函数对象、Lambda 表达式等）。为了允许运行时检查 std::function 所包装的具体函数对象类型，C++ 提供了 target_type() 成员函数来获取存储的函数对象类型信息。

在上述代码中，我们使用 o.target_type() 和 observer.target_type() 来比较两个观察者对象的函数对象类型是否相同。这样做是为了确保移除与指定观察者对象类型相同的观察者。

请注意，target_type() 返回的是 std::type_info 对象的指针，而不是直接的类型。因此，我们使用 == 运算符来比较两个 std::type_info 对象的指针是否相等，以判断两个观察者对象的函数对象类型是否相同。

使用set存储观察者列表

#include <iostream>
#include <set>
#include <functional>

// 配置参数结构体
struct MyConfigStruct {
    int parameter1;
    std::string parameter2;
};

class Config {
public:
    using Observer = std::function<void(const MyConfigStruct&)>;

    static Config& getInstance() {
        static Config instance;
        return instance;
    }

    // 注册观察者
    void registerObserver(Observer observer) {
        observers_.insert(observer);
    }

    // 移除观察者
    void removeObserver(Observer observer) {
        observers_.erase(observer);
    }

    // Setter方法用于修改配置参数的值
    void setParameters(const MyConfigStruct& newParameters) {
        parameters_ = newParameters;
        notifyObservers();
    }

private:
    Config() {
        // 初始化配置参数
        parameters_ = { 0, "" };
    }

    // 配置参数
    MyConfigStruct parameters_;

    // 比较函数对象，用于在集合中排序观察者
    struct ObserverComparator {
        bool operator()(const Observer& lhs, const Observer& rhs) const {
            // 在这里实现你需要的比较逻辑
            // 这里简单地使用内存地址进行比较
            return &lhs < &rhs;
        }
    };

    // 观察者集合
    std::set<Observer, ObserverComparator> observers_;

    // 通知观察者
    void notifyObservers() {
        for (const auto& observer : observers_) {
            observer(parameters_);
        }
    }
};

// 模块A作为观察者，处理参数变化的通知
class ModuleA {
public:
    void handleConfigUpdate(const MyConfigStruct& config) {
        std::cout << "Module A: Parameter 1 = " << config.parameter1 << ", Parameter 2 = " << config.parameter2 << std::endl;
    }
};

// 模块B作为观察者，处理参数变化的通知
class ModuleB {
public:
    void handleConfigUpdate(const MyConfigStruct& config) {
        std::cout << "Module B: Parameter 1 = " << config.parameter1 << ", Parameter 2 = " << config.parameter2 << std::endl;
    }
};

int main() {
    // 创建配置实例和模块实例
    Config& config = Config::getInstance();
    ModuleA moduleA;
    ModuleB moduleB;

    // 注册观察者
    config.registerObserver([&moduleA](const MyConfigStruct& config) {
        moduleA.handleConfigUpdate(config);
    });
    config.registerObserver([&moduleB](const MyConfigStruct& config) {
        moduleB.handleConfigUpdate(config);
    });

    // 更新配置参数
    MyConfigStruct newParameters{ 42, "Hello World" };
    config.setParameters(newParameters);

    // 移除观察者
    config.removeObserver([&moduleA](const MyConfigStruct& config) {
        moduleA.handleConfigUpdate(config);
    });

    // 再次更新配置参数
    MyConfigStruct newParameters2{ 100, "Goodbye" };
    config.setParameters(newParameters2);

    return 0;
}

同样的输出结果

Module A: Parameter 1 = 42, Parameter 2 = Hello World
Module B: Parameter 1 = 42, Parameter 2 = Hello World
Module A: Parameter 1 = 100, Parameter 2 = Goodbye
Module B: Parameter 1 = 100, Parameter 2 = Goodbye

在上述代码中，ObserverComparator 是一个用于比较观察者对象的比较器结构体。它实现了一个 operator() 函数，该函数接受两个观察者对象作为参数，并返回一个布尔值来表示它们的相对顺序。

在这个比较器中，我们简单地使用观察者对象的内存地址进行比较。如果 &lhs 小于 &rhs，则认为 lhs 在集合中应该排在 rhs 的前面，返回 true。否则，返回 false。

通过使用自定义的比较器，我们可以在 std::set 中根据指定的比较逻辑对观察者进行排序。这样做可以确保观察者在集合中以特定的顺序存储，并且在通知观察者时按照指定的顺序进行遍历。

需要注意的是，由于比较的是观察者对象的地址而不是函数对象本身，因此在使用这种比较器时需要小心。确保观察者对象的生命周期足够长，以便比较其地址的有效性。