C++ 11可变参数模板+继承

Question

我想用可变参数模板编写线性叠加的抽象.为此,我想定义一个表示某种形式的operator()的基类型

template <typename Result, typename... Parameters>
class Superposable {
  public:
    typedef Result result_t;
    void operator()(Result& result, const Parameters&...) const = 0;
};

然后从它继承当前的问题,例如像这样

class MyField : public Superposable<double, double, double> {
  public:
    void operator()(double& result, const double& p1, const double& p2) const {
      result = p1 + p2;
    }
};

然后我想编写一个抽象基类,它可以形成线性叠加,并将Superposable派生类作为模板参数来确定operator()的调用签名.我想有类似的东西

template<typename S> // where S must be inherited from Superposable
class Superposition {
  private:
    std::vector< std::shared_ptr<S> > elements;
  public:

     // This is the problem. How do I do this?
    void operator()(S::result_t& result, const S::Parameters&... parameters) const {
       for(auto p : elements){
          S::result_t r;
          p->operator()(r, parameters);
          result += r;
       }
    }
};

这是我的问题:

1. 如何从Superposable派生类中读出类型信息以在Superposition中定义我的operator()？
2. 另外,是否有推荐的方法来强制只能使用Superposable派生类作为参数调用Superposition？
3. 一个更好的解决方案当然是编写一个Superposition类,它不需要从基类派生MyField,而是直接解析MyField的operator().我能以某种方式这样做吗？

谢谢你的帮助!

Answer 1

首先,直接解决您的问题.

一些元编程样板:

template<class...>struct types{using type=types;};

一种hana风格的函数,它提取参数的类型,可选择根据以下内容从中提取模板以进行提取:

template<template<class...>class Z, class...Args>
constexpr types<Args...> extract_args( Z<Args...> const& ) { return {}; }

包含上述内容的别名,decltype以方便使用:

template<template<class...>class Z, class T>
using extract_args_from = decltype( extract_args<Z>( std::declval<T>() ) );

Superposition的主要模板保留为空,其默认参数提取以下类型参数Superposable:

template<class S, class Args=extract_args_from<Superposable, S>>
class Superposition;

然后该获取一个专业化Result和Parameters(可能的基类的)的类型S的Superposable:

template<class S, class Result, class...Parameters>
class Superposition< S, types<Result, Parameters...>> {

实例.顺便说一下,你错过了一个virtual.

请注意,我不赞同你的设计 - 结果应该是返回值(自然地),使()虚拟看起来像个坏主意(我会改用CRTP,如果我真的需要隐藏特定内容,则键入擦除实现).

您可以删除正文,Superposable它按原样运行:

public:
  typedef Result result_t;
  void operator()(Result& result, const Parameters&...) const = 0;

我至少推荐过这个.

下一步是完全摆脱继承和演绎Parameters:

class MyField {
public:
  double operator()(const double& p1, const double& p2) const {
    return p1 + p2;
  }
};
template<typename S> // where S must be inherited from Superposable
class Superposition {
  private:
    std::vector< std::shared_ptr<S> > elements;
public:

  template<class...Parameters,
    class R=std::result_of_t<S&(Parameters const&...)>
  >
  R operator()(const Parameters&... parameters) const {
    R ret = {};
    for(auto p : elements){
      ret += (*p)(parameters...);
    }
    return ret;
  }
};

它具有完美转发的所有缺陷,但也具有所有优点.

std::result_of_t<?>是C++ 14,但typename std::result_of<?>::type在C++ 11中将其替换为插件.