也可以像这样使用std::valarray<T>

#include<iostream>
#include<vector>
#include<valarray>

int main()
{
    std::vector<int> seq{ 1,2,3,4,5,6,7,8,9,10 };
    std::valarray<int> seq_add{ seq.data(), seq.size() };
    std::cout << "sum = " << seq_add.sum() << "\n";

    return 0;
}

有些人可能不觉得这种方法有效，因为valarray的大小需要和vector的大小一样大，并且初始化valarray也需要时间。

在这种情况下，不要使用它，把它作为另一种对序列求和的方式。

Std::accumulate可能有溢出问题，所以最好的方法是对较大的数据类型变量进行基于范围的积累，以避免溢出问题。

long long sum = 0;
for (const auto &n : vector)
  sum += n;

然后使用static_cast<>进一步向下转换为适当的数据类型。

实际上有相当多的方法。

int sum_of_elems = 0;

c++ 03

Classic for loop: for(std::vector<int>::iterator it = vector.begin(); it != vector.end(); ++it) sum_of_elems += *it; Using a standard algorithm: #include <numeric> sum_of_elems = std::accumulate(vector.begin(), vector.end(), 0); Important Note: The last argument's type is used not just for the initial value, but for the type of the result as well. If you put an int there, it will accumulate ints even if the vector has float. If you are summing floating-point numbers, change 0 to 0.0 or 0.0f (thanks to nneonneo). See also the C++11 solution below.

c++ 11及以上版本

b.即使将来发生变化，也会自动跟踪vector类型: # include <数字> Sum_of_elems = std::accumulate(vector.begin()， vector.end()， decltype(向量)::value_type (0)); 利用std:: for_each: std:: for_each (vector.begin (), vector.end (), [&] (int n) { Sum_of_elems += n; })； 使用基于范围的for循环(感谢Roger Pate): For (auto& n: vector) Sum_of_elems += n;

c++ 17及以上版本

使用std::reduce，它也照顾到结果类型，例如，如果你有std::vector<int>，你得到int作为结果。如果你有std::vector<float>，你得到float。或者如果你有std::vector<std::string>，你得到std::string(所有字符串连接)。很有趣，不是吗? 自动结果= std::reduce(v.begin()， v.end()); 这个函数还有其他重载，你甚至可以并行运行，如果你有一个大的集合，你想快速得到结果。

最简单的方法是使用std:accumulate of a vector<int> a:

#include <numeric>
cout << accumulate(A.begin(), A.end(), 0);

既然可以倒着做求和，为什么还要往前做呢?考虑到:

std::vector<int> v;     // vector to be summed
int sum_of_elements(0); // result of the summation

我们可以使用下标，向后计数:

for (int i(v.size()); i > 0; --i)
    sum_of_elements += v[i-1];

我们可以使用范围检查的“下标”，向后计数(以防万一):

for (int i(v.size()); i > 0; --i)
    sum_of_elements += v.at(i-1);

我们可以在for循环中使用反向迭代器:

for(std::vector<int>::const_reverse_iterator i(v.rbegin()); i != v.rend(); ++i)
    sum_of_elements += *i;

我们可以在for循环中使用前向迭代器，向后迭代(哦，很棘手!):

for(std::vector<int>::const_iterator i(v.end()); i != v.begin(); --i)
    sum_of_elements += *(i - 1);

我们可以对反向迭代器使用accumulate:

sum_of_elems = std::accumulate(v.rbegin(), v.rend(), 0);

我们可以使用反向迭代器将for_each与lambda表达式一起使用:

std::for_each(v.rbegin(), v.rend(), [&](int n) { sum_of_elements += n; });

所以，正如你所看到的，向后求和的方法和正向求和的方法一样多，其中一些更令人兴奋，并且提供了更大的机会出现差1的错误。

#include<boost/range/numeric.hpp>
int sum = boost::accumulate(vector, 0);