How to break out from loop inside switch C++

Question

Let's consider:

switch(x)
{
case something:
    {
        for(something_else : some_container)
        {
             if(a_condition)
             {
             // BREAK OUT OF THE SWITCH
             }
        }
        some_statements();
        break;
        }
}

How can I escape in the most elegant way from the loop which is inside a switch statement since I do not want to run some_statements();.

Certainly a well placed goto would nicely solve this problem, but the solution can be considered anything but elegant:

switch(x)
{
case something:
    {
        for(something_else : some_container)
        {
             if(a_condition)
             {
                  goto escape_route;
             }
        }
        some_statements();
        break;
        }
}
escape_route:
// Hurrah, freedom

And also a flag would solve this problem:

switch(x)
{
case something:
    {
        bool flag = true;
        for(something_else : some_container)
        {
             if(a_condition)
             {
                  flag = false;
                  break;
             }
        }
        if(flag)
        {
            some_statements();
        }
        break;
        }
}

But let's just say, that I am looking for other solutions for this problem for the challenge's sake (Please note: There are more statements after the switch, returning is not an option).

Any ideas?

That `goto` looks okay. Don't overthink it -- you'll only make it more tangled. — Quentin, Mar 03 '17 at 12:01
Why do you consider `goto` to not be "elegant"? It's clear, simple, and clean - pretty much the **definition** of elegant. — Andrew Henle, Mar 03 '17 at 12:02
The loop and `some_statements` probably should be in a function. Then you can just return and let the `switch`'s `break` handle the rest. Complex stuff like loops that can `break` inside a `switch` looks overly complex to begin with. — Baum mit Augen, Mar 03 '17 at 12:06
That throw and catch the exception can do break but may not looks elegant. — Chen OT, Mar 03 '17 at 12:19
**don't** use exception handling for normal flow control.... normal flow control is _not_ an exception. — JHBonarius, Mar 03 '17 at 12:22

score 4 · Answer 1 · edited Jul 03 '17 at 12:43

In general this is one of the few cases, where using gotos is often considered ok. However, since c++11 I prefer to use an immediately invoked lambda and a return statement:

[&]{
    switch(x)
    {
    case something:
        {
            for(something_else : some_container)
            {
                if(a_condition)
                {
                    return ;
                }
             }
             some_statements();
             break;
         }
     }
}(); //<- directly invokes the lambda

And once you have this, think if you might want to put the whole block into a separate named function.

score 1 · Answer 2 · answered Mar 03 '17 at 12:16

1

The goto version is ok but a better alternative might be to use a function and return from it upon an exceptional condition:

status_t func (void)
{
  status_t status = default_value;

  switch(x)
  {
    case something:
    {
      for(something_else : some_container)
      {
        if(a_condition)
        {
          return status;
        }
      }
      some_statements();
      break;
    }
  }

  return status;
}

The advantage here is that it allows you to use a status variable (for error codes etc).

Another alternative is exception handling.

answered Mar 03 '17 at 12:16

Lundin

195,001
40
254
396

3

Exception handling as flow control? Please don't ever do that... – Quentin Mar 03 '17 at 12:17
@Quentin Depends on what "a_condition" means, doesn't it? – Lundin Mar 03 '17 at 12:18
It does, but I'd expect OP to mention it if it were actually error handling and not program logic. – Quentin Mar 03 '17 at 12:22

score 0 · Answer 3 · answered Mar 03 '17 at 12:08

That goto looks okay. Don't overthink it -- you'll only make it more tangled.

That's for the general case, though. Your specific use looks like it can be folded into a nice call to an <algorithm>.

switch(x)
{
case something:
    {
        if(std::any_of(
            begin(some_container),
            end(some_container),
            [](auto &&e) { return a_condition(e); }
        ))
            break;

        some_statements();
        break;
    }
}

Notice that this calls a function which does the early returning, and immediately breaks out if it returned true.
Yes, you can mimick this pattern with your own function/lambda in place of std::any_of.
No, it's not a good idea if your function does not make sense on its own like std::any_of does.

score 0 · Answer 4 · answered Mar 03 '17 at 16:20

I would probably split the function into sub functions, removing your need of break inside the loop, something like:

void foo(/*...*/)
{
    for (auto something_else : some_container) {
         if (a_condition) {
             return;
         }
    }
    some_statements();
}

And then

switch (x)
{
    case something:  { foo (/*...*/); break; }
    case something2: { foo2(/*...*/); break; }
    case something3: { foo3(/*...*/); break; }
    // ...
}

How to break out from loop inside switch C++

4 Answers4