Qual é a melhor maneira de iterar em dois ou mais contêineres simultaneamente

C ++ 11 oferece várias maneiras de iterar em contêineres. Por exemplo:

Loop baseado em alcance

for(auto c : container) fun(c)

std :: for_each

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

No entanto, qual é a maneira recomendada de iterar em dois (ou mais) contêineres do mesmo tamanho para realizar algo como:

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

Um pouco tarde para a festa. Mas: eu iria iterar sobre os índices. Mas não com o forloop clássico, mas sim com um forloop baseado em intervalo sobre os índices:

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

indicesé uma função de invólucro simples que retorna um intervalo (avaliado lentamente) para os índices. Como a implementação - embora simples - é um pouco longa para postá-la aqui, você pode encontrar uma implementação no GitHub .

Este código é tão eficiente quanto usar um forloop clássico manual .

Se esse padrão ocorrer com frequência em seus dados, considere usar outro padrão que seja zipduas sequências e produza uma gama de tuplas, correspondendo aos elementos emparelhados:

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

A implementação de zipé deixada como um exercício para o leitor, mas decorre facilmente da implementação de indices.

(Antes do C ++ 17, você teria que escrever o seguinte :)

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

Para seu exemplo específico, basta usar

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

Para o caso mais geral, você pode usar Boost.Iterator's zip_iterator, com uma pequena função para torná-lo utilizável em loops for baseados em intervalo. Na maioria dos casos, isso funcionará:

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

Exemplo ao vivo.

No entanto, para genericidade full-blown, você provavelmente vai querer algo mais parecido com este , que irá funcionar correctamente para arrays e tipos definidos pelo usuário que não têm membro begin()/ end()mas não têm begin/ endfunções em seu namespace. Além disso, isso permitirá que o usuário obtenha constacesso especificamente por meio das zip_c...funções.

E se você é um defensor de boas mensagens de erro, como eu, então provavelmente você quer isso , que verifica se algum contêiner temporário foi passado para alguma das zip_...funções e imprime uma boa mensagem de erro em caso afirmativo.

Eu me pergunto por que ninguém mencionou isso:

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 os tamanhos do contêiner não corresponderem, você terá que colocar o código dentro das instruções if.

Existem várias maneiras de fazer coisas específicas com vários contêineres, conforme fornecido no algorithmcabeçalho. Por exemplo, no exemplo que você deu, você poderia usar em std::copyvez de um loop for explícito.

Por outro lado, não há nenhuma maneira integrada de iterar genericamente vários contêineres além de um loop for normal. Isso não é surpreendente porque existem várias maneiras de iterar. Pense nisso: você poderia iterar por meio de um contêiner com uma etapa, um contêiner com outra etapa; ou através de um contêiner até chegar ao fim, então comece a inserir enquanto vai até o final do outro contêiner; ou uma etapa do primeiro contêiner para cada vez que você passar completamente pelo outro contêiner e depois reiniciar; ou algum outro padrão; ou mais de dois contêineres por vez; etc ...

No entanto, se você quiser fazer sua própria função de estilo "for_each" que itera por meio de dois contêineres apenas até o comprimento do mais curto, poderá fazer algo assim:

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

Obviamente, você pode fazer qualquer tipo de estratégia de iterações que desejar de maneira semelhante.

Claro, você pode argumentar que apenas fazer o loop for interno diretamente é mais fácil do que escrever uma função customizada como esta ... e você está certo, se for fazer isso apenas uma ou duas vezes. Mas o bom é que isso é muito reutilizável. =)

No caso de você precisar iterar simultaneamente em apenas 2 contêineres, há uma versão estendida do algoritmo for_each padrão na biblioteca de intervalo de impulso, por exemplo:

#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 você precisa lidar com mais de 2 contêineres em um algoritmo, precisa brincar com o zip.

outra solução poderia ser capturar uma referência do iterador do outro contêiner em um lambda e usar o operador de pós-incremento nisso. por exemplo, uma cópia simples seria:

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

dentro do lambda, você pode fazer qualquer coisa itae incrementá-lo. Isso se estende facilmente ao caso de vários contêineres.

Uma biblioteca de alcance fornece esta e outras funcionalidades muito úteis. O exemplo a seguir usa Boost.Range . O rangev3 de Eric Niebler deve ser uma boa 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 tornará isso ainda melhor com ligações estruturadas:

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

Também estou um pouco atrasado; mas você pode usar isto (função variadic de estilo 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 isto (usando um pacote de parâmetros de função):

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 isto (usando uma lista de inicializadores entre chaves):

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 você pode juntar vetores como aqui: Qual é a melhor maneira de concatenar dois vetores? e, em seguida, itere sobre um grande vetor.

Aqui está uma 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;
        }
    }

Exemplo de uso

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