Why is it so 'hard' to write a for-loop in C++ with 2 loop variables? [duplicate]
Possible Duplicate:
In C++ why can’t I write a for() loop like this: for( int i = 1, double i2 = 0; …
A C developer would write this:
int myIndex;
for (myIndex=0;myIndex<10;++myIndex) ...
A C++ developer would write this to prevent the loop variable from leaking outside the loop:
for (int myIndex=0;myIndex<10;++myIndex) ...
However, if you have 2 loop variables, you cannot do this anymore. The following doesn't compile:
for (int myIndex=0,MyElement *ptr=Pool->First;ptr;++myIndex,ptr=ptr->next) ...
The comma operator does not allow two variables to be defined this way, so we have to write it like this:
int myIndex;
MyElement *ptr;
for (myIndex=0,ptr=Pool->First;ptr;++myIndex,ptr=ptr->next) ...
Which defeats the advantage of having real loop-local variables.
A solution could be to put the whole construction between braces, like this:
{
int myIndex;
MyElement *ptr;
for (myIndex=0,ptr=Pool->First;ptr;++myIndex,ptr=ptr->next) ...
}
But this is hardly more elegant.
Isn't ther开发者_Python百科e a better way of doing this in C++ (or C++0x)?
You just have to understand the first statement is a declaration (and that comma is not the comma operator). It's not any harder to do:
for (int i, double d; ...)
Than it is:
int i, double d;
Because for (init cond; expr) statement
gets expanded to:
{
init
while (cond)
{
statement
expr;
}
}
A trick is to make that init
statement a struct definition and instance, like:
for (struct { int myIndex; MyElement* ptr;} data = {0, Pool->First};
data.ptr;
++data.myIndex, data.ptr = data.ptr->next)
{
// blah...
}
Which becomes the same as:
{
struct
{
int myIndex;
MyElement* ptr;
} data = {0, Pool->First};
while (data.ptr)
{
{
// blah...
}
++data.myIndex, data.ptr = data.ptr->next;
}
}
But I find that pretty ugly. In practice, I'd just split it up like you have. If scope is really a problem, which it probably isn't, throw the extra braces around there.
I don't think there's much to improve here without a bit of boilerplate code.
If I really wanted to confine the scope to the loop I would use:
#include <utility>
for (auto i = std::make_pair(0,Pool->First);
i.second;
++i.first, i.second=i.second->next)
At least C++ allows us to declare variables in the if clause, which which is sometimes used to declare a variable that only is only visible when some condition is true:
if (MyElement *ptr=Pool->First) // block is only entered when ptr!=0
{
for (int myIndex=0;ptr;++myIndex,ptr=ptr->next)
{
}
}
// ptr is out of scope now.
This could be a method to limit the scope of ptr and index, while maintaining readability.
精彩评论