如何总结C ++向量的元素？

找到元素中所有元素之和的好方法是什么std::vector什么？

假设我有一个std::vector<int> vector包含几个元素的向量。现在，我想找到所有元素的总和。相同的不同方式有哪些？

其实有很多方法。

int sum_of_elems = 0;

C ++ 03

1. 经典的循环：

   for(std::vector<int>::iterator it = vector.begin(); it != vector.end(); ++it)
       sum_of_elems += *it;

2. 使用标准算法：

   #include <numeric>
   
   sum_of_elems = std::accumulate(vector.begin(), vector.end(), 0);

   重要说明：最后一个参数的类型不仅用于初始值，还用于结果的类型。如果在其中放置一个int，即使向量具有浮点数，它也会累积int。如果要对浮点数求和，请更改0为0.0或0.0f（感谢nneonneo）。另请参见下面的C ++ 11解决方案。

C ++ 11及更高版本

2. b。即使在将来发生更改时，也会自动跟踪向量类型：

   #include <numeric>
   
   sum_of_elems = std::accumulate(vector.begin(), vector.end(),
                                  decltype(vector)::value_type(0));

3. 使用std::for_each：

   std::for_each(vector.begin(), vector.end(), [&] (int n) {
       sum_of_elems += n;
   });

4. 使用基于范围的for循环（感谢Roger Pate）：

   for (auto& n : vector)
       sum_of_elems += n;

最简单的方法是使用std:accumuate的vector<int> A：

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

普拉松（Prasoon）已经提供了许多不同的方法来实现此目的，在此无需赘述。我想提出一种替代的速度方法。

如果您要这样做很多，您可能需要考虑对向量进行“子分类”，以便元素的总和被单独维护（实际上不是对向量进行子分类，由于缺少向量，所以很难做到这一点）虚拟析构函数-我说的是更多的类，其中包含sum和一个矢量，has-a而不是is-a，并提供类似于矢量的方法。

对于空向量，总和设置为零。在向量的每次插入中，将要插入的元素添加到总和中。每次删除时，将其减去。基本上什么都可以可以改变基础向量的都会被拦截以确保总和保持一致。

这样，您就有了一种非常有效的O（1）方法，可以在任何时间点“计算”总和（只需返回当前计算出的总和）。调整总数时，插入和删除操作将花费稍长的时间，因此应考虑到这种性能影响。

需要矢量的总和比更改矢量更频繁的矢量是可能从该方案中受益的矢量，因为计算总和的成本在所有访问中均摊销。显然，如果您每小时仅需要总和，并且向量每秒变化三千次，则不合适。

这样的事情就足够了：

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

显然，这是伪代码，您可能需要更多功能，但是它显示了基本概念。

为什么可以向后进行求和？鉴于：

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; });

因此，正如您所看到的，向后求和向量与向后求和向量的方法之多，其中一些更令人兴奋，并且为一度失误提供了更大的机会。

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

一个人也可以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需求的大小必须与向量的大小一样大，因此某些方法可能找不到这种方法有效，初始化valarray也将花费一些时间。

在这种情况下，请不要使用它，并将其作为总结序列的另一种方法。

仅C ++ 0x：

vector<int> v; // and fill with data
int sum {}; // or = 0 ... :)
for (int n : v) sum += n;

这与其他地方提到的BOOST_FOREACH相似，并且在更复杂的情况下具有相同的优点，与与accumate或for_each一起使用的有状态函子相比。

我是Perl用户，我们要做的游戏是找到增加变量的各种不同方法……在这里并没有什么不同。在C ++中找到向量元素之和的多少方法的答案可能是an infinity...

我的2美分：

使用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];
}

另一个是破坏性的，像堆栈一样访问向量：

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

我找到了找到向量所有元素之和的最简单方法

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

int main()
{
    vector<int>v(10,1);
    int sum=0;
    for(int i=0;i<v.size();i++)
    {
        sum+=v[i];
    }
    cout<<sum<<endl;

}

在此程序中，我有一个大小为10的向量，并由1初始化。我已经通过数组等简单循环计算了总和。

这很容易。C ++ 11提供了一种汇总向量元素的简便方法。

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