初始化与类相同类型的静态成员（静态初始化顺序问题）

Question

假设我有一个类Super，其中我有一个Super 类型的静态成员，它只定义了一个常用的Super 实例

// super.hpp
class Super
{
public:
    Super(const double a):
        m_a(a)
    {}

    double a() const { return m_a; }

    static const Super thing; // use this a lot in code

private:
    double m_a;
};

实施

// super.cpp
#include "super.hpp"

const Super Super::thing = Super(1.0); // definition

在这一点上我认为一切都很好，但如果不是，请纠正我。

现在我也有Super 的子类，具有类似的静态成员

// sub.hpp
#include "super.hpp"

class Sub : public Super
{
public:
    Sub(const double a):
        Super(a)
    {}

    explicit Sub(const Super& obj):
        Super(obj)
    {}

    static const Sub thing;
};

实施

// sub.hpp
#include "sub.hpp"

const Sub Sub::thing = Sub(Super::thing); // WORKS IN MYSTERIOUS WAYS

最后是一个示例用法

// main.cpp
#include <iostream>
#include "sub.hpp"

int main()
{
    Super super = Super::thing;
    std::cout << super.a() << std::endl;

    Sub sub = Sub::thing;
    std::cout << sub.a() << std::endl;
}

当我使用以下设置编译它时

// CMakeLists.txt
project (hello)
add_executable(hello main.cpp super.cpp sup.cpp)

我得到了预期的输出

$ ./hello 
1
1

但是如果我在CMakeLists 中更改cpp 文件的顺序（sub.cpp 在super.cpp 之前）

// CMakeLists.txt
project (hello)
add_executable(hello main.cpp sup.cpp super.cpp)

我明白了

$ ./hello 
1
0

我认为这是static initialization order ‘fiasco’(?)的一个例子，我对它发生的原因有所了解。

所以问题变成了：有什么方法可以得到关于未初始化静态的警告，或者有什么方法可以避免这个问题？

我已经阅读了How do I prevent the “static initialization order problem”?，但我希望能够保留Sub::thing 接口，并避免将其替换为Sub::thing()。

Answer 1

有什么方法可以得到关于未初始化静态的警告，

我不知道

或者有什么方法可以避免这个问题？

• 您可能会避免使用全局成员，并使用延迟初始化将全局包装在一个函数中，因此更改：

  // header
  class Super {
      static const Super thing;
      // ...
  };
  //  cpp file
  const Super Super::thing = Super(1.0); // definition
  

  到

  // header
  class Super {
      static const Super& thing();
      // ...
  };
  //  cpp file
  const Super& Super::thing() { static const Super instance{1.0}; return instance; }
  

  类似

  class Sub : public Super
  {
  public:
      // ...
      static const Sub thing;
  };
  
  // sub.cpp
  const Sub Sub::thing = Sub(Super::thing); 
  

  通过

  class Sub : public Super
  {
  public:
      // ...
      static const Sub& thing();
  };
  
  // sub.cpp
  const Sub& Sub::thing() { static const Sub instance(Super::thing()); return instance; }
  

• 或者将所有全局放在一个翻译单元中，因为顺序是有保证的。

  // global.cpp
  #include "super.hpp"
  #include "sub.hpp"
  
  const Super Super::thing = Super(1.0);    // Defined in order
  const Sub Sub::thing = Sub(Super::thing); // so you have control
  

Answer 2

根据您的 cmets，我做了以下操作：

• 构造函数constexpr
• 制作了static成员constexpr inline（你必须将它们放入头文件，而不是.cpp），所以需要C++17

现在，您的静态变量是 constexpr，因此它们将被静态初始化，因此静态初始化顺序的失败不会发生在它们身上。

所以，这个解决方案对我有用：

class Super
{
public:
    constexpr Super(const double a):
        m_a(a)
    {}

    double a() const { return m_a; }

    static const Super thing;

private:
    double m_a;
};

constexpr inline Super Super::thing = Super(1.0);

class Sub : public Super
{
public:
    constexpr Sub(const double a):
        Super(a)
    {}

    constexpr explicit Sub(const Super& obj):
        Super(obj)
    {}

    static const Sub thing;
};

constexpr inline Sub Sub::thing = Sub(Super::thing);

#include <iostream>

int main()
{
    Super super = Super::thing;
    std::cout << super.a() << std::endl;

    Sub sub = Sub::thing;
    std::cout << sub.a() << std::endl;
}