我在这里没有足够的代表来添加这一点作为注释，但在我看来，无论如何使用#include守卫来编写头文件是一种很好的风格，正如Paranaix几小时前指出的那样，这可以防止多重定义错误。除非已经使用了单独的CPP文件，否则没有必要只使用一个文件来初始化静态的非整型成员。

#ifndef FOO_H
#define FOO_H
#include "bar.h"

class foo
{
private:
    static bar i;
};

bar foo::i = VALUE;
#endif

我认为没有必要为此使用单独的CPP文件。当然，你可以这样做，但是没有技术上的理由必须这样做。

如果使用头保护，也可以在头文件中包含赋值。我在自己创建的c++库中使用了这种技术。实现相同结果的另一种方法是使用静态方法。例如……

class Foo
   {
   public:
     int GetMyStatic() const
     {
       return *MyStatic();
     }

   private:
     static int* MyStatic()
     {
       static int mStatic = 0;
       return &mStatic;
     }
   }

上面的代码有一个“好处”，就是不需要CPP/源文件。同样，这是我在c++库中使用的方法。

使用Microsoft编译器[1]，不像int型的静态变量也可以在头文件中定义，但在类声明之外，使用Microsoft特定的__declspec(selectany)。

class A
{
    static B b;
}

__declspec(selectany) A::b;

请注意，我并不是说这是好的，我只是说这是可以做到的。

现在，比MSC更多的编译器支持__declspec(selectany)——至少gcc和clang。甚至更多。

如果你想初始化一些复合类型(f.e. string)，你可以这样做:

class SomeClass {
  static std::list<string> _list;

  public:
    static const std::list<string>& getList() {
      struct Initializer {
         Initializer() {
           // Here you may want to put mutex
           _list.push_back("FIRST");
           _list.push_back("SECOND");
           ....
         }
      }
      static Initializer ListInitializationGuard;
      return _list;
    }
};

由于ListInitializationGuard是SomeClass::getList()方法中的一个静态变量，它将只被构造一次，这意味着构造函数被调用一次。这将初始化_list变量为你需要的值。任何后续对getList的调用都将返回已经初始化的_list对象。

当然，您必须始终通过调用getList()方法访问_list对象。

这符合你的目的吗?

//header file

struct MyStruct {
public:
    const std::unordered_map<std::string, uint32_t> str_to_int{
        { "a", 1 },
        { "b", 2 },
        ...
        { "z", 26 }
    };
    const std::unordered_map<int , std::string> int_to_str{
        { 1, "a" },
        { 2, "b" },
        ...
        { 26, "z" }
    };
    std::string some_string = "justanotherstring";  
    uint32_t some_int = 42;

    static MyStruct & Singleton() {
        static MyStruct instance;
        return instance;
    }
private:
    MyStruct() {};
};

//Usage in cpp file
int main(){
    std::cout<<MyStruct::Singleton().some_string<<std::endl;
    std::cout<<MyStruct::Singleton().some_int<<std::endl;
    return 0;
}

我在这里没有足够的代表来添加这一点作为注释，但在我看来，无论如何使用#include守卫来编写头文件是一种很好的风格，正如Paranaix几小时前指出的那样，这可以防止多重定义错误。除非已经使用了单独的CPP文件，否则没有必要只使用一个文件来初始化静态的非整型成员。

#ifndef FOO_H
#define FOO_H
#include "bar.h"

class foo
{
private:
    static bar i;
};

bar foo::i = VALUE;
#endif

我认为没有必要为此使用单独的CPP文件。当然，你可以这样做，但是没有技术上的理由必须这样做。