这很简单。c++ 11提供了一种简单的方法来对一个向量的元素求和。

sum = 0; 
vector<int> vec = {1,2,3,4,5,....}
for(auto i:vec) 
   sum+=i;
cout<<" The sum is :: "<<sum<<endl; 

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

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

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

prason已经提供了许多不同的(而且很好的)方法来做到这一点，这里没有一个需要重复。不过，我想建议另一种提高速度的方法。

如果你要经常这样做，你可能想要考虑“子类化”你的vector，这样元素的和就被分开维护(实际上不是子类化vector，因为缺少虚析构函数而存在问题——我说的更多的是一个包含和和和的类，has-a而不是is-a，并提供类似vector的方法)。

对于空向量，和设为零。每次插入向量时，将插入的元素加到和中。在每次删除时，减去它。基本上，任何可能改变底层向量的东西都会被拦截，以确保总和保持一致。

这样，您就有了一个非常有效的O(1)方法来“计算”任何时间点的和(只返回当前计算的和)。插入和删除将花费稍长的时间来调整总数，您应该考虑到这种性能影响。

如果向量的和比向量的改变更频繁，那么这些向量可能会从这个方案中受益，因为计算和的成本会在所有访问中摊销。显然，如果你只需要每小时求和，而向量每秒变化3000次，这是不合适的。

这样就足够了:

class UberVector:
    private Vector<int> vec
    private int sum

    public UberVector():
        vec = new Vector<int>()
        sum = 0

    public getSum():
        return sum

    public add (int val):
        rc = vec.add (val)
        if rc == OK:
            sum = sum + val
        return rc

    public delindex (int idx):
        val = 0
        if idx >= 0 and idx < vec.size:
            val = vec[idx]
        rc =  vec.delindex (idx)
        if rc == OK:
            sum = sum - val
        return rc

显然，这是伪代码，您可能希望有更多的功能，但它显示了基本概念。

我是一个Perl用户，我们有一个游戏是找到各种不同的方法来增加一个变量…这里没有什么不同。在c++中，有多少种方法可以求出一个向量元素的和，答案可能是无穷大……

我的观点是:

使用BOOST_FOREACH，摆脱丑陋的迭代器语法:

sum = 0;
BOOST_FOREACH(int & x, myvector){
  sum += x;
}

在索引上迭代(非常容易阅读)。

int i, sum = 0;
for (i=0; i<myvector.size(); i++){
  sum += myvector[i];
}

另一个是破坏性的，像访问堆栈一样访问vector:

while (!myvector.empty()){
   sum+=myvector.back();
   myvector.pop_back();
}

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

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

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