C++ Inicialización 2 iteradores diferentes en un bucle for

Question

Duplicar posible:
Can I declare variables of different types in the initialization of a for loop?

me gustaría tener un bucle en C++ que construye 2 tipos diferentes de iterador vector en la inicialización

Aquí está una idea aproximada de lo que me gustaría:

std::vector<double> dubVec; 
std::vector<int> intVec; 
double result = 0; 

dubVec.push_back(3.14); 
intVec.push_back(1); 

typedef std::vector<int>::iterator intIter; 
typedef std::vector<double>::iterator dubIter; 

for (intIter i = intVec.begin(), dubIter j = dubVec.begin(); i != intVec.end(); ++i, ++j) 
{ 
    result += (*i) * (*j); 
} 

Alguien sabe lo que es el estándar que hacer en esta situación? No puedo usar un vector de doble para intVec porque estoy buscando una solución general. [es decir. Podría tener alguna función f que toma int duplicar y luego calcular f (* i) * (* j)]

Answer 1

Se puede declarar una std::pair con first y second como los tipos de iterador:

for (std::pair<intIter, dubIter> i(intVec.begin(), dubVec.begin()); 
    i.first != intVec.end() /* && i.second != dubVec.end() */; 
    ++i.first, ++i.second) 
{ 
    result += (*i.first) * (*i.second); 
} 

Answer 2

Por ejemplo

intIter i = intVec.begin(); 
dubIter j = dubVec.begin(); 
for (; i != intVec.end(); ++i && ++j) 
{ 
    result += (*i) * (*j); 
} 

puede declarar varias var. solo del mismo tipo en el para. Y está seguro con esta parte

++i && ++j 

? Creo que desea escribir no

++i, ++j 

Así que, obviamente, debe leer conceptos básicos acerca de bucle en C++

Answer 3

No se puede declarar variables de diferentes tipos dentro de un bucle for.

Sólo declararlos fuera:

intIter i = intVec.begin(); 
dubIter j = dubVec.begin(); 
for (; i != intVec.end(); ++i && ++j) 
{ 
} 

Answer 4

La cosa más fácil de hacer, a costa de ampliar el alcance de los iteradores, sería simplemente izar ellos hasta el alcance que contiene:

intIter i; 
dubIter j; 
for (i = intVec.begin(), j = dubVec.begin(); i != intVec.end(); ++i && ++j) 
{ 
    result += (*i) * (*j); 
} 

Answer 5

Revisa el zip iterator. Hace exactamente lo que quiere: paralelo iterar sobre dos o más secuencias simultáneamente. Usando esto, me gustaría escribir como:

using namespace boost; 

for (auto i=make_zip_iterator(make_tuple(dubVec.begin(), intVec.begin())), 
      ie=make_zip_iterator(make_tuple(dubVec.end(), intVec.end())); 
      i!=ie; ++i) 
{ 
    // ... 
} 

Es cierto que esto es un poco más complicado si usted no tiene soporte para auto u otro tipo de inferencia en su caso específico llegar, pero todavía puede ser bastante agradable con un typedef.

Answer 6

intIter i; 
dubIter j; 
for (i = intVec.begin(), j = dubVec.begin(); i != intVec.end() && j != dubIter.end(); ++i, ++j) 
{ 
    result += (*i) * (*j); 
} 

Answer 7

No complicar demasiado las cosas.

for(size_t i = 0; i < intVec.size(); ++i) 
{ 
    result += intVec[i] * dubVec[i]; 
} 

Answer 8

Parece que necesita un inner_product algorithm.

#include <vector> 
#include <functional> 
#include <numeric> 
#include <iostream> 

struct my_plus 
{ 
    double operator()(int i, double d) 
    { 
     return d + i; 
    } 
}; 

struct my_multiplies 
{ 
    double operator()(int i, double d) 
    { 
     return d * i; 
    } 
}; 

int main() 
{ 
    std::vector<double> dubVec; 
    std::vector<int> intVec; 
    double result = 0; 

    dubVec.push_back(3.14); 
    intVec.push_back(1); 

    result = std::inner_product(intVec.begin(), 
           intVec.end(), 
           dubVec.begin(), 
           0.0, 
           my_plus(), 
           my_multiplies()); 
    std::cout << result << std::endl; 
} 

usaba mis propias palabras funcionales, porque sospecho que se multiplica el estándar y además espero ambos operandos sean de tipo similar, pero puedo estar equivocado.