C++ 技巧反射

普通情况下，类名 必须在编译时确定。
反射允许 运行时根据字符串决定创建哪个类。

```c++
#include <iostream>
#include <map>
#include <vector>
#include <string>
#include <functional>
#include <memory>
#include <any>

// ==================== 观察者模式基础 ====================

// 事件参数（可扩展）
struct EventArgs {
    std::string type;
    std::any data;
};

// 观察者接口
class IObserver {
public:
    virtual void onNotify(const EventArgs& args) = 0;
    virtual ~IObserver() = default;
};

// 可被观察的对象
class Observable {
    std::vector<IObserver*> observers;
public:
        virtual ~Observable() = default;
    void addObserver(IObserver* obs) {
        observers.push_back(obs);
    }

void notify(const EventArgs& args) {
        for (auto* obs : observers) {
            obs->onNotify(args);
        }
    }
};

// ==================== 反射：工厂注册宏 ====================

// 创建对象的函数类型
using CreatorFunc = std::function<std::shared_ptr<Observable>()>;

// 全局工厂
class ObjectFactory {
    std::map<std::string, CreatorFunc> creators;
public:
    static ObjectFactory& instance() {
        static ObjectFactory inst;
        return inst;
    }

void registerClass(const std::string& className, CreatorFunc creator) {
        creators[className] = creator;
    }

std::shared_ptr<Observable> create(const std::string& className) {
        auto it = creators.find(className);
        if (it != creators.end()) {
            return it->second();
        }
        return nullptr;
    }
};

// 自动注册宏（放在类定义的 cpp 或头文件实现处）
#define REGISTER_OBSERVABLE(ClassName) \
    namespace { \
        struct AutoRegister##ClassName { \
            AutoRegister##ClassName() { \
                ObjectFactory::instance().registerClass(#ClassName, \
                    []() -> std::shared_ptr<Observable> { \
                        return std::make_shared<ClassName>(); \
                    }); \
            } \
        }; \
        static AutoRegister##ClassName __autoReg##ClassName; \
    }

// ==================== 具体可被观察的类 ====================

// 传感器（示例1）
class Sensor : public Observable {
    std::string name;
    float value;
public:
    Sensor() : name("unknown"), value(0) {}
    void setValue(float v) {
        value = v;
        EventArgs args;
        args.type = "SensorChanged";
        args.data = value;
        notify(args);
    }
    float getValue() const { return value; }
};
REGISTER_OBSERVABLE(Sensor)

// 报警器（示例2）
class Alarm : public Observable {
    bool active;
public:
    Alarm() : active(false) {}
    void trigger() {
        active = true;
        EventArgs args;
        args.type = "AlarmTriggered";
        args.data = std::string("HIGH_TEMP");
        notify(args);
    }
    bool isActive() const { return active; }
};
REGISTER_OBSERVABLE(Alarm)

// ==================== 观察者示例 ====================

class Logger : public IObserver {
public:
    void onNotify(const EventArgs& args) override {
        if (args.type == "SensorChanged") {
            float val = std::any_cast<float>(args.data);
            std::cout << "[Logger] sensor changed: " << val << std::endl;
        } else if (args.type == "AlarmTriggered") {
            std::string reason = std::any_cast<std::string>(args.data);
            std::cout << "[Logger] alarm trig: " << reason << std::endl;
        }
    }
};

class Display : public IObserver {
public:
    void onNotify(const EventArgs& args) override {
        if (args.type == "SensorChanged") {
            float val = std::any_cast<float>(args.data);
            std::cout << "[Display] refresh window: " << val << std::endl;
        }
    }
};

// ==================== 主程序演示 ====================

int main() {
    // 通过反射创建对象
    auto sensor = ObjectFactory::instance().create("Sensor");
    auto alarm  = ObjectFactory::instance().create("Alarm");

if (!sensor || !alarm) {
        std::cout << "create object failed" << std::endl;
        return -1;
    }

// 创建观察者
    Logger logger;
    Display display;

// 注册观察者
    sensor->addObserver(&logger);
    sensor->addObserver(&display);
    alarm->addObserver(&logger);

// 触发变化 → 观察者自动响应
    std::cout << "=== sensor trig ===" << std::endl;
    dynamic_cast<Sensor*>(sensor.get())->setValue(25.5f);

std::cout << "\n=== alarm trig ===" << std::endl;
    dynamic_cast<Alarm*>(alarm.get())->trigger();

return 0;

}

```

C++ 技巧 反射

C++ 技巧反射