c++模板写一个反射，给出代码示例

好的，以下是一个简单的C++模板反射示例：

#include <iostream>
#include <string>
#include <map>

// 基类，包含反射接口
class Reflective {
public:
    virtual std::string className() const = 0;
    virtual void* newInstance() const = 0;
};

// 反射实现类
template <class T>
class Reflection : public Reflective {
public:
    std::string className() const override {
        return typeid(T).name();
    }
    void* newInstance() const override {
        return new T();
    }
};

// 反射注册表
class ReflectionRegistry {
public:
    static ReflectionRegistry& instance() {
        static ReflectionRegistry registry;
        return registry;
    }

    Reflective* get(const std::string& className) const {
        auto iter = m_registry.find(className);
        if (iter != m_registry.end()) {
            return iter->second;
        }
        return nullptr;
    }

    void registerClass(Reflective* reflect) {
        m_registry.insert(std::make_pair(reflect->className(), reflect));
    }

private:
    ReflectionRegistry() = default;
    std::map<std::string, Reflective*> m_registry;
};

// 宏定义，用于注册反射类
#define REFLECT_CLASS(T) \
    static Reflection<T> reflection_##T; \
    void* T::operator new(std::size_t size) { \
        auto reflect = ReflectionRegistry::instance().get(typeid(T).name()); \
        if (reflect) { \
            return reflect->newInstance(); \
        } \
        return ::operator new(size); \
    } \
    static void register_##T() { \
        ReflectionRegistry::instance().registerClass(&reflection_##T); \
    } \
    static int dummy_##T = (register_##T(), 0)

// 反射类实现
class Base {
public:
    virtual void foo() = 0;
    virtual ~Base() = default;

    // 反射相关
    static void* operator new(std::size_t size);
    virtual std::string className() const {
        return typeid(*this).name();
    }
};

REFLECT_CLASS(Base);

class Derived : public Base {
public:
    void foo() override {
        std::cout << "Derived::foo()" << std::endl;
    }
};

REFLECT_CLASS(Derived);

// 测试代码
int main() {
    Base* b = new Base();
    Base* d = new Derived();

    std::cout << b->className() << std::endl;
    std::cout << d->className() << std::endl;

    Base* bd = new Derived();
    bd->foo();

    return 0;
}

以上代码定义了一个 `Reflective` 基类，包含了反射接口，用于提供类名和实例创建的方法。`Reflection` 类是一个模板类，用于实现 `Reflective` 接口的具体类。`ReflectionRegistry` 类是反射注册表，可以通过类名查找对应的反射类。`REFLECT_CLASS` 宏定义用于注册反射类。`Base` 类是一个基类，包含反射相关的实现，而 `Derived` 类则是一个从 `Base` 类派生出来的子类，用于测试反射功能。

在测试代码中，首先创建了一个 `Base` 对象和一个 `Derived` 对象，分别输出它们的类名。然后创建了一个 `Derived` 类的对象，并调用其 `foo()` 方法。