Как суммировать элементы вектора 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, он будет накапливать целые, даже если вектор имеет float. Если вы суммируете числа с плавающей запятой, измените 0на 0.0или 0.0f(благодаря nneonneo). Смотрите также решение C ++ 11 ниже.

C ++ 11 и выше

2. б. Автоматическое отслеживание типа вектора даже в случае будущих изменений:

   #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 на основе диапазона (спасибо Роджеру Пейту):

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

Самый простой способ заключается в использовании std:accumuateв vector<int> A:

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

Prasoon уже предложил множество различных (и хороших) способов сделать это, ни один из которых не нужно повторять здесь. Однако я хотел бы предложить альтернативный подход к скорости.

Если вы собираетесь делать это совсем немного, вы можете рассмотреть вопрос о «юге причислять» свой вектор так, чтобы сумма элементов сохраняются отдельно (не на самом деле к югу от причислять вектор, сомнительные из - за отсутствие виртуальный деструктор - я говорю больше о классе, который содержит сумму и вектор внутри него, 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с лямбда-выражением, используя обратные итераторы:

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, упомянутый в другом месте, и имеет такое же преимущество ясности в более сложных ситуациях по сравнению с функторами с состоянием, используемыми с накоплением или 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;