When can I leave out "break" in switch loop? [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 5 years ago.
Improve this question
I just solved 1st exercise on learncpp, chaper 7.8. I tested their version of switch loop and it works, but I wonder it's without break, shouldn't in this case such code cause undesired behavior? When can I leave out break?
Here is my version(which also works correctly):
switch (op)
{
case '+': {
return add;
break;}
case '-': {
return subtract;
break;}
case '*': {
return multiply;
break;}
case '/': {
return divide;
break;}
default: ;
}

Answer 1

Without break, the flow of execution will simply continue to the next case - unless you jump in some other way of course (like returning, in your case). This is known as fall-through.
Whether this is a bug or not depends on the program. It can be useful if (for example) you want multiple cases to have the same action:
switch (op)
{
case '+':
return add;
break; // these breaks do nothing - we have already returned!
case '-':
return subtract;
break;
case 'x': // fall through to '*'
case '*':
return multiply;
break;
case '/':
return divide;
break;
}

Answer 2

Note that C++ does not insist on your using break, but often switch cases depend on them, to obviate the useful follow through feature.
You can remove a break with no effect on your program if program control never reaches it: None of the break statements after the return statements are reachable, so you can safely remove them.
You also don't need an empty default label either.

Answer 3

Since you are new to C++, consider that:
Anytime your code reaches a return statement, your current function/method will end and return the specified valued without executing any more line of codes. So your break statements are never going to be reached.
When a break is reached, the current switch, while or for will end. And the flow will continue outside of its scope {...}.
If you do not use break in a switch case then the flow just continues (even to the next case).

Answer 4

It may be useful to you to understand what a switch is doing under the covers.
essentially this:
enum command {
add, subtract, multiply, divide, error
};
command foo(char op)
{
switch (op)
{
case '+': {
return add;
break;}
case '-': {
return subtract;
break;}
case '*': {
return multiply;
break;}
case '/': {
return divide;
break;}
default:
break;
}
return error;
}
Is logically the same as this:
command foo_that_will_give_people_seizures(char op)
{
if (op == '+') goto plus_;
if (op == '-') goto minus_;
if (op == '*') goto mpy_;
if (op == '/') goto div_;
goto break_;
plus_:
return add;
goto break_; // notice how this statement cannot be reached.
minus_:
return subtract;
mpy_:
return multiply;
div_:
return divide;
break_:
;
return error;
}
and the statement break; appearing in any of the cases in the first function is equivalent to goto break_ in the second.
ps. you won't win any friends writing code like this. People like to pretend that goto is a bad thing in c++ ;-)

Answer 5

You should be aware that break should be left out on default: (if the default is the last case) where the code flow basically reaches the end and doesn't need to get break.
The very purpose of break is to prevent code to continue to next case(s) when the actual case is true. return however, returns the given statement in the case and breaks the switch. If you are considering to return inside switch cases, then instead of using break, you may use return foobar; It will break by returning whatever you wish to return.