Neden dizi indeksleri yerine yineleyiciler kullanılır?

Aşağıdaki iki kod satırını alın:

for (int i = 0; i < some_vector.size(); i++)
{
    //do stuff
}

Ve bu:

for (some_iterator = some_vector.begin(); some_iterator != some_vector.end();
    some_iterator++)
{
    //do stuff
}

Bana ikinci yolun tercih edildiği söylendi. Neden tam olarak bu?

İlk form yalnızca vector.size () hızlı bir işlemse etkilidir. Bu, vektörler için geçerlidir, ancak listeler için geçerli değildir. Ayrıca, döngü içinde ne yapmayı planlıyorsunuz? Öğelere aşağıdaki gibi erişmeyi planlıyorsanız

T elem = some_vector[i];

o zaman kabın operator[](std::size_t)tanımladığı varsayımını yaparsınız . Yine, bu vektör için geçerlidir, ancak diğer kaplar için geçerli değildir.

Yineleyicilerin kullanımı sizi konteyner bağımsızlığına yaklaştırır . Rasgele erişim yeteneği veya hızlı size()işlem hakkında varsayımlar yapmıyorsunuz , yalnızca kapsayıcıda yineleyici özellikleri var.

Standart algoritmalar kullanarak kodunuzu daha da geliştirebilirsiniz. Neyi başarmaya çalıştığınıza bağlı olarak, kullanmayı tercih edebilirsiniz std::for_each(), std::transform()vb. Açık bir döngü yerine standart bir algoritma kullanarak tekerleği yeniden icat etmekten kaçınırsınız. Kodunuzun daha verimli (doğru algoritmanın seçildiği göz önüne alındığında), doğru ve yeniden kullanılabilir olması muhtemeldir.

Bu modern C ++ aşılama sürecinin bir parçası. Yineleyiciler çoğu kapsayıcıyı yinelemenin tek yoludur, bu yüzden vektörlerle bile kendinizi uygun zihniyete sokmak için kullanırsınız. Cidden, bunu yapmamın tek nedeni - Bir vektörü farklı bir kapla değiştirdiğimi sanmıyorum.

Dizi dizini daha okunabilir olduğunu düşünüyorum. Diğer dillerde kullanılan sözdizimi ve eski moda C dizileri için kullanılan sözdizimi ile eşleşir. Ayrıca daha az ayrıntılı. Derleyiciniz iyi ise verimlilik bir yıkama olmalı ve zaten önemli olduğu durumlar neredeyse yok.

Yine de, kendimi hala yineleyicileri vektörlerle sık sık kullanıyorum. Yineleyicinin önemli bir kavram olduğuna inanıyorum, bu yüzden yapabildiğim zaman onu tanıtıyorum.

çünkü kodunuzu some_vector listesinin belirli bir uygulamasına bağlamıyorsunuz. dizi indeksleri kullanırsanız, bu bir dizi dizi olmalıdır; yineleyiciler kullanırsanız, bu kodu herhangi bir liste uygulamasında kullanabilirsiniz.

Some_vector öğesinin bağlantılı listeyle uygulandığını düşünün. Daha sonra i-inci yerde bir öğe istemek, düğümler listesinde geçiş yapmak için i işlemlerinin yapılmasını gerektirir. Şimdi, yineleyici kullanırsanız, genel olarak konuşursak, mümkün olduğunca verimli olmak için elinden geleni yapacaktır (bağlantılı bir liste söz konusu olduğunda, geçerli düğüme bir işaretçi tutacak ve her yinelemede bir tek işlem).

Yani iki şey sağlar:

• Kullanım soyutlama: sadece bazı unsurları yinelemek istiyorsunuz, nasıl yapılacağını umursamıyorsunuz
• Verim

Ben burada şeytanlar savunucusu olacağım ve yineleyicileri tavsiye etmeyeceğim. Bunun ana nedeni, Masaüstü uygulama geliştirmeden oyun geliştirmeye kadar çalıştığım tüm kaynak kodlarım var ve yineleyicileri kullanmak zorunda değilim. İhtiyaç duyulmadıkları her zaman ve ikincisi, yineleyicilerle aldığınız gizli varsayımlar ve kod karmaşası ve hata ayıklama kabusları, hız gerektiren herhangi bir uygulamada kullanmamalarının en iyi örneğidir.

Sessizlik açısından bile bir karmaşa. Bu onlar yüzünden değil, sahnenin arkasındaki tüm takma adlar yüzünden. Standartlardan tamamen farklı bir şey yapan kendi sanal vektör veya dizi listenizi uygulamadığınızı nasıl bilebilirim? Çalışma zamanında şu anda ne tür olduğunu biliyor muyum? Bir operatörü aşırı yüklediniz mi, tüm kaynak kodunuzu kontrol etmek için zamanım yoktu. Cehennem STL'nin hangi sürümünü kullandığınızı bile biliyor muyum?

Yineleyicilerle karşılaştığınız bir sonraki sorun sızdıran soyutlamadır, ancak bunları ayrıntılı olarak tartışan çok sayıda web sitesi vardır.

Üzgünüm, yineleyicilerde herhangi bir nokta görmedim ve görmedim. Listeyi veya vektörü sizden uzaklaştırırlarsa, aslında ne zaman vektörü bilmelisiniz veya başa çıkmadığınız zaman listelemelisiniz, o zaman sadece gelecekte büyük hata ayıklama oturumları için kendinizi kuracaksınız.

Üzerinde yineleme yaparken vektöre öğe ekleyecek / kaldıracaksanız bir yineleyici kullanmak isteyebilirsiniz.

some_iterator = some_vector.begin(); 
while (some_iterator != some_vector.end())
{
    if (/* some condition */)
    {
        some_iterator = some_vector.erase(some_iterator);
        // some_iterator now positioned at the element after the deleted element
    }
    else
    {
        if (/* some other condition */)
        {
            some_iterator = some_vector.insert(some_iterator, some_new_value);
            // some_iterator now positioned at new element
        }
        ++some_iterator;
    }
}

Dizinler kullanıyorsanız, ekleme ve silme işlemlerini gerçekleştirmek için dizideki öğeleri yukarı / aşağı karıştırmanız gerekir.

Endişelerin Ayrılması

Yineleme kodunu döngünün 'temel' kaygısından ayırmak çok güzel. Neredeyse bir tasarım kararı.

Gerçekten de, indekse göre tekrarlamak sizi konteynerin uygulanmasına bağlar. Kaptan bir başlangıç ​​ve bitiş yineleyicisi istemek, döngü kodunun diğer kap tipleri ile kullanılmasını sağlar.

Ayrıca, bu std::for_eachşekilde, koleksiyona içleri hakkında bir şeyler sormak yerine ne yapmasını söylersiniz

0x standardı, bu yaklaşımı daha kolay hale getirecek kapanışları tanıtacak - örneğin Ruby'nin etkileyici gücüne bir göz atın [1..6].each { |i| print i; }...

Verim

Ancak belki de çok fazla denetlenen bir sorun, for_eachyaklaşımı kullanmanın yinelemeyi paralel hale getirme fırsatı vermesidir - intel iş parçacığı blokları kod bloğunu sistemdeki işlemci sayısı üzerinden dağıtabilir!

Not: algorithmsKütüphaneyi keşfettikten sonra , özellikle foreach, geliştiricilerinizi çıldırtacak gülünç küçük 'yardımcı' operatör yapıları yazarak iki veya üç ay geçirdim. Bu zamandan sonra, pragmatik bir yaklaşıma geri döndüm - küçük döngü gövdeleri artık hak etmiyor foreach:)

Bir yineleyiciler referans okumak gerekir kitap "Genişletilmiş STL" dir .

GoF, Yineleme modelinin sonunda, bu yineleme markası hakkında konuşan küçük bir paragrafa sahiptir; buna 'dahili yineleyici' denir. Buraya da bir göz atın .

Çünkü daha nesne yönelimlidir. eğer bir indeks ile tekrarlıyorsanız:

a) bu nesnelere talimat
verildiği b) bu ​​nesnelere bir indeks ile elde edilebileceği
c) indeks artışının her öğeye çarpacağı
d) bu indeks sıfırdan başlar

Bir yineleyici ile, temel uygulamanın ne olduğunu bilmeden "bana bununla çalışabilmem için her şeyi ver" diyorsunuz. (Java'da, bir dizin aracılığıyla erişilemeyen koleksiyonlar vardır)

Ayrıca, bir yineleyici ile, dizinin sınırlarından çıkma konusunda endişelenmenize gerek yok.

Yineleyiciler hakkında bir başka güzel şey, const tercihinizi ifade etmenize (ve uygulamanıza) daha iyi izin vermeleridir. Bu örnek, döngünüzün ortasında vektörü değiştirmemenizi sağlar:

for(std::vector<Foo>::const_iterator pos=foos.begin(); pos != foos.end(); ++pos)
{
    // Foo & foo = *pos; // this won't compile
    const Foo & foo = *pos; // this will compile
}

Tüm diğer mükemmel cevapların yanı sıra ... intvektörünüz için yeterince büyük olmayabilir. Bunun yerine, dizin oluşturmayı kullanmak istiyorsanız size_type, kapsayıcısı için şunu kullanın :

for (std::vector<Foo>::size_type i = 0; i < myvector.size(); ++i)
{
    Foo& this_foo = myvector[i];
    // Do stuff with this_foo
}

Muhtemelen şunu da göstermeliyim ki

std::for_each(some_vector.begin(), some_vector.end(), &do_stuff);

STL yineleyicileri çoğunlukla oradadır, böylece sort gibi STL algoritmaları kaptan bağımsız olabilir.

Bir vektördeki tüm girdilerin üzerinde döngü yapmak istiyorsanız, dizin döngü stilini kullanın.

Çoğu insan için daha az yazı yazmak ve ayrıştırmak daha kolaydır. C ++ şablon sihirli ile denize girmeden basit bir foreach döngüsüne sahip olsaydı iyi olurdu.

for( size_t i = 0; i < some_vector.size(); ++i )
{
   T& rT = some_vector[i];
   // now do something with rT
}
'

Bir vektör için çok fazla fark yarattığını düşünmüyorum. Daha okunabilir olduğunu düşündüğüm için bir indeks kullanmayı tercih ederim ve 6 öğeyi ileriye atlamak veya gerekirse geriye doğru atlamak gibi rastgele erişim yapabilirsiniz.

Ayrıca, döngü içindeki öğeye böyle bir referans yapmak istiyorum, böylece yerin etrafında çok fazla köşeli ayraç yok:

for(size_t i = 0; i < myvector.size(); i++)
{
    MyClass &item = myvector[i];

    // Do stuff to "item".
}

İleride bir noktada vektörü bir liste ile değiştirmeniz gerekebileceğini ve ayrıca STL düşkünlerine daha şık görüneceğini düşünüyorsanız, ancak başka bir neden düşünemiyorum.

İkinci form daha doğru yaptığınızı gösterir. Örneğinizde, i'nin değerini umursamıyorsunuz, gerçekten - istediğiniz tek şey yineleyicideki bir sonraki öğedir.

Bu cevabın konusu hakkında biraz daha bilgi edindikten sonra, bunun biraz fazla basitleştirildiğinin farkındayım. Bu döngü arasındaki fark:

for (some_iterator = some_vector.begin(); some_iterator != some_vector.end();
    some_iterator++)
{
    //do stuff
}

Ve bu döngü:

for (int i = 0; i < some_vector.size(); i++)
{
    //do stuff
}

Oldukça azdır. Aslında, bu şekilde döngü yapmanın sözdizimi beni büyütüyor gibi görünüyor:

while (it != end){
    //do stuff
    ++it;
}

Yineleyiciler oldukça güçlü bazı bildirici özelliklerin kilidini açar ve STL algoritmaları kitaplığıyla birleştirildiğinde dizi dizini yönetiminin kapsamı dışında oldukça güzel şeyler yapabilirsiniz.

Dizin oluşturma işlemi ek bir mulişlem gerektirir . Örneğin, için vector<int> vderleyici dönüştürür, v[i]içine &v + sizeof(int) * i.

Yineleme sırasında işlenecek öğenin sayısını bilmenize gerek yoktur. Sadece öğeye ihtiyacınız var ve yineleyiciler böyle şeyleri çok iyi yapıyorlar.

Henüz hiç kimse endekslerin bir avantajı gibi bitişik bir kapsayıcıya eklediğinizde geçersiz hale gelmemeleri std::vector, böylece yineleme sırasında kapsayıcıya öğeler ekleyebilirsiniz.

Bu, yineleyicilerle de mümkündür, ancak aramalısınız reserve()ve bu nedenle kaç öğe ekleyeceğinizi bilmeniz gerekir.

Birkaç iyi nokta zaten. Birkaç ek yorumum daha var:

1. C ++ standart kitaplığından bahsettiğimizi varsayarsak, "vektör", C-dizisi (rastgele erişim, contiguos bellek düzeni vb.) 'Some_container' demiş olsaydınız, yukarıdaki cevapların çoğu daha doğru olurdu (konteyner bağımsızlığı vb.).

2. Derleyici optimizasyonuna olan bağımlılıkları ortadan kaldırmak için, dizinindeki koddaki some_vector.size () yöntemini aşağıdaki gibi taşıyabilirsiniz:

   const size_t numElems = some_vector.size ();
   için (size_t i = 0; i 

3. Yineleyicileri her zaman önceden artırın ve artımları istisnai durumlar olarak ele alın.

std::vector<>Konteyner gibi kabul edilebilir ve endekslenebilir , sırayla konteynerden geçerek birini diğerine tercih etmek için iyi bir neden yoktur. Daha eski veya daha yeni görünen dizinlere sık sık başvurmanız gerekiyorsa, dizinlenmiş sürüm daha uygundur.

Genel olarak, yineleyicilerin kullanılması tercih edilir çünkü algoritmalar bunlardan yararlanır ve davranış yineleyicinin tipi değiştirilerek kontrol edilebilir (ve dolaylı olarak belgelenebilir). Dizi konumları yineleyiciler yerine kullanılabilir, ancak sözdizimsel fark ortaya çıkacaktır.

Her ifadeyi sevmediğim için yineleyicileri kullanmıyorum. Birden fazla iç döngüye sahipken, tüm yerel değerleri ve yineleyici adlarını da hatırlamak zorunda kalmadan küresel / üye değişkenleri takip etmek yeterince zordur. Yararlı bulduğum şey, farklı durumlar için iki dizi indeks kullanmaktır:

for(int i=0;i<anims.size();i++)
  for(int j=0;j<bones.size();j++)
  {
     int animIndex = i;
     int boneIndex = j;


     // in relatively short code I use indices i and j
     ... animation_matrices[i][j] ...

     // in long and complicated code I use indices animIndex and boneIndex
     ... animation_matrices[animIndex][boneIndex] ...


  }

Hatta "animation_matrices [i]" gibi bazı rastgele "anim_matrix" -named-iterator gibi şeyleri kısaltmak istemiyorum, çünkü o zaman bu değerin hangi diziden kaynaklandığını açıkça göremiyorsunuz.

• Metale yakın olmak / uygulama detaylarına güvenmemek isterseniz yineleyicileri kullanmayın .
• Geliştirme sırasında düzenli olarak bir koleksiyon türünü diğeri için değiştirirseniz, yineleyicileri kullanın .
• Eğer bulursanız zor, (belki birkaç farklı dış kullanımda kaynaklardan çeşitli var) koleksiyonların farklı çeşit yineleme nasıl hatırlamak kullanım elemanları üzerinde yürümek hangi araçları birleştirmeye Yineleyicilerin. Bu, bağlantılı listenin dizi listesiyle değiştirilmesinde geçerlidir.

Gerçekten, hepsi bu kadar. Ortalama olarak her iki şekilde de daha fazla kısalık kazanacaksınız ve kısalık gerçekten hedefinizse, her zaman makrolara geri dönebilirsiniz.

C ++ 11 özelliklerine erişiminiz varsa , vektörünüz (veya başka bir kapsayıcı) üzerinde aşağıdaki gibi yineleme yapmak için aralık tabanlı bir fordöngü de kullanabilirsiniz :

for (auto &item : some_vector)
{
     //do stuff
}

Bu döngünün yararı, itembir indikatörü bozma veya yineleyiciyi devrederken hata yapma riski olmadan , vektör öğelerine doğrudan değişken aracılığıyla erişebilmenizdir . Ek olarak, yer tutucu auto, konteyner elemanlarının türünü tekrarlamanıza engel olur, bu da sizi konteynırdan bağımsız bir çözüme daha da yaklaştırır.

Notlar:

• Döngünüzdeki öğe dizinine ve operator[]kapınız için var olana (ve sizin için yeterince hızlı) ihtiyacınız varsa, ilk yol için daha iyi gidin.
• forKapsayıcıya / kapsayıcıya öğe eklemek / kapsayıcıdan öğe eklemek / aralık tabanlı döngü kullanılamaz. Bunu yapmak istiyorsanız, Brian Matthews tarafından verilen çözüme sadık kalın.
• Eğer kap içinde elemanlarını değiştirmek istemiyorsanız, o zaman anahtar kelime kullanmanız gerekir constaşağıdaki gibi: for (auto const &item : some_vector) { ... }.

Hatta "CPU'ya ne yapması gerektiğini söylemek" (zorunlu) "kütüphanelere ne istediğinizi söylemek" (işlevsel).

Bu yüzden döngüler kullanmak yerine stl'de bulunan algoritmaları öğrenmelisiniz.

Konteyner bağımsızlığı için

Ben her zaman dizi dizin kullanın çünkü benim birçok uygulama "görüntü küçük resim" gibi bir şey gerektirir. Ben de şöyle bir şey yazdım:

some_vector[0].left=0;
some_vector[0].top =0;<br>

for (int i = 1; i < some_vector.size(); i++)
{

    some_vector[i].left = some_vector[i-1].width +  some_vector[i-1].left;
    if(i % 6 ==0)
    {
        some_vector[i].top = some_vector[i].top.height + some_vector[i].top;
        some_vector[i].left = 0;
    }

}

Her iki uygulama da doğrudur, ancak 'for' döngüsünü tercih ederim. Başka bir kapsayıcı değil, bir Vector kullanmaya karar verdiğimiz için, dizinleri kullanmak en iyi seçenek olacaktır. Yineleyicilerin Vektörlerle birlikte kullanılması, nesnelerin erişimlerini kolaylaştırmaya yardımcı olan sürekli bellek bloklarında bulunma avantajını kaybedecektir.

Buradaki cevapların hiçbirinin, yineleyicileri neden kapsayıcılara endeksleme konusunda genel bir kavram olarak sevdiğimi açıklamamıştım. Yineleyicileri kullanma deneyimimin çoğunun aslında C ++ değil Python gibi daha üst düzey programlama dillerinden geldiğini unutmayın.

Yineleyici arabirimi, işlevinizin tüketicilerine daha az gereksinim getirir ve bu da tüketicilerin onunla daha fazlasını yapmasını sağlar.

İhtiyacınız olan tüm iletmek isteriz ki muktedir ise, geliştirici indeksli kapları kullanarak sınırlı değildir - bunlar uygulayan herhangi bir sınıf kullanabilirsiniz operator++(T&), operator*(T)ve operator!=(const &T, const &T).

#include <iostream>
template <class InputIterator>
void printAll(InputIterator& begin, InputIterator& end)
{
    for (auto current = begin; current != end; ++current) {
        std::cout << *current << "\n";
    }
}

// elsewhere...

printAll(myVector.begin(), myVector.end());

Algoritmanız ihtiyaç duyduğunuz durumda çalışır - bir vektör üzerinden yineleme - ancak mutlaka beklemediğiniz uygulamalar için de yararlı olabilir:

#include <random>

class RandomIterator
{
private:
    std::mt19937 random;
    std::uint_fast32_t current;
    std::uint_fast32_t floor;
    std::uint_fast32_t ceil;

public:
    RandomIterator(
        std::uint_fast32_t floor = 0,
        std::uint_fast32_t ceil = UINT_FAST32_MAX,
        std::uint_fast32_t seed = std::mt19937::default_seed
    ) :
        floor(floor),
        ceil(ceil)
    {
        random.seed(seed);
        ++(*this);
    }

    RandomIterator& operator++()
    {
        current = floor + (random() % (ceil - floor));
    }

    std::uint_fast32_t operator*() const
    {
        return current;
    }

    bool operator!=(const RandomIterator &that) const
    {
        return current != that.current;
    }
};

int main()
{
    // roll a 1d6 until we get a 6 and print the results
    RandomIterator firstRandom(1, 7, std::random_device()());
    RandomIterator secondRandom(6, 7);
    printAll(firstRandom, secondRandom);

    return 0;
}

Yineleyici uygulaması nispeten basitken, bu yineleyiciye benzer bir şey yapan bir köşeli parantez operatörünün uygulanmaya çalışılması uygun olacaktır. Köşeli parantez operatörü ayrıca, uygulamanız zor veya verimsiz olabilecek sınıfınızın yetenekleri hakkında - herhangi bir keyfi noktaya indeksleyebileceğiniz - imalar yapar.

Yineleyiciler de dekorasyona borç veriyorlar . İnsanlar yapıcılarında yineleyici alan ve işlevlerini genişleten yineleyiciler yazabilir:

template<class InputIterator, typename T>
class FilterIterator
{
private:
    InputIterator internalIterator;

public:
    FilterIterator(const InputIterator &iterator):
        internalIterator(iterator)
    {
    }

    virtual bool condition(T) = 0;

    FilterIterator<InputIterator, T>& operator++()
    {
        do {
            ++(internalIterator);
        } while (!condition(*internalIterator));

        return *this;
    }

    T operator*()
    {
        // Needed for the first result
        if (!condition(*internalIterator))
            ++(*this);
        return *internalIterator;
    }

    virtual bool operator!=(const FilterIterator& that) const
    {
        return internalIterator != that.internalIterator;
    }
};

template <class InputIterator>
class EvenIterator : public FilterIterator<InputIterator, std::uint_fast32_t>
{
public:
    EvenIterator(const InputIterator &internalIterator) :
        FilterIterator<InputIterator, std::uint_fast32_t>(internalIterator)
    {
    }

    bool condition(std::uint_fast32_t n)
    {
        return !(n % 2);
    }
};


int main()
{
    // Rolls a d20 until a 20 is rolled and discards odd rolls
    EvenIterator<RandomIterator> firstRandom(RandomIterator(1, 21, std::random_device()()));
    EvenIterator<RandomIterator> secondRandom(RandomIterator(20, 21));
    printAll(firstRandom, secondRandom);

    return 0;
}

Bu oyuncaklar sıradan görünse de, basit bir arayüzle güçlü şeyler yapmak için yineleyiciler ve yineleyici dekoratörleri kullandığınızı hayal etmek zor değildir - örneğin, tek bir sonuçtan bir model nesnesi oluşturan bir yineleyici ile veritabanı sonuçlarının ileriye dönük bir yineleyicisini süslemek . Bu kalıplar, sonsuz kümelerin bellek tasarruflu yinelemesini sağlar ve yukarıda yazdığım gibi bir filtreyle, sonuçların potansiyel olarak tembel olarak değerlendirilmesini sağlar.

C ++ şablonlarının gücünün bir kısmı, sabit uzunluklu C dizilerinin beğenilerine uygulandığında yineleyici arayüzünüzdür, basit ve verimli işaretçi aritmetiğine bozulur ve gerçekten sıfır maliyetli bir soyutlama yapar.