std :: for_each funziona su più di un intervallo di iteratori

Question

La notazione lambda ha reso gli algoritmi di stl più accessibili. Sto ancora imparando a decidere quando è utile e quando ricadere in un buon vecchio stile. Spesso, diventa necessario iterare su due (o più) contenitori della stessa dimensione, in modo tale che gli elementi corrispondenti siano correlati, ma per qualche motivo non sono raggruppati nella stessa classe.

Una funzione utilizza un ciclo for per ottenere che sarebbe simile a questa:

template<typename Data, typename Property> 
void foo(vector<Data>& data, vector<Property>& prop) { 
    auto i_data = begin(data); 
    auto i_prop = begin(prop); 
    for (; i_data != data.end(); ++i_data, ++i_prop) { 
     if (i_prop->SomePropertySatistfied()) { 
      i_data->DoSomething(); 
     } 
    } 
} 

Per poter utilizzare for_each, ho bisogno di una versione di esso che gestisce più intervalli; qualcosa di simile:

template<typename InputIter1, typename InputIter2, typename Function> 
Function for_each_on_two_ranges(InputIter1 first1, InputIter1 last1, InputIter2 first2, Function f) { 
    for (; first1 != last1; ++first1, ++first2) { 
     f(*first1, *first2); 
    } 
    return f; 
} 

Con questa versione, il codice di cui sopra sarebbe simile a questa:

template<typename Data, typename Property> 
void foo_two_ranges(vector<Data>& data, vector<Property>& prop) { 
    for_each_on_two_ranges(begin(data), end(data), begin(prop), [](Data& d, Property& p) { 
     if (p.SomePropertySatistfied()) { 
      d.DoSomething(); 
     } 
    }); 
} 

C'è un modo equivalente di ottenere lo stesso risultato utilizzando algoritmi STL?

EDIT

ho trovato la risposta esatta alla mia domanda in forma di boost :: for_each esecuzione su boost :: gamma. Ho aggiunto la risposta, con codice di esempio per motivi di completezza.

Answer 1

1) Gli algoritmi in STL non sono pensati per coprire ogni possibile caso, se è necessario for_each_on_two_ranges quindi scrivilo (come hai) e usalo. La bellezza dell'STL è così estensibile e l'hai estesa con un nuovo utile algo.

2) Se ciò non funziona, non è necessario utilizzare buoni for-loop di vecchio stile, è possibile utilizzare fantastici nuovi for-loops, invece!

Come un'altra risposta ha detto, boost::zip_iterator è tuo amico qui, ma non deve essere difficile da usare. Ecco una soluzione con un adattatore intervallo che viene implementata con zip_iterator

template<typename Data, typename Property> 
void foo(vector<Data>& data, vector<Property>& prop) { 
    for (auto i : redi::zip(data, prop)) 
     if (i.get<1>().SomePropertySatistfied()) 
      i.get<0>.DoSomething(); 
} 

Tale zip funzione crea un adattatore con begin() e end() membri che restituiscono un boost::zip_iterator, quindi la variabile loop è una tupla degli elementi di ogni contenitore sottostante (e dato che è un modello di variadic si può fare per qualsiasi numero di contenitori, in modo da non avere bisogno di scrivere for_each_for_three_ranges e for_each_for_four_ranges ecc)

si potrebbe anche usare con for_each

auto z = redi::zip(data, prop); 
typedef decltype(z)::iterator::reference reference; 

for_each(begin(z), end(z), [](reference i) { 
    if (i.get<1>().SomePropertySatistfied()) { 
     i.get<0>().DoSomething(); 
    } 
}); 

Answer 2

ha un sovraccarico che opera su due sequenze in parallelo. Avresti bisogno di un iteratore di output nullo per assorbire i risultati, se non ti interessasse raccoglierne.

Answer 3

Dopo aver letto su boost :: zip_iterator e boost :: iterator_range come suggerito da alcune risposte, mi sono imbattuto nel extension algorithms in boost::range, e ho trovato l'esatto parallelo dell'algoritmo che ho scritto per due gamme, ma con intervalli di boost.

un codice di lavoro per l'esempio sarebbe

#include <boost/range/algorithm_ext/for_each.hpp> 

template<typename Data, typename Property> 
void foo_two_ranges(vector<Data>& data, vector<Property>& prop) { 
    auto rng1 = boost::make_iterator_range(data.begin(), data.end()); 
    auto rng2 = boost::make_iterator_range(prop.begin(), prop.end()); 
    boost::for_each(rng1, rng2, [](Data& d, Property& p) { 
     if (p.SomePropertySatistfied()) { 
      d.DoSomething(); 
     } 
    }); 
} 

Alcuni involucri e funzioni di utilità, simili in mente di cosa @ Jonathan Wakely suggerito, può renderlo ancora più fruibile.