[英]Variadic member function of template class
我正面临一个问题,我正在尝试使用特定类型的参数包创建一个可变成员函数。
template <typename T>
struct A
{
using result_type = T;
T operator()(T a, T b)
{
return a+b;
}
};
template <typename Functor>
struct B
{
using T = typename Functor::result_type;
T operator()(Functor &&f, T... args)
{
return f(args...);
}
};
它应该像以下一样工作:
A<int> a;
B<A<int>> b;
int result = b(a, 2, 3); // should return 5
但是我收到以下错误:
error: type 'T' (aka 'typename Functor::result_type') of function parameter pack does not contain any unexpanded parameter packs
T operator()(Functor &&f, T... args)
~^~~~~~~~
error: pack expansion does not contain any unexpanded parameter packs
return f(args...);
~~~~^
实现预期功能的正确方法是什么?
仅当函数是函数模板时,才能使用参数包。
来自http://en.cppreference.com/w/cpp/language/parameter_pack :
模板参数包是一个模板参数,它接受零个或多个模板参数(非类型,类型或模板)。 函数参数包是一个函数参数,它接受零个或多个函数参数。
具有至少一个参数包的模板称为可变参数模板。
template <typename ... Args>
T operator()(Functor&& f, Args... args)
{
return f(args...);
}
另外,只有在模板参数中,在上述函数中使用&&
才有意义。 如果在参数上使用&&
而类型不是模板参数,则不能使用:
A<int> a;
B<A<int>> b;
int r = b(a, 2, 3);
但是,您可以使用
int r = b(std::move(a), 2, 3);
随便挑选。 保持参数类型不变并使用std::move(a)
或更改函数以使用简单引用
template <typename ... Args>
T operator()(Functor& f, Args... args)
{
return f(args...);
}
并使用
int r = b(a, 2, 3);
更新
您可以使用帮助程序类来确保所有参数都是正确的类型。
template<typename ... Args> struct IsSame : public std::false_type {};
template<typename T> struct IsSame<T> : public std::true_type {};
template<typename T, typename ... Args> struct IsSame<T, T, Args...> : public std::true_type
{
static const bool value = IsSame<T, Args ...>::value;
};
并使用:
template <typename ... Args>
T operator()(Functor&& f, Args... args)
{
static_assert(IsSame<T, Args...>::value, "Invalid argument type");
return f(args...);
}
接着就,随即,
A<int> a;
B<A<int>> b;
int r = b(std::move(a), 2, 3);
仍然有效
r = b(std::move(a), 2, 3.0);
失败。
在你的情况下,我不知道对参数类型是否严格要求。 如果需要,你有办法。
一个想法是使用std::initializer_list
,它将强制使用相同的类型(当然,您可以使用可变参数模板和一些巧妙使用std::is_same
来强制执行相同类型的所有params可变参数模板):
#include <algorithm>
#include <initializer_list>
#include <utility>
#include <iostream>
template <typename T>
struct A
{
using result_type = T;
T operator()(std::initializer_list<result_type> const& li)
{
return std::accumulate(std::begin(li), std::end(li), 0.);
}
};
template <typename Functor>
struct B
{
using T = typename Functor::result_type;
T operator()(Functor &&f, std::initializer_list<T> args)
{
return f(args);
}
};
int main()
{
A<int> functor;
B<decltype(functor)> test;
std::cout << test(std::move(functor), {1, 2, 3}); // displays 6
}
可以做一些SFINAE技巧,如:
struct Foo {};
template<class T, class...>
struct all_same : std::true_type
{};
template<class T, class U, class... SS>
struct all_same<T, U, SS...>
: std::integral_constant<bool, std::is_same<T,U>{} && all_same<T, SS...>{}>
{};
然后,
template <typename Functor>
struct B
{
using T = typename Functor::result_type;
template<typename ...Args>
T operator()(Functor&& f, Args... args)
{
static_assert(all_same<T, Args...>{}, "all not same types");
return f(args...);
}
};
Here
演示
你应该使用一个参数包。 另外,为什么要尝试传递右值参考?
template <typename Functor>
struct B
{
using T = typename Functor::result_type;
template<typename ...Args>
T operator()(Functor f, Args... args)
{
return f(args...);
}
};
编辑:如果要验证所有参数都是T类型,可以声明一个验证结构:
template <typename T, typename ...Pack>
struct verify_params {};
template <typename T>
struct verify_params<T> {
using val=void;
};
template <typename T, typename ...Pack>
struct verify_params<T,T,Pack...> {
using val=typename verify_params<T,Pack...>::val;
};
然后,您可以添加一行(typename verify_params<T,Args...>::val)0;
你的功能。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.