Come riassumere elementi di un vettore C ++?

Quali sono i buoni modi per trovare la sum di tutti gli elementi in un std::vector ?

Supponiamo che io abbia un vettore vettoriale std::vector vector con alcuni elementi in esso. Ora voglio trovare la sum di tutti gli elementi. Quali sono i diversi modi per lo stesso?

In realtà ci sono parecchi metodi.

 int sum_of_elems = 0; 

C ++ 03

  1. Classico per loop:

     for(std::vector::iterator it = vector.begin(); it != vector.end(); ++it) sum_of_elems += *it; 
  2. Utilizzando un algoritmo standard:

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

    bandiera

    Stai attento con l’accumulo. Il tipo dell’ultimo argomento è usato non solo per il valore iniziale, ma anche per il tipo del risultato. Se metti un int lì, accumulerà int i anche se il vettore è fluttuante. Se si sumno i numeri a virgola mobile, cambiare da 0 a 0.0 o 0.0f (grazie a nneonneo).

C ++ 11 e versioni successive

  1. Utilizzando std::for_each :

     std::for_each(vector.begin(), vector.end(), [&] (int n) { sum_of_elems += n; }); 
  2. Utilizzo di un loop per cicli (grazie a Roger Pate):

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

Prasoon ha già offerto una serie di diversi (e buoni) modi per farlo, nessuno dei quali ha bisogno di ripetere qui. Vorrei comunque suggerire un approccio alternativo per la velocità.

Se lo farai un bel po ‘, dovresti prendere in considerazione la “sottoclass” del tuo vettore in modo tale che una sum di elementi sia mantenuta separatamente (non in realtà un vettore di sottoclass che è incerto a causa della mancanza di un distruttore virtuale: sto parlando più di una class che contiene la sum e un vettore al suo interno, has-a piuttosto che is-a e fornisce i metodi vettoriali).

Per un vettore vuoto, la sum è impostata su zero. Ad ogni inserimento nel vettore, aggiungi l’elemento inserito nella sum. Ad ogni eliminazione, sottrarla. Fondamentalmente, tutto ciò che può cambiare il vettore sottostante viene intercettato per assicurare che la sum sia mantenuta coerente.

In questo modo, hai un efficiente metodo O (1) per “calcolare” la sum in qualsiasi momento (basta restituire la sum attualmente calcasting). L’inserimento e la cancellazione richiederanno un po ‘più tempo mentre modifichi il totale e dovresti prendere in considerazione questo hit prestazionale.

I vettori in cui la sum è necessaria più spesso di quanto il vettore è cambiato sono quelli che possono beneficiare di questo schema, poiché il costo del calcolo della sum viene ammortizzato su tutti gli accessi. Ovviamente, se hai bisogno solo della sum ogni ora e il vettore sta cambiando tremila volte al secondo, non sarà adatto.

Qualcosa di simile sarebbe sufficiente:

 class UberVector: private Vector vec; private int sum; public UberVector(): vec = new Vector(); 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 

Ovviamente, è uno pseudo-codice e potresti voler avere un po 'più di funzionalità, ma mostra il concetto di base.

Perché eseguire la sumtoria in avanti quando puoi farlo all’indietro ? Dato:

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

Possiamo usare gli abbonamenti, contare all’indietro:

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

Possiamo usare il controllo di intervallo “subscripting”, contando all’indietro (nel caso):

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

Possiamo usare gli iteratori inversi in un ciclo for:

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

Possiamo usare gli iteratori forward, iterando all’indietro, in un ciclo for (oooh, ingannevole!):

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

Possiamo usare accumulate con iteratori inversi:

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

Possiamo usare for_each con un’espressione lambda usando iteratori inversi:

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

Quindi, come puoi vedere, ci sono altrettanti modi per sumre il vettore all’indietro, in quanto ci sono sumtori di vettori in avanti, e alcuni di questi sono molto più eccitanti e offrono molte più opportunità per errori off-by-one.

 #include int sum = boost::accumulate(vector, 0); 

Solo C ++ 0x:

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

Questo è simile al BOOST_FOREACH menzionato altrove e ha lo stesso beneficio di chiarezza in situazioni più complesse, rispetto ai funtori con stato utilizzati con accumulate o for_each.

Sono un utente Perl, un gioco che abbiamo è quello di trovare tutti i modi diversi per incrementare una variabile … non è molto diverso qui. La risposta a quanti modi per trovare la sum degli elementi di un vettore in C ++ è probabilmente an infinity

I miei 2 centesimi:

Usando BOOST_FOREACH, per liberarci della brutta syntax iteratore:

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

iterando su indici (veramente facile da leggere).

 int i, sum = 0; for (i=0; i 

Quest'altro è distruttivo, accedendo al vettore come una pila:

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

Si può anche usare std :: valarray come questo

 #include #include #include int main() { std::vector seq{1,2,3,4,5,6,7,8,9,10}; std::valarray seq_add {seq.data(), seq.size()}; std::cout << "sum = " << seq_add.sum() << "\n"; return 0; } 

Alcuni potrebbero non trovare questo modo efficiente poiché la dimensione di valarray deve essere grande quanto la dimensione del vettore e l'inizializzazione del valarray richiederà anche del tempo.

In tal caso non usarlo e prendilo come un altro modo di riassumere la sequenza.

Grazie

Ho trovato il modo più semplice per trovare la sum di tutti gli elementi di un vettore

 #include  #include using namespace std; int main() { vectorv(10,1); int sum=0; for(int i=0;i 

In questo programma, ho un vettore di dimensione 10 e sono inizializzato di 1. Ho calcolato la sum con un semplice ciclo come nella matrice.