c++ switches Return inside/outside braces? break? [closed]

Question

In c++ you don't have to put braces {} inside cases in switch statements unless you're declaring a variable.

Consider the following code:

int Lesson82a() {
    int test = 1;
    switch (test) {
    case 1:
    {
        int i = 1;
        cout << i << "\n";
        cout << "Inside braces" << "\n";
        return 0;
    }
    case 2:
        cout << "2" << "\n";
    case 3:
        cout << "3" << "\n";
    }
    return -1;
}

int Lesson82b() {
    int test = 1;
    switch (test) {
    case 1:
    {
        int i = 1;
        cout << i << "\n";
    }
    cout << "Outside braces" << "\n";
    return 0;
    case 2:
        cout << "2" << "\n";
    case 3:
        cout << "3" << "\n";
    }
    return -1;
}

void Lesson82() {
    int test = Lesson82a();
    cout << test << "\n";
    test = Lesson82b();
    cout << test;
}

When running Lesson82() the output is as follows:

1
Inside braces
0
1
Outside braces
0

So the result is the same but does it make a difference?

1. Should i put braces always wheather i declare a variable or not?
2. If i put braces, does it matter if i put all my code for the case inside the braces? or only the code that needs the variable(s) i declare such as in Lesson82b() where i run some code and a return statement after the braces.
3. Should i put break; after return even though it's then unreachable?

Does it make a difference when it is compiled?

On line 122 here: https://github.com/microsoft/Windows-classic-samples/blob/main/Samples/Win7Samples/begin/LearnWin32/BaseWindow/cpp/main.cpp#L122 i couldn't understand why the return statement is outside the braces.

I tried experimenting but i get the same results in my code regardless of it.

Answer 1

Should i put braces always wheather i declare a variable or not?

Braces aren't needed in that case and unless you find it clearer that way, then no.

If i put braces, does it matter if i put all my code for the case inside the braces? or only the code that needs the variable(s) i declare such as in Lesson82b() where i run some code and a return statement after the braces.

No it doesn't. Only the code that needs access to the variable declared within the braces needs to be within the braces.

Should i put break; after return even though it's then unreachable?

No, that's completely unnecessary and doesn't improve reading in any way that I can see.

Answer 2

The switch statement’s cases do not require braces, period.

The purpose of braces is to create a local lexical context — that is, a space where one or more local variables may be created (and consequently given a specific, limited lifetime). In the case of a case clause in a switch statement, that lifetime must be limited. Consider:

switch (quux)
{
  case 1:
    int n = quux / 2;
    break;
  case 2:
    std::cout << "Hello " << n << "!\n";
    break;
}

If quux is 2, then what is the expected lifetime of n? Is it even created? When we attempt to print the value of n, is there even an n to print?

The answers are no. The targeted switch-case label jumps right over the code that creates it.

In C (before C23), it is a syntactic failure as well: the target of case labels must be a statement. But int n ... is a variable declaration.
^{Sorry, I misread your language tag as C. But I’ll leave this here since it is worthwhile info for C anyway.}

---

We could move the declaration to before the switch. Let’s try it:

int n;
switch (quux)
{
  case 1:
    n = quux / 2;
    break;
  case 2:
    std::cout << "Hello " << n << "!\n";
    break;
}

Now when quux is 2 we jump right over the code that initializes n with a value. With your compiler warnings turned up, you should definitely see something like:

error: 'n' may be used uninitialized

...which is UB.

---

These two examples are bad code. (IOW, don’t do that.) They exist solely to demonstrate the problem.

But suppose you have a construct like this:

int n;
switch (quux)
{
  case 1:
    n = quux / 2;
    std::cout << n << "\n";
    break;
  case 2:
    std::cout << "Hello world!\n";
    break;
}

Surely life is better, right?

Maybe. But the problems already noted still exist. You cannot declare n local to where it is used, and in those cases where it is not used, it is uninitialized. I cannot say whether or not this is actually consequential, but it is still something the compiler must think about, so it is.

Aaaand, it is a good idea anyway to make local variables only exist when and for as little time as needed.

---

The solution: create a local context using { curly braces }. This has always been how it works in C and, consequently, C++. It has always been totally valid to do something like:

int main(void)
{
  int sum = 0;             // x does not exist
  {                        // (new local context)
    int x = 10;            // x exists!
    while (x) sum += x--;  // x exists!
  }                        // (end of scope: x is destroyed)
  printf( "%d\n", sum );   // x does not exist
  return 0;                // x does not exist
}

We can apply this knowledge to use in switch statements.

switch (quux)
{
  case 1:
    {
      int n = quux / 2;
      std::cout << n << "\n";
    }
    break;
  case 2:
    std::cout << "Hello world!\n";
    break;
}

This is perfectly fine and valid. The case clauses only contain statements. n only exists in a local context. Everything is clear and, importantly, easy for the compiler (and us humans) to reason about.

---

Now, return and break statements are attached to very specific brace-enclosed contexts. The return is attached to a function’s brace-enclosed context. The break is attached to a switch (or a loop’s) context. (It is not attached to a case!)

That means that the position of return or break relative to a local brace-enclosed context is irrelevant. Both are valid:

switch (quux)                       |  switch (quux)
{                                   |  {
  case 1:                           |    case 1:
  {                                 |      {
    int n = quux / 2;               |        int n = quux / 2;
    std::cout << n << "\n";         |        std::cout << n << "\n";
    break;                          |      }
  }                                 |      break;
  case 2:                           |    case 2:
    std::cout << "Hello world!\n";  |      std::cout << "Hello world!\n";
    break;                          |      break;
}                                   |  }

In both of these cases the local context is properly terminated before the break jumps control to the end of the entire switch statement.

---

The list of statements following a case label are like any other list of statements: they may contain brace-enclosed local contexts in any fashion you wish.

switch (quux)
{
  case 1:
    {
      std::cout << "inside\n";
    }
    std::cout << "outside\n";
    {
      std::cout << "inside again, lol\n";
    }
    break;
}

Just... try to write readable code. This leads us to the final bit:

---

Brace-enclosed spaces are easily elided by the compiler when they serve no purpose. So using braces for stylistic reasons is fine:

switch (quux)
{
  case 1:
  {
    int n = quux / 2;
    std::cout << n << "\n";
    break;
  }
  case 2:
  {
    std::cout << "Hello world!\n";
    break;
  }
}