Would an break-less switch/case be feasible?

Question

Would the suggestion to have a syntax for a switch that does not need breaks all the time feasible?

My suggestion would be to insert auto both before switch and each case:

auto switch(expr) {
  auto case 1: statement; statement;
  auto case 2: statement; statement;
  default: statement; statement;
}

would be equivalent to

switch(expr) {
  case 1: statement; statement; break;
  case 2: statement; statement; break;
  default: statement; statement;
}

The compiler would complain with an error

• if in a auto switch any case is not prepended with auto or
• if a auto case is used in an auto-less switch.

Is there any parser problem to be expected, any ambiguities?

Is there additional benefit from less wrong-use-errors of users, like better optimization possibilities?

Update

A slightly more useful case would be where the location of the break is not so clear:

case(expr) {
  case 1:
      if(isThisTrue) {
        print(that);
      } else {
        break;
      }
      doSomethingElse();
      if(!isThisTrue) {
        break;
      }

...or something like this.

I think prevention of fall-through is useful to prevent some difficult to diagnose errors.

Answer 1

This won't be a thing for many reasons!

• The most obvious: it doesn't save any time totype auto rather than break

• It is a lot less readable. Just like nobody would recommend the use of goto, your proposition is hard to decypher. Imagine a long case block, a reader would have to keep in mind this auto keyword the whole time he is reading the block. Unless you are using a lot of goto, c++ is pleasant to read because you don't to go up and down in the code constantly.

• A case statement might not systematically break, and if I choose to add a condition that skips the break, your auto would most likely be forgotten and annoy me when compiling.

• auto already means something. Adding new keywords to a language can be annoying, but re-using some with a different meaning is just bad!

To answer your question, at last: no this wouldn't cause any parsing issue. Just replace auto case[...]auto by case[...]break. You can, actually, define your own macro to do exacly this! And by doing so you will probably realize why it is not necessary.

Something like:

#define AUTO(x) x break;
switch(i){
case 1: std::cout<<1;
AUTO case 2: std::cout<<2;
AUTO default: std::cout<<i
}

Note: This macro is kinda twisting your point, I know. There's definitely a way to do something closer to what you have in mind, I'll think about it and update when I have time.