Apa cara terbaik untuk melakukan iterasi pada dua atau lebih kontainer secara bersamaan

C ++ 11 menyediakan banyak cara untuk melakukan iterasi pada container. Sebagai contoh:

Loop berbasis rentang

for(auto c : container) fun(c)

std :: for_each

for_each(container.begin(),container.end(),fun)

Namun apa cara yang disarankan untuk mengulang lebih dari dua (atau lebih) wadah dengan ukuran yang sama untuk mencapai sesuatu seperti:

for(unsigned i = 0; i < containerA.size(); ++i) {
  containerA[i] = containerB[i];
}

Agak terlambat ke pesta. Tapi: Saya akan mengulangi indeks. Tetapi tidak dengan forpengulangan klasik melainkan dengan forpengulangan berbasis rentang di atas indeks:

for(unsigned i : indices(containerA)) {
    containerA[i] = containerB[i];
}

indicesadalah fungsi pembungkus sederhana yang mengembalikan rentang (dievaluasi secara malas) untuk indeks. Karena implementasinya - meskipun sederhana - agak terlalu lama untuk diposting di sini, Anda dapat menemukan implementasinya di GitHub .

Kode ini seefisien menggunakan forloop manual dan klasik .

Jika pola ini sering muncul dalam data Anda, pertimbangkan untuk menggunakan pola lain yang merupakan zipdua urutan dan menghasilkan berbagai tupel, sesuai dengan elemen yang dipasangkan:

for (auto& [a, b] : zip(containerA, containerB)) {
    a = b;
}

Implementasi zipdibiarkan sebagai latihan bagi pembaca, tetapi mengikuti dengan mudah dari implementasi indices.

(Sebelum C ++ 17 Anda harus menulis yang berikut ini :)

for (auto items&& : zip(containerA, containerB))
    get<0>(items) = get<1>(items);

Untuk contoh spesifik Anda, gunakan saja

std::copy_n(contB.begin(), contA.size(), contA.begin())

Untuk kasus yang lebih umum, Anda dapat menggunakan Boost.Iterator zip_iterator, dengan fungsi kecil untuk membuatnya dapat digunakan dalam loop berbasis rentang. Untuk kebanyakan kasus, ini akan berhasil:

template<class... Conts>
auto zip_range(Conts&... conts)
  -> decltype(boost::make_iterator_range(
  boost::make_zip_iterator(boost::make_tuple(conts.begin()...)),
  boost::make_zip_iterator(boost::make_tuple(conts.end()...))))
{
  return {boost::make_zip_iterator(boost::make_tuple(conts.begin()...)),
          boost::make_zip_iterator(boost::make_tuple(conts.end()...))};
}

// ...
for(auto&& t : zip_range(contA, contB))
  std::cout << t.get<0>() << " : " << t.get<1>() << "\n";

Contoh langsung.

Namun, untuk genericity full-blown, Anda mungkin ingin sesuatu yang lebih seperti ini , yang akan bekerja dengan benar untuk array dan tipe user-defined yang tidak memiliki anggota begin()/ end()tapi jangan memiliki begin/ endfungsi dalam namespace mereka. Selain itu, ini akan memungkinkan pengguna untuk secara khusus mendapatkan constakses melalui zip_c...fungsi.

Dan jika Anda seorang pendukung pesan kesalahan yang bagus, seperti saya, maka Anda mungkin menginginkan ini , yang memeriksa apakah ada wadah sementara yang diteruskan ke salah satu zip_...fungsi, dan mencetak pesan kesalahan yang bagus jika demikian.

Saya heran mengapa tidak ada yang menyebutkan ini:

auto ItA = VectorA.begin();
auto ItB = VectorB.begin();

while(ItA != VectorA.end() || ItB != VectorB.end())
{
    if(ItA != VectorA.end())
    {
        ++ItA;
    }
    if(ItB != VectorB.end())
    {
        ++ItB;
    }
}

PS: jika ukuran wadah tidak cocok, maka Anda harus memasukkan kode di dalam pernyataan if.

Ada banyak cara untuk melakukan hal - hal tertentu dengan banyak penampung seperti yang disediakan di algorithmtajuk. Misalnya, dalam contoh yang Anda berikan, Anda dapat menggunakan std::copyfor loop sebagai pengganti eksplisit.

Di sisi lain, tidak ada cara built-in untuk secara umum mengulang beberapa kontainer selain for loop normal. Ini tidak mengherankan karena ada banyak cara untuk mengulang. Pikirkan tentang hal ini: Anda dapat mengulangi satu wadah dengan satu langkah, satu wadah dengan langkah lainnya; atau melalui satu wadah hingga mencapai ujung kemudian mulai memasukkan sementara Anda melewati ke ujung wadah lainnya; atau satu langkah dari wadah pertama untuk setiap kali Anda benar-benar melewati wadah lainnya, lalu mulai lagi; atau pola lainnya; atau lebih dari dua wadah sekaligus; dll ...

Namun, jika Anda ingin membuat fungsi gaya "for_each" Anda sendiri yang melakukan iterasi melalui dua penampung hanya sampai penampung yang paling pendek, Anda dapat melakukan sesuatu seperti ini:

template <typename Container1, typename Container2>
void custom_for_each(
  Container1 &c1,
  Container2 &c2,
  std::function<void(Container1::iterator &it1, Container2::iterator &it2)> f)
{
  Container1::iterator begin1 = c1.begin();
  Container2::iterator begin2 = c2.begin();
  Container1::iterator end1 = c1.end();
  Container2::iterator end2 = c2.end();
  Container1::iterator i1;
  Container1::iterator i2;
  for (i1 = begin1, i2 = begin2; (i1 != end1) && (i2 != end2); ++it1, ++i2) {
    f(i1, i2);
  }
}

Tentunya Anda dapat membuat strategi iterasi apa pun yang Anda inginkan dengan cara yang serupa.

Tentu saja, Anda mungkin berpendapat bahwa melakukan perulangan for dalam secara langsung lebih mudah daripada menulis fungsi khusus seperti ini ... dan Anda akan benar, jika Anda hanya akan melakukannya satu atau dua kali. Tetapi hal yang menyenangkan adalah ini sangat dapat digunakan kembali. =)

Jika Anda perlu mengulang secara bersamaan melalui 2 penampung saja, ada versi tambahan dari algoritme for_each standar di pustaka rentang peningkatan, misalnya:

#include <vector>
#include <boost/assign/list_of.hpp>
#include <boost/bind.hpp>
#include <boost/range/algorithm_ext/for_each.hpp>

void foo(int a, int& b)
{
    b = a + 1;
}

int main()
{
    std::vector<int> contA = boost::assign::list_of(4)(3)(5)(2);
    std::vector<int> contB(contA.size(), 0);

    boost::for_each(contA, contB, boost::bind(&foo, _1, _2));
    // contB will be now 5,4,6,3
    //...
    return 0;
}

Saat Anda perlu menangani lebih dari 2 kontainer dalam satu algoritme, Anda harus bermain dengan zip.

solusi lain dapat menangkap referensi dari iterator wadah lain dalam lambda dan menggunakan operator kenaikan pos di atasnya. misalnya salinan sederhana adalah:

vector<double> a{1, 2, 3};
vector<double> b(3);

auto ita = a.begin();
for_each(b.begin(), b.end(), [&ita](auto &itb) { itb = *ita++; })

di dalam lambda Anda dapat melakukan apa saja dengan itadan kemudian menaikkannya. Ini dengan mudah meluas ke beberapa wadah kontainer.

Pustaka rentang menyediakan fungsi ini dan fungsi lain yang sangat membantu. Contoh berikut menggunakan Boost.Range . Rangev3 Eric Niebler seharusnya menjadi alternatif yang baik.

#include <boost/range/combine.hpp>
#include <iostream>
#include <vector>
#include <list>

int main(int, const char*[])
{
    std::vector<int> const v{0,1,2,3,4};
    std::list<char> const  l{'a', 'b', 'c', 'd', 'e'};

    for(auto const& i: boost::combine(v, l))
    {
        int ti;
        char tc;
        boost::tie(ti,tc) = i;
        std::cout << '(' << ti << ',' << tc << ')' << '\n';
    }

    return 0;
}

C ++ 17 akan membuatnya lebih baik dengan binding terstruktur:

int main(int, const char*[])
{
    std::vector<int> const v{0,1,2,3,4};
    std::list<char> const  l{'a', 'b', 'c', 'd', 'e'};

    for(auto const& [ti, tc]: boost::combine(v, l))
    {
        std::cout << '(' << ti << ',' << tc << ')' << '\n';
    }

    return 0;
}

Saya sedikit terlambat; tetapi Anda dapat menggunakan ini (fungsi variadic gaya-C):

template<typename T>
void foreach(std::function<void(T)> callback, int count, ...) {
    va_list args;
    va_start(args, count);

    for (int i = 0; i < count; i++) {
        std::vector<T> v = va_arg(args, std::vector<T>);
        std::for_each(v.begin(), v.end(), callback);
    }

    va_end(args);
}

foreach<int>([](const int &i) {
    // do something here
}, 6, vecA, vecB, vecC, vecD, vecE, vecF);

atau ini (menggunakan paket parameter fungsi):

template<typename Func, typename T>
void foreach(Func callback, std::vector<T> &v) {
    std::for_each(v.begin(), v.end(), callback);
}

template<typename Func, typename T, typename... Args>
void foreach(Func callback, std::vector<T> &v, Args... args) {
    std::for_each(v.begin(), v.end(), callback);
    return foreach(callback, args...);
}

foreach([](const int &i){
    // do something here
}, vecA, vecB, vecC, vecD, vecE, vecF);

atau ini (menggunakan daftar penginisialisasi tertutup kurung kurawal):

template<typename Func, typename T>
void foreach(Func callback, std::initializer_list<std::vector<T>> list) {
    for (auto &vec : list) {
        std::for_each(vec.begin(), vec.end(), callback);
    }
}

foreach([](const int &i){
    // do something here
}, {vecA, vecB, vecC, vecD, vecE, vecF});

atau Anda dapat menggabungkan vektor seperti di sini: Apa cara terbaik untuk menggabungkan dua vektor? dan kemudian melakukan iterasi pada vektor besar.

Ini satu varian

template<class ... Iterator>
void increment_dummy(Iterator ... i)
    {}

template<class Function,class ... Iterator>
void for_each_combined(size_t N,Function&& fun,Iterator... iter)
    {
    while(N!=0)
        {
        fun(*iter...);
        increment_dummy(++iter...);
        --N;
        }
    }

Contoh penggunaan

void arrays_mix(size_t N,const float* x,const float* y,float* z)
    {
    for_each_combined(N,[](float x,float y,float& z){z=x+y;},x,y,z);    
    }