C++模板类如何支持面向对象 泛型编程与多态结合技巧

template <typename T>
class Base {
public:
    virtual ~Base() {} // 确保析构函数为虚函数，支持动态多态

    virtual T process(T input) {
        // 默认实现，可以在派生类中重写
        return input;
    }
};

template <typename T>
class Derived : public Base<T> {
public:
    T process(T input) override {
        // 派生类特定的处理逻辑
        return input * 2;
    }
};

template <typename Derived>
class Base {
public:
    T process(T input) {
        // 将调用转发给派生类
        return static_cast<Derived*>(this)->process_impl(input);
    }

private:
    T process_impl(T input) {
        // 默认实现，如果派生类没有提供，则调用此实现
        return input;
    }
};

class Derived : public Base<Derived> {
public:
    T process_impl(T input) {
        // 派生类特定的处理逻辑
        return input * 2;
    }
};

#include <memory>
#include <typeindex>
#include <unordered_map>

class AnyProcessor {
public:
    template <typename T>
    AnyProcessor(T obj) : 
        type_(typeid(T)),
        deleter_([](void* p){ delete static_cast<T*>(p); }),
        data_(new T(obj)),
        process_func_([](void* p, int input) { return static_cast<T*>(p)->process(input); })
    {}

    int process(int input) {
        return process_func_(data_, input);
    }

    std::type_index type() const { return type_; }

    ~AnyProcessor() { deleter_(data_); }

private:
    std::type_index type_;
    void* data_;
    std::function<void(void*)> deleter_;
    std::function<int(void*, int)> process_func_;
};

class IntProcessor {
public:
    int process(int input) { return input + 1; }
};

class FloatProcessor {
public:
    int process(int input) { return static_cast<int>(input * 1.5); }
};

// 使用示例
AnyProcessor int_processor(IntProcessor{});
int result1 = int_processor.process(5); // result1 = 6

AnyProcessor float_processor(FloatProcessor{});
int result2 = float_processor.process(5); // result2 = 7