为什么总和是0？

Question

我正在尝试创建一个通用的求和函数模板。此模板为left associative。下面是我的实现

    int result=0;
template <typename D, typename T>
const T &sum_helper(const D &d, const T &v) {
    result=result+v;
    return result;
}
int pass(...){}

template <typename D, typename T1, typename... Ts>
auto sum_helper(const D &d, const T1 &v1, const Ts &... params) -> decltype(v1 + sum_helper(d, params...)) {
    return v1 + sum_helper(d, params... );
}

class A {};

template <typename... Ns> 
struct seq {};

template <typename... Ts>
auto sum(const Ts &... params) -> decltype(sum_helper(A(), params...)) 
{
    return  pass((sum_helper(seq<Ts...>(),params)) ...,1);

}

但是当我像sum(1,2,3,4) 这样称呼它时，它总是输出0。怎么了？我知道应该更正pass。但是有什么办法可以改正呢？

Answer 1

原始答案不起作用，因为尾随返回类型在其声明点之前使用了重载。在知道函数的返回类型之前，也不可能转发声明函数。所以我们需要一个辅助结构。这是工作的（不幸的是现在非常复杂）版本：

#include <utility>

template <typename...>
struct sum_impl;

/* This is the base case */
template <typename T1, typename T2>
struct sum_impl<T1, T2>
{
    typedef decltype(std::declval<const T1&>() + std::declval<const T2&>()) result_type;

    static result_type doit(const T1& v1, const T2& v2)
    {
        return v1 + v2;
    }
};

/* And here is the recursive definition for left-associativity */
template <typename T1, typename T2, typename... Ts>
struct sum_impl<T1, T2, Ts...>
{
    typedef decltype(std::declval<const T1&>() + std::declval<const T2&>()) step_type;
    typedef typename sum_impl<step_type, Ts...>::result_type result_type;

    static result_type doit(const T1& v1, const T2& v2, const Ts&... rest)
    {
        return sum_impl<step_type, Ts...>::doit(v1 + v2, rest...);
    }
};

template <typename... Ts>
typename sum_impl<Ts...>::result_type sum(const Ts&... args)
{
    return sum_impl<Ts...>::doit(args...);
}

演示：http://ideone.com/jMwgLz

---

这是一个保留 Named 答案的简单性但保留关联性的版本：

/* not really needed, unless someone wants to call sum with only a single argument */
template <typename T>
T sum(const T& v)
{
    return v;
}

/* This is the base case */
template <typename T1, typename T2>
auto sum(const T1& v1, const T2& v2) -> decltype( v1 + v2 )
{
    return v1 + v2;
}

/* And here is the recursive definition for left-associativity */
template <typename T1, typename T2, typename... Ts>
auto sum(const T1& v1, const T2& v2, const Ts&... rest) -> decltype( sum(v1 + v2, rest...) )
{
    return sum(v1 + v2, rest... );
}

Answer 2

这是一个更简单的解决方案：

#include <iostream>

using namespace std;

template <typename T1>
auto _sum(T1 & _ret, const T1 & _t1) -> T1
{
    _ret += _t1;
    return _ret;
}

template <typename T1, typename... Ts>
auto _sum(T1 & _ret, const T1 & _t1, const Ts &... params) -> T1 
{
    _ret += _t1;
    return _sum(_ret, params...);
}

template <typename T1, typename... Ts>
auto sum(const T1 & _t1, const Ts &... params) -> T1 
{
    T1 ret = _t1;
    return _sum(ret, params...);    
}

int main()
{
    cout << sum(1, 2, 3, 4, 5) << endl;
    return 0;
}

Answer 3

但是当我像 sum(1,2,3,4) 一样调用它时，它总是输出 0。怎么了？

那是因为pass 没有返回任何东西，所以你这里有 未定义的行为，因为你正在流出一个非 void 函数而没有返回任何东西。

我不知道你为什么在这里需要pass

return  pass((sum_helper(seq<Ts...>(),params)) ...,1);

---

您可以扩展可变参数并将它们直接发送到sum_helper。像这样

return  sum_helper(seq<Ts...>(),params...);

---

---

但是更简单的版本会是

template <typename T>
T sum(const T& v) {
    return v;
}

template <typename T1, typename T2>
auto sum(const T1& v1, const T2& v2) -> decltype( v1 + v2) {
    return v1 + v2;
}

template <typename T1, typename T2, typename... Ts>
auto sum(const T1& v1, const T2& v2, const Ts&... rest) -> decltype( v1 + v2 + sum(rest...) ) {
    return v1 + v2 + sum(rest... );
}

int main() {
    cout << sum(1,2,3,4);    
}

---

Rollie 的回答提供了一个更简单的版本。