在C11中：for (bool b : { false, true }) { /* ... */ }
下面是C03版本：

for (bool a = true, b = false; b != a; a = a && b, b = !b) { /*...*/ }

(Use a或b。）

当局限于C2003时，你可以使用一种大致等同于C2011的方法;

{
  bool const bools[] = { false, true };
  for (bool const* it(bools); it != std::end(bools); ++it) {
      bool a(*it);
      use(a);
  }
}

可能被打包进了一个宏。您还可以使用

for (bool a: { false, true }) {
    use(a);
}

for (int a = 0; a <= 1; a++)
  doStuff(a ? true : false);

忘记“没有转换到其他类型”的限制：）在一天结束时，清晰度比人为的限制更重要。五年后，你会阅读自己的代码，想知道“我到底在想什么，这是某种混淆比赛吗？”“

a = true;
do {
  use(a);
  a = !a;
} while (!a);

好吧，所以它不是一个 for 循环，但我认为它比任何for循环建议（当然，除了C++11方法）更具可读性。）

C++03：

for(bool a = false, b = true; b; a = !a, b = a)

使用B。

这个答案解决了“不可能的”C++03，单变量的唯一解决方案
首先，让我们确认，没有一个仅依赖于单个输入变量的确定性算术表达式对于两个输入true,false都是真的，但对于必须是true或false之一的第三个值则不是真的。
但是，我们可以“作弊”。不过，我恳求你证明我真的在作弊。

#include <iostream>

using namespace std;

int main() {
    for (bool b = false; *((char*)&b) != 2; *((char*)&b) += 1) {
        cout << "bool " << b << endl;
    }
}

这看起来像是一种未定义的行为。C++03是位unclear about it。但是，sizeof必须始终至少为1（对于长度为0的可变长度数组，有一个非标准的例外）。此外，由于我们保证每个字符至少是8位，因此我们可以使用第二个字符作为计数器。
实际上，要做到这一点，我们需要避开确定性（如果不放弃对false, true只迭代一次的保证，就不能这样做），或者我们的约束类型系统。

这个也可以用：

for (bool a = false, b = false; a == b; b = !b, a = a || b) { }

(sort比@KerrekSB的倒置溶液）

我知道你要求一个不转换到其他类型的解决方案，但我想你的意思是“不转换到不适当的其他类型”。这里有一个答案，在这个特定的例子中，它提供了一个对象来替换bool。

struct IterableBool
{
  bool b;
  bool out_of_scope;
  IterableBool() : b(false), out_of_scope(false) {}
  IterableBool(bool b_) : b(b_), out_of_scope(false) {}
  IterableBool(IterableBool ib) : b(ib.b), out_of_scope(ib.out_of_scope) {}
  operator bool () { return this->b; }
  bool in_scope() const { return !this->out_of_scope; }
  IterableBool& operator ++ ()
  {                    
    this->out_of_scope = this->b;
    this->b = true;
    return *this;
  }
  IterableBool operator ++ (int)
  {
    IterableBool copy = *this;
    ++(*this);
    return copy;
  }
  IterableBool& operator -- ()
  {
    this->out_of_scope = !this->b;
    this->b = false;
    return *this;
  }
  IterableBool operator -- (int)
  {
    IterableBool copy = *this;
    --(*this);
    return copy;
  }
};

// Usage :
for(IterableBool ib = false;  ib.in_scope(); ++ib)
  do_stuff((bool)ib);

一个可能不那么令人困惑的版本，基于Pokrovsky的回答：

bool firstPass=true;
for (int i = 0; i < 2; i++, firstPass=false)
    myfunc(firstPass);

或者更简单地说：

for (int pass = 1; i < 3; i++)
    myfunc(pass == 1);

甚至

for (int secondPass = 0; secondPass < 2; ++secondPass)
    myfunc(!secondPass);

（Pokrovsky的答案优化）。
我认为当程序员在循环中看到变量时，让它有意义是很重要的。