Let’s break down exactly why your first code snippet won’t compile, and walk through the ways to work around this issue.

The Core Reason #

C++ enforces a strict rule: case labels in a switch statement must be compile-time constant expressions.

In your first example, val is a non-static const member variable. Even though you initialized it with = 1 in the class, this value is set when a Foo object is constructed at runtime. When the compiler processes the switch in bar(), it’s actually looking at this->val (since non-static members are tied to a specific instance of the class). this is a runtime value—there’s no way for the compiler to guarantee val will be the same across all Foo objects (a subclass could override this initialization, for example). That’s exactly why GCC throws the error: use of ‘this’ in a constant expression.

In contrast, the local const int val = 1 in your second snippet is a compile-time constant. The compiler can confirm its value is fixed before the program runs, so it’s allowed as a case label.

How to Use Member Variables with Switch Logic #

Here are the most common solutions, depending on your needs:

1. Make the Member static const (or static constexpr) #

By declaring val as a static class member, you turn it into a class-wide constant that exists independently of any object. The compiler can resolve its value at compile time, making it valid for case labels:

class Foo{
public:
    static const int val = 1; // Compile-time constant, shared across all Foo instances
    void bar(){
        switch (1){
            case val:
                // ...
                break;
            default:
                // ...
                break;
        }
    }
};

For C++17 and later, you can use inline static const or inline static constexpr to define the variable directly in the class (no need for a separate .cpp file definition).

2. Use an if-else Chain (for Per-Object Values) #

If you need val to be unique per Foo instance (i.e., its value varies at runtime), switch statements won’t work. Instead, use an if-else chain, which accepts runtime values:

class Foo{
public:
    const int val = 1;
    void bar(){
        int target = 1;
        if (target == val) {
            // Logic for matching case
        } else {
            // Logic for default case
        }
    }
};

3. Use static constexpr for Strict Compile-Time Checks #

If you want the strongest guarantee that val is a compile-time constant, declare it as static constexpr (C++11 and later):

class Foo{
public:
    static constexpr int val = 1;
    void bar(){
        switch (1){
            case val:
                // ...
                break;
            default:
                // ...
                break;
        }
    }
};

内容的提问来源于stack exchange，提问作者theStroyer