Wie fasse ich Elemente eines C ++ - Vektors zusammen?

Was sind die guten Möglichkeiten, um die Summe aller Elemente in a zu finden std::vector?

Angenommen, ich habe einen Vektor std::vector<int> vectormit einigen Elementen. Jetzt möchte ich die Summe aller Elemente finden. Was sind die verschiedenen Möglichkeiten für das gleiche?

Eigentlich gibt es einige Methoden.

int sum_of_elems = 0;

C ++ 03

1. Klassiker für Loop:

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

2. Verwenden eines Standardalgorithmus:

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

   Wichtiger Hinweis: Der Typ des letzten Arguments wird nicht nur für den Anfangswert verwendet, sondern auch für den Typ des Ergebnisses . Wenn Sie dort ein int einfügen, werden Ints akkumuliert, selbst wenn der Vektor float hat. Wenn Sie Gleitkommazahlen summieren, wechseln Sie 0zu 0.0oder0.0f (dank nneonneo). Siehe auch die C ++ 11-Lösung unten.

C ++ 11 und höher

2. b. Automatische Verfolgung des Vektortyps auch bei zukünftigen Änderungen:

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

3. Verwenden von std::for_each:

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

4. Verwenden einer bereichsbasierten for-Schleife (danke an Roger Pate):

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

Der einfachste Weg ist die Verwendung std:accumuatevon vector<int> A:

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

Prasoon hat bereits eine Reihe verschiedener (und guter) Möglichkeiten angeboten, von denen keine hier wiederholt werden muss. Ich möchte jedoch einen alternativen Ansatz für die Geschwindigkeit vorschlagen.

Wenn Sie vorhaben , dieses ziemlich viel zu tun, können Sie „sub-classing“ Ihr Vektor so dass eine Summe von Elementen zu prüfen , ist separat gepflegt (nicht eigentlich Unterklassierungsvektor, der iffy aufgrund des Fehlens von a virtueller Destruktor - Ich spreche eher von einer Klasse, die die Summe und einen Vektor enthält, has-aals von is-avektorähnlichen Methoden.

Für einen leeren Vektor wird die Summe auf Null gesetzt. Fügen Sie bei jeder Einfügung in den Vektor das einzufügende Element zur Summe hinzu. Subtrahieren Sie es bei jedem Löschen. Grundsätzlich alles abgefangen den zugrunde liegenden Vektor ändern kann, um sicherzustellen, dass die Summe konsistent bleibt.

Auf diese Weise haben Sie eine sehr effiziente O (1) -Methode zum "Berechnen" der Summe zu jedem Zeitpunkt (geben Sie einfach die aktuell berechnete Summe zurück). Das Einfügen und Löschen dauert etwas länger, wenn Sie die Gesamtsumme anpassen, und Sie sollten diesen Leistungseinbruch berücksichtigen.

Vektoren, bei denen die Summe häufiger benötigt wird als der Vektor geändert wird, profitieren wahrscheinlich von diesem Schema, da die Kosten für die Berechnung der Summe über alle Zugriffe abgeschrieben werden. Wenn Sie nur die Summe jede Stunde benötigen und sich der Vektor dreitausend Mal pro Sekunde ändert, ist dies natürlich nicht geeignet.

So etwas würde ausreichen:

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

Das ist natürlich Pseudocode und Sie möchten vielleicht etwas mehr Funktionalität, aber es zeigt das Grundkonzept.

Warum die Summierung vorwärts durchführen, wenn Sie sie rückwärts ausführen können ? Gegeben:

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

Wir können Subskription verwenden und rückwärts zählen:

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

Wir können bereichsüberprüfte "Subskriptionen" verwenden, die rückwärts zählen (nur für den Fall):

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

Wir können Reverse-Iteratoren in einer for-Schleife verwenden:

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

Wir können Vorwärtsiteratoren verwenden, die rückwärts in einer for-Schleife iterieren (oooh, knifflig!):

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

Wir können accumulatemit Reverse-Iteratoren verwenden:

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

Wir können for_eachmit einem Lambda-Ausdruck unter Verwendung von Umkehriteratoren verwenden:

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

Wie Sie sehen, gibt es also genauso viele Möglichkeiten, den Vektor rückwärts zu summieren wie den Vektor vorwärts, und einige davon sind viel aufregender und bieten weitaus größere Möglichkeiten für Fehler, die nacheinander auftreten.

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

Man kann auch verwendet werden, std::valarray<T>wie dies

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

Einige finden diesen Weg möglicherweise nicht effizient, da die Größe von valarrayso groß sein muss wie die Größe des Vektors, und die Initialisierung valarraywird ebenfalls Zeit in Anspruch nehmen.

Verwenden Sie es in diesem Fall nicht und nehmen Sie es als eine weitere Möglichkeit, die Sequenz zusammenzufassen.

Nur C ++ 0x:

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

Dies ähnelt dem an anderer Stelle erwähnten BOOST_FOREACH und hat den gleichen Vorteil der Klarheit in komplexeren Situationen im Vergleich zu Stateful-Funktoren, die mit accumulate oder for_each verwendet werden.

Ich bin ein Perl-Benutzer. Ein Spiel, das wir haben, besteht darin, alle Möglichkeiten zu finden, um eine Variable zu erhöhen. Das ist hier nicht wirklich anders. Die Antwort darauf, wie viele Möglichkeiten es gibt, die Summe der Elemente eines Vektors in C ++ zu finden, ist wahrscheinlich an infinity...

Meine 2 Cent:

Verwenden Sie BOOST_FOREACH, um sich von der hässlichen Iteratorsyntax zu befreien:

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

Iteration auf Indizes (sehr einfach zu lesen).

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

Dieser andere ist destruktiv und greift wie ein Stapel auf einen Vektor zu:

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

Ich habe den einfachsten Weg gefunden, die Summe aller Elemente eines Vektors zu finden

#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;

}

In diesem Programm habe ich einen Vektor der Größe 10 und werde mit 1 initialisiert. Ich habe die Summe durch eine einfache Schleife wie im Array berechnet.

Es ist leicht. C ++ 11 bietet eine einfache Möglichkeit, Elemente eines Vektors zusammenzufassen.

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