C++ 有没有办法在for循环初始值设定项中定义两种不同类型的变量？

可以在for循环中定义两个相同类型的变量：

int main() {
  for (int i = 0, j = 0; i < 10; i += 1, j = 2*i) {
    cout << j << endl;
  }
}

可以这样使用它：

foreach(ii, collection, {
  cout << ii;
}). 

foreach（二、集合、{
库特
请不要建议移动任何
身体外部的变量，
可能不适用于我作为
迭代器必须在之后立即消失
循环

您可以这样做：

#include <iostream>

int main( int, char *[] ) {
    {
        float j = 0.0;

        for ( int i = 0; i < 10; i += 1, j = 2*i ) {
            std::cout << j << std::endl;
        }
    }

    float j = 2.0; // works

    std::cout << j << std::endl;

    return 0;
}

#包括
int main（int，char*[]）{
{
浮动j=0.0；
对于（int i=0；i<10；i+=1，j=2*i）{
std：：cout为什么不在for循环之外声明和初始化变量呢？您仍然可以像现在这样测试和增加变量。
{
{
  int i = 0;
  float j = 0.0;
  for ( ; i < 10; i += 1, j = 2*i) {
    cout << j << endl;
  }
}

int i=0；
浮动j=0.0；
对于（；i<10；i+=1，j=2*i）{
cout这将使迭代器（在本例中为float）在不再需要时消失：

int main() {
  // some code...

  {
    float j = 0.0;
    for (int i = 0; i < 10; i += 1, j = 2*i) {
      cout << j << endl;
    }
  }

  // more code...
}

intmain（）{
//一些代码。。。
{
浮动j=0.0；
对于（int i=0；i<10；i+=1，j=2*i）{
嗯，很难看。但你们可以用这双

int main() {
  for (std::pair<int,float> p(0,0.0f); 
       p.first < 10; 
       p.first += 1, p.second = 2*p.first) {
    cout << p.second << endl;
  }
}

intmain（）{
对于（std：：对p（0,0.0f）；
p、 一级<10；
p、 第一次+=1，第二次=2*p.first）{
库特
请不要建议将任何变量移到for body之外，因为迭代器必须在循环结束后立即消失，所以对我来说可能不可用

您仍然可以这样做，并将整个过程放在花括号中，以使额外的变量超出范围

int main() 
{
  {
    float j = 0.0;
    for (int i = 0; i < 10; i += 1, j = 2*i) 
    {
      cout << j << endl;
    }
  }
  // more code...
}

intmain（）
{
{
浮动j=0.0；
对于（int i=0；i<10；i+=1，j=2*i）
{
根据您给出的要求，我能想到的最简单的代码是：

for ( int i = 0; i < 10; ++i )
{
   float f = i * 2;
   std::cout << f << std::endl;
}

for（int i=0；i<10；++i）
{
浮点数f=i*2；
std:：cout
int main（）{
对于（int i=0，float j=0.0；i<10；i+=1，j=2*i）{
你可以说
i
是你自己的类型，你只需要从
i
中生成
j
，对吗？很简单。在
i
的类中添加一个成员函数来生成
j
值，并始终使用它。如果你愿意，你甚至可以创建一个宏来“隐藏”对该成员函数的调用。：-）
如果宏有问题，有一个标准的
do

#define MYFOR(init, test, post, body) \
    do \
    { \
        init \
        for( ; test; post) \
            body \
    } while(0)

按如下方式使用：

MYFOR( int i = 0; float j = 0.0f; , i < 10 , (i += 1, j = 2.0f * i),
    {
         cout << j << endl;
    } );

MYFOR（int i=0；float j=0.0f；，i<10，（i+=1，j=2.0f*i），
{
cout编辑：问题再次发生变化。该问题现在明确希望实现foreach循环。最简单的答案是：

#include <boost/foreach.hpp>
void( std::vector<int>& v ) {
   BOOST_FOREACH( int & x, v ) {
      x = x*2;
   }
}

#包括
void（std:：vector&v）{
增压器（int&x，v）{
x=x*2；
}
}

将变量注入代码块

这不是一个答案，而是为了展示一种更通用的将变量注入代码块的技术。似乎OP试图定义的宏可能会使用，即使它确实会产生一些开销

您可以在几个地方定义具有不同作用域的变量。您可以在任何代码块内定义变量，其寿命将一直到该特定块的末尾。您可以在for循环的括号内定义变量，作用域将是循环块。您还可以在if块内定义变量，并其范围为if（包括else条款）

您可以将上述选项组合在一起，从外部创建变量并将变量注入代码块，而无需创建寿命超过该块寿命的变量。一个实际示例是定义foreach循环（简化为仅在STL容器上工作）。调用语法为：

void f( std::vector<int>& container ) 
{
   INTVECTOR_FOREACH( int & x, container )
   {
      x = x*2;
   }
}

void f（标准：：向量和容器）
{
INTVECTOR_FOREACH（int&x，容器）
{
x=x*2；
}
}

语义与其他语言中的foreach类似：x被引用到容器中的每个元素，因此函数实际上将整数向量中的每个值加倍

现在，简化宏的代码是：

#define INTVECTOR_FOREACH( variable, container ) \
   for ( std::vector<int>::iterator it = container.begin(); it!=container.end(); ++it ) \
      if ( bool condition=false ) {} else \
         for ( variable = *it; !condition; condition=true )

\define INTVECTOR\u FOREACH（变量、容器）\
对于（std:：vector:：iterator it=container.begin（）；it！=container.end（）；++it）\
如果（bool条件=false）{}else\
for（变量=*it；！条件；条件=true）

为任何容器和类型泛化宏都需要一些元编程，这与问题的上下文无关，但它的工作原理（我希望）应该不会太难理解

外部for在容器上迭代，在每次迭代中，我们只执行一次定义迭代变量的另一个for（示例代码中的int&x）。我们需要一个条件来控制迭代次数（1）我们选择使if失败，这样我们就可以确保用户在循环后编写else时不会得到意外的结果……宏很复杂。
这里有一个使用boost预处理器的版本（这只是为了好玩。有关真实世界的答案，请参阅上面的@kitchen的一个）:

然后，
k
是可见的。当然，它总是必须计算为
false
。因此我们不能使用它。另一个上下文是：

for(int k = 0; ...; ...) COMPOUND_STATEMENT

这就是我在这里要使用的。我们必须注意只对
composite_语句
进行一次迭代。实际的
for
循环执行增量和条件检查必须在最后，因此附加的composite语句与之相关

#include <boost/preprocessor.hpp>
#include <iostream>

#define EMIT_DEC_(R,D,DEC) \
    for(DEC; !_k; ) 

#define FOR(DECS, COND, INC) \
    if(bool _k = false) ; else \
      BOOST_PP_SEQ_FOR_EACH(EMIT_DEC_, DECS, DECS) \
        for(_k = true; COND; INC)

int main() {
    FOR((int i = 0)(float j = 0.0f), i < 10, (i += 1, j = 2 * i)) {
        std::cout << j << std::endl;
    }
}

这一个也很难看，但也提供了一些通用的方法，用于在for循环中声明具有某些给定名称和类型的多个变量

int main() {
  for (struct { int i; float j; } x = { };
       x.i < 10; x.i += 1, x.j = 2 * x.i) {
    cout << x.j << endl;
  }
}

intmain（）{
对于（struct{int i；float j；}x={}；
x、 i<10；x.i+=1，x.j=2*x.i）{
您是否意识到可能没有任何解决方案可以满足您给定的所有条件？“请不要建议将任何变量移到for body之外，因为迭代器必须在循环结束后立即消失，所以可能对我不可用。”听起来您创建了一个工件
void f( std::vector<int>& container ) 
{
   INTVECTOR_FOREACH( int & x, container )
   {
      x = x*2;
   }
}

#define INTVECTOR_FOREACH( variable, container ) \
   for ( std::vector<int>::iterator it = container.begin(); it!=container.end(); ++it ) \
      if ( bool condition=false ) {} else \
         for ( variable = *it; !condition; condition=true )

FOR((int i = 0)(int j = 0.0), i < 10, (i += 1, j = 2 * i)) { 

}

if(int k = 0) ; else COMPOUND_STATEMENT

for(int k = 0; ...; ...) COMPOUND_STATEMENT

#include <boost/preprocessor.hpp>
#include <iostream>

#define EMIT_DEC_(R,D,DEC) \
    for(DEC; !_k; ) 

#define FOR(DECS, COND, INC) \
    if(bool _k = false) ; else \
      BOOST_PP_SEQ_FOR_EACH(EMIT_DEC_, DECS, DECS) \
        for(_k = true; COND; INC)

int main() {
    FOR((int i = 0)(float j = 0.0f), i < 10, (i += 1, j = 2 * i)) {
        std::cout << j << std::endl;
    }
}

if(bool _k = false) ; else
  for(int i = 0; !_k; )
    for(float j = 0.0f; !_k; )
      for(_k = true; i < 10; (i += 1, j = 2 * i)) {
        std::cout << j << std::endl;
      }

int main() {
  for (struct { int i; float j; } x = { };
       x.i < 10; x.i += 1, x.j = 2 * x.i) {
    cout << x.j << endl;
  }
}