使用带有可变参数模板函数的 decltype 的尾随返回类型

Question

我想编写一个简单的加法器（用于傻笑），将每个参数相加并返回具有适当类型的总和。 目前，我有这个：

#include <iostream>
using namespace std;

template <class T>
T sum(const T& in)
{
   return in;
}

template <class T, class... P>
auto sum(const T& t, const P&... p) -> decltype(t + sum(p...))
{
   return t + sum(p...);
}

int main()
{
   cout << sum(5, 10.0, 22.2) << endl;
}

在 GCC 4.5.1 上，这似乎适用于 2 个参数，例如 sum(2, 5.5) 返回 7.5。 但是，有比这更多的参数，我得到 sum() 尚未定义的错误。 但是，如果我像这样声明 sum() ：

template <class T, class P...>
T sum(const T& t, const P&... p);

然后它适用于任意数量的参数，但 sum(2, 5.5) 将返回整数 7，这不是我所期望的。 有两个以上的参数，我假设 decltype() 必须进行某种递归才能推断出 t + sum(p...) 的类型。 这是合法的 C++0x 吗？ 还是 decltype() 仅适用于非可变参数声明？ 如果是这样，您将如何编写这样的函数？

Answer 1

我认为问题在于可变参数函数模板仅在您指定其返回类型后才被视为声明，因此decltype中的sum永远不会引用可变参数函数模板本身。 但我不确定这是 GCC 错误还是 C++0x 根本不允许这样做。 我的猜测是 C++0x 不允许在->decltype(expr)部分进行“递归”调用。

作为一种解决方法，我们可以使用自定义特征类避免->decltype(expr)这种“递归”调用：

#include <iostream>
#include <type_traits>
using namespace std;

template<class T> typename std::add_rvalue_reference<T>::type val();

template<class T> struct id{typedef T type;};

template<class T, class... P> struct sum_type;
template<class T> struct sum_type<T> : id<T> {};
template<class T, class U, class... P> struct sum_type<T,U,P...>
: sum_type< decltype( val<const T&>() + val<const U&>() ), P... > {};

这样，我们可以用typename sum_type<T,P...>::type替换程序中的decltype并且它会编译。

编辑：由于这实际上返回decltype((a+b)+c)而不是decltype(a+(b+c))这将更接近您如何使用加法，您可以用这个替换最后一个专业化：

template<class T, class U, class... P> struct sum_type<T,U,P...>
: id<decltype(
      val<T>()
    + val<typename sum_type<U,P...>::type>()
)>{};

Answer 2

C++14的解决方案：

template <class T, class... P>
decltype(auto) sum(const T& t, const P&... p){
    return t + sum(p...);
}

自动扣除返回类型。

在在线编译器中查看

如果您想支持不同类型的引用，甚至更好：

template <class T, class... P>
decltype(auto) sum(T &&t, P &&...p)
{
   return std::forward<T>(t) + sum(std::forward<P>(p)...);
}

在在线编译器中查看

如果您需要求和的自然顺序（即(((a+b)+c)+d)而不是(a+(b+(c+d))) ），则解决方案更复杂：

template <class A>
decltype(auto) sum(A &&a)
{
    return std::forward<A>(a);
}

template <class A, class B>
decltype(auto) sum(A &&a, B &&b)
{
    return std::forward<A>(a) + std::forward<B>(b);
}

template <class A, class B, class... C>
decltype(auto) sum(A &&a, B &&b, C &&...c)
{
    return sum( sum(std::forward<A>(a), std::forward<B>(b)), std::forward<C>(c)... );
}

在在线编译器中查看

Answer 3

显然你不能以递归方式使用 decltype （至少目前，也许他们会修复它）

您可以使用模板结构来确定和的类型

它看起来丑陋但有效

#include <iostream>
using namespace std;


template<typename... T>
struct TypeOfSum;

template<typename T>
struct TypeOfSum<T> {
    typedef T       type;
};

template<typename T, typename... P>
struct TypeOfSum<T,P...> {
    typedef decltype(T() + typename TypeOfSum<P...>::type())        type;
};



template <class T>
T sum(const T& in)
{
   return in;
}

template <class T, class... P>
typename TypeOfSum<T,P...>::type sum(const T& t, const P&... p)
{
   return t + sum(p...);
}

int main()
{
   cout << sum(5, 10.0, 22.2) << endl;
}

Answer 4

使用 C++11 的std::common_type减少输入的最后一个问题的另一个答案：只需使用

std::common_type<T, P ...>::type

作为您的可变参数总和的返回类型。

关于std::common_type ，这里是http://en.cppreference.com/w/cpp/types/common_type的摘录：

对于算术类型，公共类型也可以被视为（可能是混合模式）算术表达式的类型，例如 T0() + T1() + ... + Tn()。

但显然这仅适用于算术表达式，并不能解决一般问题。

Answer 5

我为接受的答案提供了这种改进。 只有两个结构

#include <utility>

template <typename P, typename... Ps>
struct sum_type {
    using type = decltype(std::declval<P>() + std::declval<typename sum_type<Ps...>::type>());
};

template <typename P>
struct sum_type<P> {
    using type = P;
};

现在只需将您的函数声明为

template <class T>
auto sum(const T& in) -> T
{
   return in;
}

template <class P, class ...Ps>
auto sum(const P& t, const Ps&... ps) -> typename sum_type<P, Ps...>::type
{
   return t + sum(ps...);
}

有了这个，你的测试代码现在可以工作了

std::cout << sum(5, 10.0, 22.2, 33, 21.3, 55) << std::endl;

146.5

Answer 6

正确的做法：

#include <utility>

template <typename... Args>
struct sum_type;

template <typename... Args>
using sum_type_t = typename sum_type<Args...>::type;

template <typename A>
struct sum_type<A> {
    using type = decltype( std::declval<A>() );
};

template <typename A, typename B>
struct sum_type<A, B> {
    using type = decltype( std::declval<A>() + std::declval<B>() );
};

template <typename A, typename B, typename... Args>
struct sum_type<A, B, Args...> {
    using type = sum_type_t< sum_type_t<A, B>, Args... >;
};

template <typename A>
sum_type_t<A> sum(A &&a)
{
    return (std::forward<A>(a));
}

template <typename A, typename B>
sum_type_t<A, B> sum(A &&a, B &&b)
{
    return (std::forward<A>(a) + std::forward<B>(b));
}

template <typename A, typename B, typename... C>
sum_type_t<A, B, C...> sum(A &&a, B &&b, C &&...args)
{
    return sum( sum(std::forward<A>(a), std::forward<B>(b)), std::forward<C>(args)... );
}

https://coliru.stacked-crooked.com/a/a5a0e8019e40b8ba

这完全保留了结果类型的操作（甚至是 r 值引用）。 操作顺序很自然： (((a+b)+c)+d) 。

Answer 7

对于 C++17：

template <class... P>
auto sum(const P... p){
    return (p + ...);
}

int main()
{
    std::cout << sum(1, 3.5, 5) << std::endl;
    return EXIT_SUCCESS;
}

阅读折叠表达式。