Hey guys,

So I think this probably more of a style preference/opinion thread than a question with a specific answer.

Let's say you have a for loop that goes through an array, vector, or whatever. Maybe it's a search and destroy or something else, but it has the following form:

for (int i = 0 ; i < MAX ; i ++)
{
    if (someCondition == true)
    {
        foo () ;
        bar () ;
    }
}

Now, afaik, the previous code would be behavior equivalent to:

for (int i = 0 ; i < MAX ; i ++)
{
    if (someCondition == false) {continue ;}
    foo () ;
    bar () ;
}

Is there a predominant form or an advantage in using one over the other?

// first way
for (int i = 0 ; i < MAX ; i ++)
{
    if (someCondition && someOtherCondition && unrelatedCrap && 
        whyIsThisHere && isThereAnyCoffeeLeft)
    {
        foo () ;
        bar () ;
    }
}

// second way
for (int i = 0 ; i < MAX ; i ++)
{
    if (!someCondition)
    {
        continue;
    }
    if (!someOtherCondition )
    {
        continue;
    }
    if (!unrelatedCrap )
    {
        continue;
    }
    if (!whyIsThisHere )
    {
        continue;
    }
    if (!isThereAnyCoffeeLeft)
    {
        continue;
    }

    foo () ;
    bar () ;    
}

That makes sense. Never thought about it from a debugging standpoint.

That's make sense. Never thought about from a debugging standpoint.

Forget the body, what about the fist line? :wink:

for(int i = 0; i < MAX; i ++)

VS idiomatic iterator style:

for(int i = 0, end = MAX; i != end; ++i)

The for loop is everything wrong with imperative code imho :)

It has too many moving parts and too many ways to make stupid mistakes. Much prefer the declarative approach C# allows with something like this

Range(0, MAX).Foreach(i => {do stuff here});

and to filter

Range(0, MAX)

.Where(i => someCondition)

.Foreach(i => {do stuff here});

Easier to read and reason about and really hard to mess up :)

I'm personally a fan of decrementing my for-loops rather than incrementing. So instead of this:

for(int i = 0; i < MAX; i ++) {
    // ...
}

There's this:

for(int i = MAX; i --> 0;) {
    // ...
}

It comes in handy when you're iterating over a container and are deleting elements along the way. This way you don't have to add as much logic for moving to the next element after deleting the one prior.

i --> 0

I've never seen anyone write it like this, and in fact, without my morning coffee, it took me a few seconds to realize this is actually valid code and I had to put in extra effort to understand that it iterates over the same range. It's a neat trick, but I'm not sure it's really worth confusing other people who may read the code.