在模板参数列表中使用参数包-解网

问：

我想编写一个抽象类，该类获取一些具有特定签名的函数作为模板参数，并根据输入数据的解析阶段运行它们。这是我写的代码：Pipeline

#include <array>

enum class ParseState
{
  EXTRACTED,   /**< EXTRACTED */
  IN_PROGRESS, /**< IN_PROGRESS */
  REJECTED,    /**< REJECTED */
};

struct ParseStage
{
  std::size_t stage;

public:
  ParseStage() : stage(0)
  {}

  std::size_t get_stage() const
  {
    return stage;
  }

  std::size_t next_stage()
  {
    return ++stage;
  }

  void reset()
  {
    stage = 0;
  }
};

template <typename InputDataType>
using ParseResult = std::pair<ParseState, InputDataType>;

template <typename InputDataType, typename ParserState, typename... Args>
using StageFunctionRefType = ParseResult<InputDataType> (&)(const InputDataType &, ParserState &, Args... args);

template <typename InputDataType, typename ParserState, typename... Args,
          StageFunctionRefType<InputDataType, ParserState, Args...>... StageFunctions>
class Pipeline
{
  static constexpr std::array Stages{ StageFunctions... };

public:
  static ParseResult<InputDataType> feed(const InputDataType &input_data, ParserState &parser_state,
                                         ParseStage &parse_stage, Args... args)
  {
    if (parser_state.parse_state == ParseState::REJECTED)
      return { ParseState::REJECTED, input_data };

    auto remaining_data = input_data;

    while (parse_stage.get_stage() < Stages.size() && remaining_data.size())
    {
      const auto parse_result = Stages[parse_stage.get_stage()](remaining_data, parser_state, args...);
      remaining_data = parse_result.second;
      if (parse_result.first == ParseState::EXTRACTED)
        parse_stage.next_stage();
      else if (parse_result.first == ParseState::REJECTED)
        return parse_result;
    }

    if (parse_stage.get_stage() == Stages.size())
      return { ParseState::EXTRACTED, remaining_data };

    return { ParseState::IN_PROGRESS, remaining_data };
  }
};

但我收到一条错误消息：parameter pack 'Args' must be at the end of the template parameter list

我该如何解决这个问题？或者您还有其他解决方案吗？性能对我来说真的很重要，所以我想避免使用虚拟或。std::function

C++ 模板 variadic-templates 参数包

void foo1(int i) {
    std::cout << i << '\n';
}

void foo2(int i, double d){
    std::cout << "i = " << i << ", d = " << d << '\n';
}

void foo3(int i, double d){
    std::cout << "i * d = " << i * d << '\n';
}

int main() {
    FoosHolder<foo1> f1;
    FoosHolder<foo2, foo3> f2;
    f1.call(7);
    f2.call(2, 2.5);
}

预期输出为：

7
i = 2, d = 2.5
i * d = 5

但是，上面的代码有点局限性。因为它不允许 lambda 作为 FoosHolder 的函数。这就提出了一个问题，为什么我们需要首先声明。一个可能更好的方法是使用一个简单的模板，而不需要任何专业化，就像这样：foo

template <auto... Foos>
class FoosHolder
{
public:
    template <typename... Args>
    static void call(Args... args) {
        return (..., Foos(args...));
    }
};

现在我们也可以做（使用 C++20）：

FoosHolder<[](){std::cout << "lambda!\n";}> f3;
f3.call();

FoosHolder<[](char c){std::cout << "lambda with params!" << c;}> f4;
f4.call('\n');

这种方法有一个小缺点（恕我直言，这是一个合理的缺点），因为它允许创建一个 FoosHolder，其函数需要不同数量的参数，这不会在创建类型时被捕获，而只有在调用操作时才会被捕获：call

FoosHolder<foo1, foo3> f5; // passes compilation
f5.call(3, 1.5); // fails compilation only here

在模板参数列表中使用参数包

Use parameter pack in template parameters list

评论

评论