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

Question

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

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

但是定义不同类型的变量是非法的：

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

有没有办法做到这一点？ （我不需要在循环内使用 i，只需使用 j。）

如果您有完全破解且晦涩的解决方案，对我来说没关系。

在这个人为的示例中，我知道您可以对两个变量使用 double 。 我正在寻找一个普遍的答案。

请不要建议将任何变量移到 for 主体之外，可能对我来说不可用，因为它是一个迭代器，必须在循环之后立即消失，并且 for 语句将包含在我的 foreach 宏：

#define foreach(var, iter, instr) {                  \
    typeof(iter) var##IT = iter;                     \
    typeof(iter)::Element var = *var##IT;            \
    for (; var##_iterIT.is_still_ok(); ++var##IT, var = *var#IT) {  \
      instr;                                         \
    }                                                \
  }

可以这样使用：

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

但我需要这样使用的东西：

foreach(ii, collection)
  cout << ii;

请不要引入任何运行时开销（但编译可能会很慢）。

Answer 1

这是一个使用 boost 预处理器的版本（这只是为了好玩。有关实际答案，请参阅上面 @kitchen 的答案）：

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

}

第一部分指定一系列声明： (a)(b)...< /代码>。 后面声明的变量可以引用前面声明的变量。 第二部分和第三部分照常进行。 当第二部分和第三部分出现逗号时，可以使用括号来防止它们分隔宏参数。

我知道有两个技巧用于声明变量，这些变量稍后在宏外部添加的复合语句中可见。 第一个使用条件，例如 if：

if(int k = 0) ; else COMPOUND_STATEMENT

Then k 可见。 当然，它总是必须评估为false。 所以我们不能使用它。 另一种上下文是这样的：

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

这就是我要在这里使用的。 我们必须注意仅对 COMPOUND_STATMENT 进行一次迭代。 执行增量和条件检查的实际 for 循环必须出现在末尾，因此附加的复合语句与其相关。

#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 语句，每个语句都嵌套在另一个语句中。 它扩展为：

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

Answer 2

嗯，这很丑。 但你可以使用pair。

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

Answer 3

请不要建议移动任何
for 主体之外的变量，
可能对我来说不可用，因为
迭代器必须立即消失
循环。

你可以这样做：

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

Answer 4

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

也许我太笨了，但为什么你还要声明浮动呢？ 无论如何，当你离开循环时，你只需“扔掉它”即可。 正确的？

for(int i=0; i<10; ++i)
    cout << (float)2*i << endl;

为什么需要 j？

Answer 5

根据您给出的要求，我能想到的最简单的代码是：

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

您仅使用 f 作为 i 值的两倍。 生命周期仅限于循环，并且（至少在您提供的简化问题中）浮点数的创建成本低廉（与分配成本完全相同）。

如果构建真正的浮点数（我假设因为 i 不是真正的 int，f 也可能不是浮点数）比重新分配值要昂贵得多，那么封装在内部的其他解决方案一对额外的大括号来限制范围将是最好的选择。

Answer 6

请不要建议将任何变量移到 for 主体之外，可能对我来说不可用，因为迭代器必须在循环后立即消失。

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

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

这样 j 将在循环之后立即超出范围。

Answer 7

这也很丑陋，但也提供了一些通用方法，用于在 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;
  }
}

Answer 8

编辑：问题再次改变。 现在的问题明确想要实现一个 foreach 循环。 最简单的答案：

#include <boost/foreach.hpp>
void( std::vector<int>& v ) {
   BOOST_FOREACH( 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;
   }
}

语义与其他语言中的 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 )

将宏推广到任何容器和类型都需要一些脱离问题上下文的元编程，但它的工作原理（我希望）不应该太复杂 。

外部 for 遍历容器，在每次迭代中，我们仅执行一次定义迭代变量（示例代码中的 int & x ）的 for 我们需要一个条件来控制内部循环的迭代次数 (1)，并且该条件是用 if 注入的，我们选择使 if 失败，以便我们可以确保用户这样做。如果她在循环后编写 else，则不会得到意外的结果...宏很棘手。

Answer 9

如果您在使用宏时遇到问题，有一个标准的 do..while 技巧可以完美地发挥作用：

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

它很丑陋，但它可以满足您的要求：i 的范围 和 j 受到宏中的 do..while 循环的限制，并且它需要在末尾有一个分号，所以你不会被将其放在 if/else 语句的谓词中。

Answer 10

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

变量在块之后“消失”。

Answer 11

这将使迭代器（或者在本例中为浮动）在不再需要时消失：

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

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

  // more code...
}

Answer 12

为什么不在 for 循环之外声明并初始化变量呢？ 您仍然可以像现在一样进行测试和增量。

Answer 13

你说i是你自己的类型，你只需要从i生成j，对吧？ 简单的。 将成员函数添加到 i 的类中以生成 j 值，并始终使用该值。 如果需要，您甚至可以创建一个宏来“隐藏”对该成员函数的调用。 :-)