c++ Initialising 2 different iterators in a for loop [duplicate]

Answer 1

The easiest thing to do, at the expense of widening the scope of the iterators, would be to just hoist them up to the containing scope:

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

Answer 2

You could declare a std::pair with first and second as the iterator types:

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 3

It seems you need an 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;
}

I used my own functors, because I suspect the standard multiplies and plus expect both operands to be of similar type, but I might be wrong.

Answer 4

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

Answer 5

Don't overcomplicate things.

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

Answer 6

Check out the zip iterator. It does exactly what you want: parallel iterate over two or more sequences simultaneously. Using that, I'd write it as:

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

Admittedly, this get's a little more complicated if you don't have support for auto or other type inference in your specific case, but it can still be quite nice with a typedef.