关于C++ constexpr静态数据成员定义与使用场景的技术咨询

Great question! You’ve already got the hang of using constexpr static members for compile-time constant replacement (like defining array sizes), but the confusion around cases where the compiler can’t just substitute the raw value makes total sense. Let’s break down how to handle these scenarios properly:

1. For C++17 and Later: No Extra Work Needed #

Starting in C++17, constexpr static data members are implicitly inline. This means the in-class initialization you’ve already written acts as both a declaration and a definition. You can use the member in any scenario—including when you need its memory address or a reference to it—without adding anything else:

class test{
public:
    static constexpr int stc = 1;
private:
    int a = 0;
    int b = 0;
    int c = 0;
};

int main() {
    // This works perfectly in C++17+
    const int &a = test::stc;
    const int* p = &test::stc;
    
    // Still works for compile-time substitutions too
    int array[test::stc];
    return 0;
}

The compiler automatically handles creating the memory entity for you, so no linker errors will pop up.

2. For C11/C14: Add an Out-of-Class Definition #

Before C++17, the in-class initialization of a constexpr static member is only a declaration, not a full definition. If you need to use the member in a context that requires its memory identity (like references, pointers, or functions that take a const T& parameter), you must add an out-of-class definition (no need to reassign the value—this is just to tell the linker where the entity lives):

class test{
public:
    static constexpr int stc = 1; // Declaration + initial value
private:
    int a = 0;
    int b = 0;
    int c = 0;
};

// Mandatory out-of-class definition for C++11/C++14
constexpr int test::stc;

int main() {
    // Now these work without linker errors
    const int &a = test::stc;
    const int* p = &test::stc;
    
    int array[test::stc]; // Still valid for compile-time use
    return 0;
}

Omitting this out-of-class definition will lead to a linker error, as the linker can’t find the actual memory location of test::stc.

3. When Do You Need the Memory Entity? #

As a rule of thumb, you need the member to have a defined memory entity whenever you’re not just using its compile-time value directly. Common scenarios include:

• Binding the member to a reference (const T& = Class::static_member)
• Taking the member’s address (&Class::static_member)
• Passing the member to a function that accepts a const T& parameter (if the function doesn’t just treat it as a compile-time value)

Compile-time contexts (like array sizes, non-type template parameters) don’t require the memory entity—these just use the constant value directly.

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