Як підсумувати елементи вектора C ++?

Які хороші способи знаходження суми всіх елементів у a 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. б. Автоматичне відстеження векторного типу навіть у разі майбутніх змін:

   #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 (auto& n : vector)
       sum_of_elems += n;

Найпростіший спосіб полягає у використанні std:accumuateв vector<int> A:

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

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

Якщо ви збираєтеся робити це зовсім небагато, ви можете розглянути «підкласифікацію» вашого вектора, щоб сума елементів підтримувалась окремо (а не насправді вектор підкласифікації, який є iffy через відсутність віртуальний деструктор - я кажу більше про клас, який містить суму і вектор всередині нього, 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 (oooh, хитро!):

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;