[英]C++11 variadic template + inheritance
我想用可变参数模板编写线性叠加的抽象。 为此,我想定义一个表示某种形式的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;
}
}
};
这是我的问题:
谢谢你的帮助!
首先,直接解决您的问题。
一些元编程样板:
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;
然后是一个特殊化,它获得S
(可能是基类) S
的Superposable
的Result
和Parameters
类型:
template<class S, class Result, class...Parameters>
class Superposition< S, types<Result, Parameters...>> {
实例 。 顺便说一句,你错过了virtual
。
请注意,我不赞成你的设计 - 结果应该是返回值(自然地),make ()
虚拟似乎是一个坏主意(我使用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
替换为drop-in。
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>>;
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.