使用带有默认情况和lambda函数的switch语句时出现gcc错误

Question

I do not understand why this code

#include <iostream>

class A {
    public:


    void foo(){
        char g = 'm';
        switch(g){
            case 'g':
                auto f = [](){std::printf("hello world\n");};
                f();
                break;
//            default:
//                std::printf("go to hell\n");
//                break;
        }
    };
};



int main(int iargc, char *iargv[]){
    A a;
    a.foo();
}

compiles (and works) fine, whereas when uncommenting the default statement

#include <iostream>

class A {
    public:


    void foo(){
        char g = 'm';
        switch(g){
            case 'g':
                auto f = [](){std::printf("hello world\n");};
                f();
                break;
            default:
                std::printf("go to hell\n");
                break;
        }
    };
};



int main(int iargc, char *iargv[]){
    A a;
    a.foo();
}

gives me the following error message

test.cpp:15:13: error: jump to case label [-fpermissive]
         default:
         ^
test.cpp:12:22: error:   crosses initialization of ‘A::foo()::__lambda0 f’
             auto f = [](){std::printf("hello world\n");};

I can use a default statement, if I comment out the lambda function.

I am using gcc 4.8.5.

Answer 1

You need to enclose your case 'g' body in braces. This is not because of the lambda per se, but due to the creation of any new variable in a case statement.

Without the default I suppose it doesn't complain because there's only one place the execution can flow. But with default and no braces, you have a problem because the scope of f extends to the default code but it won't be initialized there.

Answer 2

The error message tells you exactly what the problem is. Jumping to the default label goes from a point where f is not in scope to a point where it is in scope, skipping its initialization.

The relevant rule from the standard is:

6.7 Declaration statement [stmt.dcl]

It is possible to transfer into a block, but not in a way that bypasses declarations with initialization. A program that jumps from a point where a variable with automatic storage duration is not in scope to a point where it is in scope is ill-formed unless the variable has scalar type, class type with a trivial default constructor and a trivial destructor, a cv-qualified version of one of these types, or an array of one of the preceding types and is declared without an initializer (8.6).

When you only have one case for the switch there is no way to jump over the initialization, because the only place you can enter the switch statement is at the first case label, which doesn't miss out the initialization. If you don't bypass the initialization of the variable then there's no problem.

You don't get the error for types like double or int because they are scalar types (so if you jump over their initialization they are in scope, but uninitialized). The closure type created by the lambda is not a scalar type, and is not declared without an initializer.

Answer 3

switch(g){
  case 'g':
    auto f = [](){std::printf("hello world\n");};
    f();
    break;
  default:
    std::printf("go to hell\n");
    break;
}

A switch transfers control to one of it's labels. All these labels are in the single block introduced by the switch statement.

The standard (N4296 §6.7/3) says (emphasis mine):

It is possible to transfer [control] into a block, but not in a way that bypasses declarations with initialization . A program that jumps from a point where a variable with automatic storage duration is not in scope to a point where it is in scope is ill-formed unless the variable has scalar type, class type with a trivial default constructor and a trivial destructor, a cv-qualified version of one of these types, or an array of one of the preceding types and is declared without an initializer.

Thus, because it is possible to transfer control directly to the default label, past the declaration and initialization of the lambda f (which is not trivially constructible), your program is ill-formed and is rightfully rejected by the compiler.

Answer 4

wrap your code between braces or it is considered as the same block.

Jumping to default skips variable declaration.

case 'g':
    {
                auto f = [](){std::printf("hello world\n");};
                f();
                break;
    }