C++ compilation error: Static members cannot be initialized by constant expressions, how to solve it?

In C programming, static members are public properties of a class. They can be accessed without relying on a specific object, because its life cycle is the same as that of the class, with only one copy. But when using static members, sometimes you will encounter a compilation error that static members cannot be initialized by constant expressions. So how does this error occur and how to solve it? This article will introduce it from two aspects.

1. The reason why static members cannot be initialized by constant expressions

In the C 11 standard, the concept of constant expression constexpr is introduced, which refers to the result that can be calculated at compile time expression. You can use constexpr to define constants, for example:

constexpr int max(int a, int b) {
    return a > b ? a : b;
}

When using this function, the compiler can calculate the result at compile time, so max(1, 2) can be regarded as a constant expression. Its result is 2. But when using static members, if you try to use a constant expression to initialize static member variables, a compilation error will occur. For example:

class MyClass {
public:
    static constexpr int m_value = 10; // 编译错误
};

This is because the initialization order of static members is related to the calculation order of constant expressions. In C, static members are initialized in the order of declaration, and constant expressions are evaluated at compile time, so if a static member depends on a constant expression, it must be guaranteed to be initialized after the constant expression.

2. Methods to solve the problem that static members cannot be initialized by constant expressions

There are three methods to solve this problem, namely:

1. Use integer constant expressions to Initializing static members

An integer constant expression is a special kind of constant expression that only involves integer literals, arithmetic operators, and functions or members without side effects. For static member variables, you can use integer constant expressions to initialize, for example:

class MyClass {
public:
    static const int m_value = 10; // 正确
};

For other types of static member variables, you can also use this method, just make sure that you use integer constant expressions for initialization formula is enough.

2. Use inline variables

In the C 17 standard, the concept of inline variables was introduced, which allows variables to be defined in header files without causing the problem of multiple definitions. For static member variables, you can use inline variables to initialize, for example:

class MyClass {
public:
    inline static int m_value = 10; // 正确
};

Using inline variables can avoid the problem that static members cannot be initialized by constant expressions. It is also more convenient and does not need to be in the source file. Define variables individually.

3. Use delayed initialization

Delayed initialization refers to initializing static member variables when they need to be used. This method can avoid the problem that static members cannot be initialized by constant expressions, for example:

class MyClass {
public:
    static int& m_value() {
        static int s_value = 10;
        return s_value;
    }
};

Returning a reference through a static member function, and then initializing it when the static member variable needs to be used, can avoid the problem that static members cannot be initialized by constant expressions. The advantage of this approach is that you can flexibly control the initialization timing of static member variables as needed, while also avoiding unnecessary initialization when the program starts.

Summary

Static members are public properties of the class. They can be accessed without relying on a specific object. However, when using static members, sometimes you encounter static members that cannot be used by constant expressions. Initialization compilation error. The reason for this problem is that the initialization order of static members is related to the evaluation order of constant expressions. In order to solve this problem, you can use integer constant expressions to initialize static members, use inline variables to initialize static members, or use lazy initialization to avoid the problem that static members cannot be initialized by constant expressions. Which method to choose depends on the specific situation and needs to be chosen flexibly based on actual needs.

The above is the detailed content of C++ compilation error: Static members cannot be initialized by constant expressions, how to solve it?. For more information, please follow other related articles on the PHP Chinese website!