C++策略模式在神经网络实现中的应用问题

核心问题拆解 #

你遇到的本质矛盾是：C++不允许虚函数为模板，但Parameter作为模板类，无法直接作为非模板虚方法的参数；同时尝试CRTP静态策略模式时，Parameter中存储的Optimizer指针因为基类未模板化，导致类型不匹配。

方案一：模板化Optimizer基类+CRTP静态多态 #

这种方式通过将Optimizer基类模板化，结合CRTP实现静态多态，既避免了虚函数模板的限制，又能让优化器精准处理对应类型的Parameter。

代码实现 #

// 模板化Optimizer基类，CRTP实现静态多态
template<typename Derived, typename ParamType>
class Optimizer {
public:
    // 对外统一接口，转发到子类的实现
    void update(ParamType& param) {
        static_cast<Derived*>(this)->update_impl(param);
    }
};

// SGD优化器，继承模板化的Optimizer
template<typename ParamType>
class SGD : public Optimizer<SGD<ParamType>, ParamType> {
public:
    explicit SGD(double lr = 0.01) : learning_rate(lr) {}

    // 具体的更新逻辑实现
    void update_impl(ParamType& param) {
        param.weight -= learning_rate * param.grad_weight;
        param.bias -= learning_rate * param.grad_bias;
    }

private:
    double learning_rate;
};

// Parameter模板类，持有对应类型的Optimizer指针
template<typename T>
struct Parameter {
    T weight;
    T bias;
    T grad_weight;
    T grad_bias;

    // 定义当前Parameter对应的Optimizer类型
    using OptType = Optimizer<SGD<Parameter<T>>, Parameter<T>>;
    OptType* optimizer = nullptr;

    // 调用优化器更新参数
    void update() {
        if (optimizer) {
            optimizer->update(*this);
        }
    }
};

// Linear层，存储Parameter并初始化优化器
template<typename T>
class Linear {
public:
    Parameter<T> params;

    Linear(int in_features, int out_features) {
        // 假设T是矩阵类型，初始化权重和偏置
        params.weight = T(in_features, out_features);
        params.bias = T(1, out_features);
        // 绑定SGD优化器
        params.optimizer = new SGD<Parameter<T>>();
    }

    ~Linear() {
        delete params.optimizer;
    }

    // 前向传播等逻辑...
};

优势 #

• 静态多态无运行时开销，性能优于动态多态
• 类型安全，编译期即可检查参数与优化器的匹配性

方案二：类型擦除实现动态多态 #

如果需要更灵活的动态多态（比如同一优化器处理不同类型的Parameter），可以通过定义非模板的基类接口，用类型擦除隐藏Parameter的模板细节。

代码实现 #

// 非模板的Parameter基类，定义统一接口
class ParameterBase {
public:
    virtual ~ParameterBase() = default;
    virtual void update() = 0;
};

// 模板化的Parameter，继承ParameterBase
template<typename T>
struct Parameter : public ParameterBase {
    T weight;
    T bias;
    T grad_weight;
    T grad_bias;

    std::unique_ptr<Optimizer> optimizer;

    void update() override {
        if (optimizer) {
            optimizer->update(*this);
        }
    }
};

// 非模板的Optimizer基类，定义虚更新方法
class Optimizer {
public:
    virtual ~Optimizer() = default;
    virtual void update(ParameterBase& param) = 0;
};

// SGD优化器，模板化以处理特定类型的Parameter
template<typename T>
class SGD : public Optimizer {
public:
    explicit SGD(double lr = 0.01) : learning_rate(lr) {}

    void update(ParameterBase& param) override {
        // 动态转换到具体的Parameter类型
        auto* typed_param = dynamic_cast<Parameter<T>*>(&param);
        if (!typed_param) {
            // 可添加断言或异常处理类型不匹配的情况
            return;
        }
        // 执行SGD更新逻辑
        typed_param->weight -= learning_rate * typed_param->grad_weight;
        typed_param->bias -= learning_rate * typed_param->grad_bias;
    }

private:
    double learning_rate;
};

优势 #

• 支持动态多态，同一优化器可处理不同类型的Parameter（需确保类型转换正确）
• 代码结构更接近传统的OOP策略模式

内容的提问来源于stack exchange，提问作者Eric Cardozo