Qual è il modo migliore per iterare su due o più contenitori contemporaneamente

C ++ 11 offre diversi modi per eseguire l'iterazione sui contenitori. Per esempio:

Loop basato su intervallo

for(auto c : container) fun(c)

std :: for_each

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

Tuttavia, qual è il modo consigliato per iterare su due (o più) contenitori della stessa dimensione per ottenere qualcosa come:

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

Piuttosto tardi per la festa. Ma: itererei sugli indici. Ma non con il forciclo classico ma invece con un forciclo basato su intervallo sugli indici:

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

indicesè una semplice funzione wrapper che restituisce un intervallo (valutato pigramente) per gli indici. Poiché l'implementazione, sebbene semplice, è un po 'troppo lunga per pubblicarla qui, puoi trovarne un'implementazione su GitHub .

Questo codice è efficiente quanto l'utilizzo di un classico forciclo manuale .

Se questo modello si verifica spesso nei dati, considera l'utilizzo di un altro modello che zipsia due sequenze e produca un intervallo di tuple, corrispondenti agli elementi accoppiati:

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

L'implementazione di zipè lasciata come esercizio per il lettore, ma segue facilmente dall'implementazione di indices.

(Prima di C ++ 17 dovresti invece scrivere quanto segue :)

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

Per il tuo esempio specifico, usa solo

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

Per il caso più generale, puoi usare Boost.Iterator's zip_iterator, con una piccola funzione per renderlo utilizzabile in loop per range-based. Nella maggior parte dei casi, questo funzionerà:

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

Esempio dal vivo.

Tuttavia, per genericità in piena regola, probabilmente si desidera qualcosa di più simile a questo , che funzionerà correttamente per array e tipi definiti dall'utente che non hanno membro begin()/ end()ma non hanno begin/ endfunzioni nel loro spazio dei nomi. Inoltre, ciò consentirà all'utente di ottenere l' constaccesso specifico tramite le zip_c...funzioni.

E se sei un sostenitore di messaggi di errore piacevoli, come me, allora probabilmente vuole questo , che controlla se sono stati passati ad uno qualsiasi degli eventuali contenitori temporanei zip_...funzioni, e stampa un messaggio di errore bello se così.

mi chiedo perché nessuno lo abbia menzionato:

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: se le dimensioni del contenitore non corrispondono, dovrai inserire il codice all'interno delle istruzioni if.

Esistono molti modi per eseguire operazioni specifiche con più contenitori, come indicato algorithmnell'intestazione. Ad esempio, nell'esempio che hai fornito, potresti usare std::copyinvece di un ciclo for esplicito.

D'altra parte, non esiste alcun modo integrato per iterare genericamente più contenitori oltre a un normale ciclo for. Questo non è sorprendente perché ci sono molti modi per iterare. Pensaci: potresti scorrere un contenitore con un passaggio, un contenitore con un altro passaggio; oppure attraverso un contenitore fino a quando non arriva alla fine, quindi inizia a inserire mentre si passa alla fine dell'altro contenitore; o un passaggio del primo contenitore per ogni volta che si passa completamente attraverso l'altro contenitore, quindi si ricomincia da capo; o qualche altro modello; o più di due contenitori alla volta; eccetera ...

Tuttavia, se si voleva fare il vostro proprio funzione di stile "for_each" che consente di scorrere due contenitori solo fino alla lunghezza del più breve, si potrebbe fare qualcosa di simile a questo:

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

Ovviamente puoi fare qualsiasi tipo di strategia di iterazione che desideri in un modo simile.

Naturalmente, potresti sostenere che eseguire direttamente il ciclo interno for è più facile che scrivere una funzione personalizzata come questa ... e avresti ragione, se lo farai solo una o due volte. Ma la cosa bella è che questo è molto riutilizzabile. =)

Nel caso in cui sia necessario iterare simultaneamente solo su 2 contenitori, esiste una versione estesa dell'algoritmo for_each standard nella libreria della gamma boost, ad esempio:

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

Quando devi gestire più di 2 contenitori in un algoritmo, devi giocare con zip.

un'altra soluzione potrebbe essere l'acquisizione di un riferimento dell'iteratore dell'altro contenitore in un lambda e l'utilizzo dell'operatore di incremento post su quello. per esempio una copia semplice sarebbe:

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++; })

all'interno di lambda puoi fare qualsiasi cosa con itae poi incrementarlo. Questo si estende facilmente al caso di più contenitori.

Una libreria di intervalli fornisce questa e altre funzionalità molto utili. L'esempio seguente utilizza Boost.Range . Il rangev3 di Eric Niebler dovrebbe essere una buona alternativa.

#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 lo renderà ancora migliore con i collegamenti strutturati:

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

Anch'io sono un po 'in ritardo; ma puoi usare questo (funzione variadica in stile 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);

o questo (usando un pacchetto di parametri di funzione):

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

o questo (usando un elenco di inizializzatori racchiuso tra parentesi graffe):

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

oppure puoi unire i vettori come qui: Qual è il modo migliore per concatenare due vettori? e quindi iterare su un vettore grande.

Ecco una variante

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

Utilizzo di esempio

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