C++ Inicjalizacja 2 różne iteratory w pętli for

Question

Powiel możliwe:
Can I declare variables of different types in the initialization of a for loop?

chciałbym mieć do pętli w C++, który konstruuje 2 różne rodzaje wektora iterator w inicjalizacja.

Oto z grubsza to, co lubię:

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

ktoś wie co jest standardem zrobić w tej sytuacji? Nie mogę po prostu użyć wektora podwójnego dla intVec, ponieważ szukam ogólnego rozwiązania. [to znaczy. Może mam jakąś funkcję f, który trwa int podwojenia, a następnie obliczyć f (* i) * (* j)]

Answer 1

można zadeklarować std::pair z first i second jako typów iterator:

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

Na przykład

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

można zadeklarować kilka var. tylko tego samego typu w for. I czy na pewno z tą częścią

++i && ++j 

? Wierzę, że chcesz napisać tam

++i, ++j 

Więc oczywiście trzeba odczytać podstawowe informacje na temat pętli w C++

Answer 3

Nie można deklarować zmienne różnych typów wewnątrz for pętli.

Wystarczy zadeklarować je na zewnątrz:

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

Answer 4

Najłatwiej zrobić, kosztem poszerzenia zakresu iteratorów, byłoby po prostu podnosić je do zawierającym zakresie:

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

Answer 5

Zapoznaj się z zip iterator. Robi dokładnie to, co chcesz: równolegle iteruj przez dwie lub więcej sekwencji jednocześnie. Korzystanie z tym, że piszę to jako:

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) 
{ 
    // ... 
} 

Trzeba przyznać, że się trochę bardziej skomplikowane, jeśli nie mają wsparcia dla auto lub inny rodzaj wnioskowania w Twoim konkretnym przypadku, ale może być jeszcze całkiem ładny z 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

Nie kompiluj wszystkiego.

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

Answer 8

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

użyłem własnych funktory, bo podejrzewam standardowe mnoży a także oczekiwać oba operandy być z podobnego typu, ale może się mylę.