Quelle est la meilleure façon d'itérer simultanément sur deux ou plusieurs conteneurs

C ++ 11 offre plusieurs façons d'itérer sur des conteneurs. Par exemple:

Boucle basée sur la plage

for(auto c : container) fun(c)

std :: for_each

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

Cependant, quelle est la manière recommandée d'itérer sur deux (ou plus) conteneurs de même taille pour accomplir quelque chose comme:

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

Plutôt tard à la fête. Mais: je voudrais itérer sur les indices. Mais pas avec la forboucle classique mais plutôt avec une forboucle basée sur une plage sur les indices:

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

indicesest une simple fonction wrapper qui renvoie une plage (évaluée paresseusement) pour les indices. Puisque l'implémentation - bien que simple - est un peu trop longue pour la publier ici, vous pouvez trouver une implémentation sur GitHub .

Ce code est aussi efficace que l'utilisation d'une forboucle classique manuelle .

Si ce modèle se produit souvent dans vos données, envisagez d'utiliser un autre modèle zipcomposé de deux séquences et produisant une plage de tuples, correspondant aux éléments appariés:

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

La mise en œuvre de zipest laissée comme un exercice pour le lecteur, mais elle découle facilement de la mise en œuvre de indices.

(Avant C ++ 17, vous devriez plutôt écrire ce qui suit :)

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

Pour votre exemple spécifique, utilisez simplement

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

Pour le cas plus général, vous pouvez utiliser Boost.Iterator's zip_iterator, avec une petite fonction pour le rendre utilisable dans des boucles for basées sur la plage. Dans la plupart des cas, cela fonctionnera:

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

Exemple en direct.

Cependant, pour une généricité à part entière, vous voulez probablement quelque chose de plus comme ça , qui fonctionnera correctement pour les tableaux et les types définis par l'utilisateur qui n'ont pas de membre begin()/ end()mais qui ont begin/ des endfonctions dans leur espace de noms. En outre, cela permettra à l'utilisateur d'accéder spécifiquement constà travers les zip_c...fonctions.

Et si vous êtes un partisan de bons messages d'erreur, comme moi, alors vous voulez probablement ceci , qui vérifie si des conteneurs temporaires ont été passés à l'une des zip_...fonctions, et affiche un joli message d'erreur si c'est le cas.

je me demande pourquoi personne n'a mentionné ceci:

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: si les tailles des conteneurs ne correspondent pas, vous devrez mettre le code dans les instructions if.

Il existe de nombreuses façons de faire des choses spécifiques avec plusieurs conteneurs, comme indiqué dans l'en- algorithmtête. Par exemple, dans l'exemple que vous avez donné, vous pouvez utiliser à la std::copyplace d'une boucle for explicite.

D'un autre côté, il n'existe aucun moyen intégré d'itérer génériquement plusieurs conteneurs autre qu'une boucle for normale. Ce n'est pas surprenant car il existe de nombreuses façons d'itérer. Pensez-y: vous pouvez parcourir un conteneur avec une étape, un conteneur avec une autre étape; ou à travers un conteneur jusqu'à ce qu'il arrive à la fin, puis commencez à insérer pendant que vous passez à l'extrémité de l'autre conteneur; ou une étape du premier conteneur pour chaque fois que vous passez complètement par l'autre conteneur, puis recommencez; ou un autre modèle; ou plus de deux conteneurs à la fois; etc ...

Cependant, si vous souhaitez créer votre propre fonction de style "for_each" qui ne parcourt que deux conteneurs jusqu'à la longueur du plus court, vous pouvez faire quelque chose comme ceci:

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

Évidemment, vous pouvez faire n'importe quel type de stratégie d'itérations de la même manière.

Bien sûr, vous pourriez affirmer que faire directement la boucle for interne est plus facile que d'écrire une fonction personnalisée comme celle-ci ... et vous auriez raison, si vous ne le faites qu'une ou deux fois. Mais la bonne chose est que c'est très réutilisable. =)

Dans le cas où vous devez itérer simultanément sur 2 conteneurs uniquement, il existe une version étendue de l'algorithme for_each standard dans la bibliothèque de plage de boost, par exemple:

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

Lorsque vous devez gérer plus de 2 conteneurs dans un seul algorithme, vous devez jouer avec zip.

une autre solution pourrait être de capturer une référence de l'itérateur de l'autre conteneur dans un lambda et d'utiliser l'opérateur de post-incrémentation sur cela. par exemple, une copie simple serait:

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

à l'intérieur de lambda, vous pouvez faire n'importe quoi itaet l'incrémenter. Cela s'étend facilement au cas des conteneurs multiples.

Une bibliothèque de plage fournit ceci et d'autres fonctionnalités très utiles. L'exemple suivant utilise Boost.Range . Le rangev3 d'Eric Niebler devrait être une bonne alternative.

#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 rendra cela encore meilleur avec des liaisons structurées:

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

Je suis un peu en retard aussi; mais vous pouvez utiliser ceci (fonction variadique de style 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);

ou ceci (en utilisant un pack de paramètres de fonction):

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

ou ceci (en utilisant une liste d'initialiseurs entre accolades):

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

ou vous pouvez joindre des vecteurs comme ici: Quelle est la meilleure façon de concaténer deux vecteurs? puis itérer sur un gros vecteur.

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

Exemple d'utilisation

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