Elle yazılmış döngüler için algoritmaları mı tercih ediyorsunuz?

Aşağıdakilerden hangisini daha okunabilir buluyorsunuz? Elle yazılmış döngü:

for (std::vector<Foo>::const_iterator it = vec.begin(); it != vec.end(); ++it)
{
    bar.process(*it);
}

Veya algoritma çağırma:

#include <algorithm>
#include <functional>

std::for_each(vec.begin(), vec.end(),
              std::bind1st(std::mem_fun_ref(&Bar::process), bar));

Ben std::for_eachgerçekten buna değer olup olmadığını merak ediyorum , böyle basit bir örnek verilen çok fazla kod gerektirir.

Bu konudaki düşünceleriniz neler?

Lambdaların getirilmesinin bir nedeni var ve bunun nedeni Standart Komite'nin bile ikinci formun berbat olduğunu kabul etmesi. C ++ 0x ve lambda desteği alana kadar ilk formu kullanın.

Her zaman ne yapmak istediğinizi en iyi açıklayan değişkeni kullanın . Yani

Her öğe için xde vecyapın bar.process(x).

Şimdi örnekleri inceleyelim:

std::for_each(vec.begin(), vec.end(),
              std::bind1st(std::mem_fun_ref(&Bar::process), bar));

Biz var for_eachorada da - yippeh . [begin; end)Üzerinde çalışmak istediğimiz ürün yelpazemiz var .

Prensip olarak, algoritma çok daha açıktı ve bu nedenle elle yazılmış herhangi bir uygulamaya göre tercih edilebilirdi. Ama sonra ... Bağlayıcılar? Memfun? Temelde bir C ++ interna nasıl üye fonksiyonu ele almak için? Görevim için onları umursamıyorum ! Ben de bu ayrıntılı, ürkütücü sözdiziminden muzdarip olmak istemiyorum.

Şimdi diğer olasılık:

for (std::vector<Foo>::const_iterator it = vec.begin(); it != vec.end(); ++it)
{
    bar.process(*it);
}

Kabul edersek, bu tanımak için yaygın bir örüntüdür, ama ... yineleyiciler oluşturmak, döngü oluşturmak, arttırma, kayıttan kaldırma. Bunlar da görevimi yerine getirmek için umursamadığım şeyler .

Kuşkusuz, ilk çözümden daha iyi gözüküyor (en azından, döngü gövdesi esnek ve oldukça açık), ancak yine de, gerçekten o kadar büyük değil . Daha iyi bir imkanımız yoksa bunu kullanacağız, ama belki de ...

En iyi yol?

Şimdi geri dönelim for_each. Yapılması gereken operasyonda tam anlamıyla söylemek for_each ve esnek olmak harika olmaz mıydı ? Neyse ki, C ++ 0x lambdas'dan beri

for_each(v.begin(), v.end(), [&](const Foo& x) { bar.process(x); })

Birçok ilgili duruma soyut, genel bir çözüm bulduğumuza göre, bu özel durumda, mutlak bir # 1 favori olduğunu belirtmek gerekir :

foreach(const Foo& x, vec) bar.process(x);

Gerçekten bundan daha net olamaz. Neyse ki, C ++ 0x benzer benzer bir sözdizimi yerleşiktir !

Çünkü bu okunamıyor mu?

for (unsigned int i=0;i<vec.size();i++) {
{
    bar.process(vec[i]);
}

genel olarak, ilk form, wat arka planı ne olursa olsun, for-döngüsünün ne olduğunu bilen herkes tarafından okunabilir.

ayrıca genel olarak, ikincisi o kadar okunabilir değil: for_each'un ne yaptığını bulmak yeterince kolay, ama daha önce hiç görmediyseniz std::bind1st(std::mem_fun_refanlamak zor.

Aslında, C ++ 0x ile bile, for_eachçok sevgi alacak emin değilim .

for(Foo& foo: vec) { bar.process(foo); }

Çok daha okunabilir.

Algoritmalar hakkında sevmediğim tek şey (C ++ 'da) yineleyiciler üzerinde muhakeme yapmaktır, çok ayrıntılı ifadeler yapar.

Bir functor olarak bar yazmış olsaydınız, çok daha basit olurdu:

// custom functor
class Bar
{    public: void operator()(Foo& value) { /* STUFF */ }
};


std::for_each(vec.begin(), vec.end(), Bar());

Burada kod oldukça okunabilir.

İkincisini tercih ederim çünkü temiz ve temiz. Aslında diğer birçok dilin bir parçası ama C ++ 'da kütüphanenin bir parçası. Gerçekten önemli değil.

Şimdi bu sorun aslında C ++ özgü değildir, iddia ediyorum.

Mesele şu ki, bazı işlevleri başka bir işleve geçirmek döngülerin yerini almak değildir . Hemen aklıma gelen ziyaretçi ve gözlemci
gibi işlevsel programlama ile çok doğal hale gelen bazı kalıpları basitleştirmesi gerekiyor . Birinci dereceden işlevleri olmayan dillerde (Java muhtemelen en iyi örnektir), bu tür yaklaşımlar her zaman belirli bir arayüzün uygulanmasını gerektirir, bu da oldukça verbous ve gereksizdir.

Diğer dillerde çok gördüğüm yaygın bir kullanım:

someCollection.forEach(someUnaryFunctor);

Bunun avantajı someCollection, aslında nasıl uygulandığını veya ne yaptığını someUnaryFunctorbilmemeniz gerektiğidir. Bilmeniz gereken tek şey, forEachyönteminin koleksiyonun tüm öğelerini yineleyerek verilen işleve geçireceğidir.

Şahsen, eğer pozisyondaysanız, tekrarlamak istediğiniz veri yapısı ve her tekrarlama adımında ne yapmak istediğiniz hakkında tüm bilgilere sahip olmak için, o zaman fonksiyonel bir yaklaşım, özellikle bir dilde, şeyleri aşırı karmaşıklaştırır, bu görünüşte oldukça sıkıcı.

Ayrıca, fonksiyonel yaklaşımın daha yavaş olduğunu unutmayın, çünkü belirli bir maliyetle gelen ve for döngüsünde bulunmadığınız çok fazla çağrınız var.

Burada sorun for_eachgerçekten bir algoritma değil, sadece elle yazılmış bir döngü yazmak için sadece farklı (ve genellikle daha düşük bir yol) olduğunu düşünüyorum. bu açıdan en az kullanılan standart algoritma olmalıdır ve evet muhtemelen for döngüsü de kullanabilirsiniz. ancak başlıktaki öneri, daha spesifik kullanımlar için uyarlanmış birkaç standart algoritma olduğu için hala geçerlidir.

İstediğinizi daha sıkı yapan bir algoritma olduğunda, evet, elle yazılmış döngüler yerine algoritmaları tercih etmelisiniz. Burada bariz örnekler ile sıralama vardır sortya stable_sortya ile arama lower_bound, upper_boundya da equal_range, ancak bunların çoğu onlar bir el kodlu döngü üzerinde kullanılması tercih olduğu kimi durum var.

Bu küçük kod parçacığı için, her ikisi de bana eşit olarak okunabilir. Genel olarak, manuel döngüler hataya eğilimli buluyorum ve algoritmalar kullanmayı tercih ediyorum, ancak gerçekten somut bir duruma bağlı.