Bir C ++ vektörünün elemanlarını nasıl özetleyebilirim?

A'daki tüm öğelerin toplamını bulmanın iyi yolları nelerdir std::vector?

std::vector<int> vectorİçinde birkaç element bulunan bir vektörüm olduğunu varsayalım . Şimdi tüm elementlerin toplamını bulmak istiyorum. Aynı şeyin farklı yolları nelerdir?

Aslında birkaç yöntem var.

int sum_of_elems = 0;

C ++ 03

1. Döngü için klasik:

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

2. Standart bir algoritma kullanma:

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

   Önemli Not: Son bağımsız değişkenin türü yalnızca başlangıç ​​değeri için değil , sonucun türü için de kullanılır. Buraya bir int koyarsanız, vektör yüzer olsa bile ints biriktirir. Eğer kayan noktalı sayılar, değişim toplanmasıyla varsa 0etmek 0.0veya 0.0f(nneonneo sayesinde). Ayrıca aşağıdaki C ++ 11 çözümüne bakın.

C ++ 11 ve üstü

2. b. Gelecekteki değişikliklerde bile vektör türünü otomatik olarak takip etme:

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

3. Kullanma std::for_each:

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

4. Döngü için aralık tabanlı kullanma (Roger Pate sayesinde):

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

En kolay yolu kullanmaktır std:accumuatea vector<int> A:

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

Prasoon zaten bunu yapmanın farklı (ve iyi) yollarını teklif etti, bunların hiçbirinin burada tekrarlanması gerekmez. Ancak hız için alternatif bir yaklaşım önermek istiyorum.

Bunu biraz yapacaksanız, vektörünüzü "alt sınıflandırma" olarak değerlendirmek isteyebilirsiniz, böylece bir dizi öğe ayrı ayrı korunur ( aslında bir eksiklik nedeniyle iffy olan alt sınıflandırma vektörü değil) sanal yıkıcı - Ben toplamını ve içindeki bir vektör içeren bir sınıfın daha bahsediyorum has-aziyadeis-a ) ve vektör benzeri yöntemlerle sağlar.

Boş bir vektör için, toplam sıfıra ayarlanır. Vektöre yapılan her eklemede, eklenen öğeyi toplama ekleyin. Her silme işleminde çıkartın. Temel olarak, toplam vektörü değiştirebilecek her şey , toplamın tutarlı kalmasını sağlamak için durdurulur.

Bu şekilde, toplamı herhangi bir zamanda "hesaplamak" için çok verimli bir O (1) yönteminiz olur (sadece hesaplanan toplamı döndürün). Ekleme ve silme, toplamı ayarladıkça biraz daha uzun sürer ve bu performans isabetini dikkate almanız gerekir.

Toplamın vektöre göre daha sık ihtiyaç duyulduğu vektörler, bu şemadan yararlanma olasılığı yüksek olanlardır, çünkü toplamı hesaplama maliyeti tüm erişimlerde amortismana tabi tutulur. Açıkçası, sadece saatte bir toplama ihtiyacınız varsa ve vektör saniyede üç bin kez değişiyorsa, uygun olmayacaktır.

Böyle bir şey yeterli olacaktır:

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

Açıkçası, bu sahte kod ve biraz daha fazla işlevselliğe sahip olmak isteyebilirsiniz, ancak temel konsepti gösterir.

Geriye doğru yapabildiğinizde toplamı neden ileriye taşıyorsunuz ? Verilen:

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

Aboneliği geriye doğru sayarak kullanabiliriz:

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

Aralık kontrollü "abonelik" i geriye doğru sayarak kullanabiliriz (her ihtimale karşı):

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

For döngüsünde ters yineleyiciler kullanabiliriz:

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

İleri döngüleri geriye doğru yineleyerek bir for döngüsü (oooh, tricky!)

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

accumulateTers yineleyicilerle birlikte kullanabiliriz :

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

for_eachTers yineleyiciler kullanarak bir lambda ifadesi ile kullanabiliriz :

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

Gördüğünüz gibi, vektörü ileri doğru toplamak için vektörün geriye doğru toplanmasının birçok yolu vardır ve bunların bazıları çok daha heyecan vericidir ve birebir hatalar için çok daha fazla fırsat sunar.

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

Bir de kullanabilir std::valarray<T>böyle

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

Bazıları bu şekilde verimli bulamayabilir, çünkü valarrayihtiyaç büyüklüğü vektörün büyüklüğü kadar büyük olmalıdır ve başlatma valarrayda zaman alacaktır.

Bu durumda, kullanmayın ve diziyi özetlemenin başka bir yolu olarak almayın.

Yalnızca C ++ 0x:

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

Bu, başka bir yerde bahsedilen BOOST_FOREACH ile benzerdir ve birikim veya for_each ile kullanılan durumsal işlevlere kıyasla daha karmaşık durumlarda aynı netlik avantajına sahiptir.

Ben bir Perl kullanıcısıyım, sahip olduğumuz bir oyun, bir değişkeni artırmak için her farklı yolu bulmak ... burada gerçekten farklı değil. C ++ 'da bir vektörün elemanlarının toplamını bulmanın kaç yolunun cevabı muhtemelenan infinity ...

2 sentim:

Çirkin yineleyici sözdiziminden kurtulmak için BOOST_FOREACH kullanma:

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

endeksler üzerinde yineleme (okumak gerçekten kolay).

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

Bu diğeri yıkıcıdır, vektöre yığın gibi erişir:

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

Bir vektörün tüm öğelerinin toplamını bulmanın en kolay yolunu buldum

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

}

Bu programda, 10 büyüklüğünde bir vektör var ve 1 ile başlatılır. Toplamı dizi gibi basit bir döngü ile hesapladım.

Kolay. C ++ 11, bir vektörün elemanlarını özetlemek için kolay bir yol sağlar.

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