C++11可变模板+继承

C++11 variadic template + inheritance

本文关键字：继承 C++11      更新时间：2023-10-16

我想使用可变模板编写线性叠加的抽象。要做到这一点，我想定义一个基类型，它显示某种形式的运算符((，比如

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派生类作为模板参数，以确定运算符((的调用签名。我想要一些类似的东西

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派生类中读取类型信息，以在Superposion中定义运算符((
  2. 此外，有没有一种推荐的方法来强制执行"叠加"只能用一个可叠加的派生类作为参数来调用
  3. 当然，一个更好的解决方案是编写一个叠加类，该类不需要从基类派生MyField，而是直接解析MyField的运算符((。我能以某种方式做到这一点吗

谢谢你的帮助！

首先，直接为您的问题提供解决方案。

一些元编程样板：

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>() ) );

叠加的主要模板为空，默认参数提取Superposable:的类型参数

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

则得到S的Superposable:的Result和Parameters类型的专门化

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

活生生的例子。顺便说一句，你错过了一个virtual。

请注意，我不赞成您的设计——结果应该是返回值(自然(，使()虚拟化似乎是个坏主意(如果我真的需要隐藏特定的实现，我会使用CRTP，并键入erase(。

您可以移除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，但在C++11中将其替换为typename std::result_of<?>::type作为插入。

template <typename Result, typename... Parameters>
class Superposable
{
public:
    using result_t = Result;
    using params_t = std::tuple<Parameters...>;
    virtual 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;
    }
};
template <typename, typename>
class Superposition_impl;
template <typename S, std::size_t... Is>
class Superposition_impl<S, std::index_sequence<Is...>>
{
    static_assert(std::is_base_of<Superposable<typename S::result_t, typename std::tuple_element<Is, typename S::params_t>::type...>, S>::value, "!");
public:
    std::vector<std::shared_ptr<S>> elements;
    void operator()(typename S::result_t& result, const typename std::tuple_element<Is, typename S::params_t>::type&... parameters) const
    {
        for (auto p : elements)
        {
            typename S::result_t r;
            (*p)(r, parameters...);
            result += r;
        }
    }
};
template <typename S>
using Superposition = Superposition_impl<S, std::make_index_sequence<std::tuple_size<typename S::params_t>::value>>;

DEMO

相关文章：