C++ 可变参数类模板设计

Question

我正在开发一个混合类型的 Config Reader 类，它支持从环境、命令行、文件等读取配置数据。

我有点遵循 std::tuple 类型设计：

template <class... Ts> struct ConfigReader {};

template <class T, class... Ts>
class ConfigReader<T, Ts...> : ConfigReader<Ts...>
{
  public:
    typedef boost::fusion::set<T, Ts...> sequence_type;

    ConfigReader(T t, Ts... ts)
      : ConfigReader<Ts...>(ts...)
      , parameters_(t, ts...)
    {
      this->init();
    }

  private:
    sequence_type parameters_;

    void init()
    {
       boost::fusion::for_each(parameters_, SetFromEnvironment());
       boost::fusion::for_each(parameters_, SetFromCommandLine());
       boost::fusion::for_each(parameters_, SetFromConfigFile());
    }
};

但我意识到我也可以在没有递归继承的情况下定义它

template <class T, class... Ts>
class ConfigReader<T, Ts...>
{
  public:
    typedef boost::fusion::set<T, Ts...> sequence_type;

    ConfigReader(T t, Ts... ts)
      : parameters_(t, ts...)
    {
      this->init();
    }

    template <class Type>
    typename boost::fusion::result_of::value_at_key<Sequence const, Type>::type get()
    {
      return boost::fusion::at_key<Type>(parameters);
    }

  private:
    sequence_type parameters_;

    void init()
    {
       boost::fusion::for_each(parameters_, SetFromEnvironment());
       boost::fusion::for_each(parameters_, SetFromCommandLine());
       boost::fusion::for_each(parameters_, SetFromConfigFile());
    }
};

后一种情况似乎效果更好，因为 init() 只被调用一次，这正是我想要的。但是现在我很困惑这两者之间有什么区别？如果没有递归继承，我会失去一些东西吗？

简化用法是......（忽略参数类型结构）

int main()
{
  ConfigReader<Start, End, Resources> configReader(Start(), End("infinity"), Resources());

  Start startTime = configReader.get<Start>();
}

Answer 1

递归方法没有意义。考虑一个您想要的示例：

ConfigReader<A, B, C> reader(A{}, B{}, C{});

在递归的情况下，你会得到这个层次结构：

ConfigReader<A, B, C> has three readers: A, B, C
    |
    |
    V
ConfigReader<B, C> has two readers: B, C
    |
    |
    V
ConfigReader<C> has one reader: C

您有 6 个读者，而您的意思是只有 3 个！当您执行递归层次结构时，可能的意思是每个实例化只有 一个 阅读器：不是所有的阅读器。那就是：

template <typename T, typename... Ts>
struct ConfigReader : ConfigReader<Ts...> {
    T current;

    ConfigReader(T t, Ts... ts)
    : ConfigReader<Ts...>(ts...)
    , current(t)
    { }
};

但是您使用 boost fusion set 所做的事情直接实现了这一点。不过，对于 C++11，您可能应该坚持使用：

template <typename... T>
struct ConfigReader {
    std::tuple<T...> readers;
};

它应该适合您的目的。