Is this a valid (ab)use of lambda expressions?

Question

Like we all know, it's not that easy to break from a nested loop out of an outer loop without either:

• a goto (Example code.)
• another condition check in the outer loop (Example code.)
• putting both loops in an extra function and returning instead of breaking (Example code.)

Though, you gotta admit, all of those are kinda clumsy. Especially the function version lacks because of the missing context where the loops are called, as you'd need to pass everything you need in the loops as parameters.
Additionally, the second one gets worse for each nested loop.
So, I personally, still consider the goto version to be the cleanest.

---

Now, thinking all C++0x and stuff, the third option brought me this idea utilizing lambda expressions:

#include <iostream>

bool CheckCondition(){
  return true;
}

bool CheckOtherCondition(){
  return false;
}

int main(){
  [&]{while(CheckCondition()){
    for(;;){
      if(!CheckOtherCondition())
        return;
      // do stuff...
    }
    // do stuff...
  }}();
  std::cout << "yep, broke out of it\n";
}

(Example at Ideone.)

This allows for the semantic beauty of a simple return that the third option offers while not suffering from the context problems and being (nearly) as clean as the goto version. It's also even shorter (character-wise) than any of the above options.

---

Now, I've learned to keep my joy down after finding beautiful (ab)uses of the language, because there's almost always some kind of drawback. Are there any on this one? Or is there even a better approach to the problem?

Answer 1

Please don't do that in a project I'm managing. That's an awkward abuse of lambdas in my opinion.

Use a goto where a goto is useful.

Answer 2

Perfectly valid in my opinion. Though I prefer to assign mine with names, making the code more self documenting, i.e.

int main(){

  auto DoThatOneThing = [&]{while(CheckCondition()){
    for(;;){
      if(!CheckOtherCondition())
        return;
      // do stuff...
    }
    // do stuff...
  }};

  DoThatOneThing();
  std::cout << "yep, broke out of it\n";
}

Answer 3

In which way is that an improvement over

void frgleTheBrgls()
{
  while(CheckCondition()) {
    for(;;) {
      if(!CheckOtherCondition())
        return;
      // do stuff...
    }
    // do stuff...
  }
}

int main()
{
  frgleTheBrgls();
  std::cout << "yep, broke out of it\n";
}

This is much well-known (functions, you know, as in BASIC), clearer (the algorithm's got a nice name explaining what it does), and does exactly the same as yours does.

Especially the function version lacks because of the missing context where the loops are called, as you'd need to pass everything you need in the loops as parameters.

I see that as an advantage. You see exactly what is needed to frgle the brgls. Explicity, when programming, often is a good thing.

Answer 4

One drawback with your proposed syntax: you cannot have more than 2 nested loops. The 'goto' syntax allows this:

int main()
{
    for (;;)
    {
        for (;;)
        {
            for (;;)
            {
                if (CheckCondition1()) goto BREAK_ON_COND1;
                if (CheckCondition2()) goto BREAK_ON_COND2;
                if (CheckCondition3()) break;
                // Do stuff when all conditions are false
            }
            // Do stuff when condition 3 becomes true
        }
    BREAK_ON_COND2:
        // Do stuff when condition 2 becomes true
    }
BREAK_ON_COND1: // When condition 1 becomes true
    std::cout << "yep, broke out of it\n";
}