可变参数模板推导失败：构建类型安全C++操作流水线遇阻

我尝试构建类型安全的操作流水线，以下是简化后的核心代码。我已尝试多种可变参数包的组合与顺序，但认为问题并非源于此。我怀疑问题出自模板参数推导的非推导上下文，但现有解决方法在此处无效。我希望获得可彻底规避该问题的方案，要求操作链能正确进行类型检查，且最终Pipeline具备正确的Op<>类型。

enum DType {
  INT,
  FLOAT,
  DOUBLE,
};

template<DType InputT, DType OutputT>
class Op: public BaseOp {// Do stuff 
};

template<DType InputT, DType OutputT>
class Pipeline:Op<InputT, OutputT> {
vector<Ptr<BaseOp>> pipeline_stages;
public:
  Pipeline(Ptr<Op<InputT, OutputT>> stage) {
    //add to pipeline_stages 
  };
  
  template<DType TempOutputT, class... Stages>
  Pipeline(Ptr<Op<InputT, TempOutputT>> stage, Stages... stages):Pipeline(stage, Pipeline<TempOutputT, OutputT>(stages...)) {}

  template<DType OldOutputT>
  Pipeline(Ptr<Op<InputT,OldOutputT>> stage, Pipeline<OldOutputT,OutputT> other) {
    //Insert stages to vec
  };

  //Do all the Pipeline and Op stuff
};

// Ideally, this would work with auto mypipe.
Pipeline<DType::INT, DType::FLOAT> mypipe(
  make_ptr<CovertOp<DType::INT, DType::FLOAT>>(),
  make_ptr<FloatOp1>(),
  make_ptr<FloatOp2>(param)
  );

核心问题在于直接调用Pipeline构造函数时，模板参数OutputT处于非推导上下文，编译器无法从后续参数中推导出来。我们可以通过辅助工厂函数+链式调用的方式彻底规避这个问题，同时保证类型安全：

1. 重构Pipeline实现 #

调整Pipeline的构造逻辑，通过工厂函数和链式扩展方法让编译器自动推导类型：

#include <vector>
#include <memory>

enum DType {
  INT,
  FLOAT,
  DOUBLE,
};

class BaseOp {
public:
    virtual ~BaseOp() = default;
};

template<DType InputT, DType OutputT>
class Op : public BaseOp {
public:
    using InputType = InputT;
    using OutputType = OutputT;
};

// 示例操作类实现
template<DType In, DType Out>
class ConvertOp : public Op<In, Out> {};

template<DType In>
class FloatOp1 : public Op<In, DType::FLOAT> {};

template<DType In>
class FloatOp2 : public Op<In, DType::FLOAT> {
public:
    explicit FloatOp2(int param) {}
};

template<DType InputT, DType OutputT>
class Pipeline : public Op<InputT, OutputT> {
    std::vector<std::unique_ptr<BaseOp>> pipeline_stages;

    // 私有构造：单阶段初始化
    Pipeline(std::unique_ptr<Op<InputT, OutputT>> stage) {
        pipeline_stages.emplace_back(std::move(stage));
    }

    // 私有构造：从已有Pipeline扩展
    Pipeline(Pipeline<InputT, auto> prev_pipeline, std::unique_ptr<Op<decltype(prev_pipeline)::OutputType, OutputT>> next_stage)
        requires (decltype(prev_pipeline)::OutputType == decltype(next_stage)::InputType) {
        // 复制前序所有阶段
        for (auto& stage : prev_pipeline.pipeline_stages) {
            pipeline_stages.push_back(std::move(stage));
        }
        pipeline_stages.emplace_back(std::move(next_stage));
    }

public:
    // 工厂函数：创建单阶段Pipeline
    template<DType In, DType Out>
    static Pipeline<In, Out> create(std::unique_ptr<Op<In, Out>> stage) {
        return Pipeline<In, Out>(std::move(stage));
    }

    // 链式扩展方法：添加新操作阶段
    template<DType NewOutput>
    auto then(std::unique_ptr<Op<OutputT, NewOutput>> next_stage) {
        return Pipeline<InputT, NewOutput>(std::move(*this), std::move(next_stage));
    }

    // 示例执行逻辑
    void run() {
        for (auto& stage : pipeline_stages) {
            // 这里可以调用每个Op的具体执行方法
        }
    }
};

2. 使用方式（支持auto推导） #

通过create工厂函数和then链式调用，编译器会自动推导所有类型，同时严格检查操作链的输入输出匹配：

int main() {
    // auto自动推导最终类型为Pipeline<DType::INT, DType::FLOAT>
    auto mypipe = Pipeline::create(std::make_unique<ConvertOp<DType::INT, DType::FLOAT>>())
        .then(std::make_unique<FloatOp1<DType::FLOAT>>())
        .then(std::make_unique<FloatOp2<DType::FLOAT>>(42));

    mypipe.run();
    return 0;
}

方案优势 #

• 强类型安全：操作链的输入输出类型不匹配时，编译器直接报错，无运行时风险
• 自动类型推导：无需手动指定Pipeline的模板参数，auto即可获取最终类型
• 彻底规避非推导上下文：链式调用的每一步都基于前一步的输出类型推导，编译器可逐步解析

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