Question

可能重复：
Can I declare variables of different types in the initialization of a for loop?

我想在c ++中有一个for循环，它在初始化中构造了两种不同类型的向量迭代器。

以下是我想要的概念：

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

任何人都知道在这种情况下要做的标准是什么？我不能只为intVec使用double的向量，因为我正在寻找一个通用的解决方案。 [即我可能有一些函数f，它将int加倍，然后计算f（* i）*（* j）]

Answer 1

您可以声明std::pair first和second作为迭代器类型：

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

您无法在for循环内声明不同类型的变量。

只需在外面宣布：

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

Answer 3

例如

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

你可以声明几个var。只有相同类型的for。你确定这个部分

++i && ++j

？我相信你想写那里

 ++i, ++j

显然你必须阅读有关C ++中for循环的基础知识

Answer 4

查看zip iterator。它完全符合您的要求：并行迭代两个或多个序列。使用它，我把它写成：

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

不可否认，如果你在特定情况下不支持auto或其他类型的推理，这会变得有点复杂，但对于typedef它仍然可以很好。

Answer 5

最简单的做法是以扩大迭代器的范围为代价，将它们提升到包含范围：

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

Answer 6

不要过于复杂化。

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

Answer 7

您似乎需要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;
}

我使用了自己的仿函数，因为我怀疑标准乘法并且期望两个操作数都类似，但我可能错了。

Answer 8

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

c ++在for循环中初始化2个不同的迭代器

8 个答案: