对于这个问题的未来观众，我想指出您应该避免monkey0506所建议的内容。

头文件用于声明。

对于每个直接或间接包含头文件的.cpp文件，头文件将被编译一次，并且在main()之前在程序初始化时运行任何函数之外的代码。

通过输入:foo::i = VALUE;对于每个.cpp文件，foo:i将被赋值value(不管它是什么)，并且这些赋值将以不确定的顺序(由链接器决定)在main()运行之前发生。

如果我们在其中一个。cpp文件中#define VALUE为不同的数字会怎样?它将编译良好，我们将无法知道哪个胜出，直到我们运行程序。

永远不要将执行的代码放入头文件中，这与您永远不要#include .cpp文件的原因相同。

Include守卫(我同意你应该经常使用)保护你不受一些不同情况的影响:在编译一个.cpp文件时，同一个头文件被间接地多次# Include。

我遵循卡尔的想法。我喜欢它，现在我也在用它。 我稍微改变了一下符号，增加了一些功能

#include <stdio.h>

class Foo
{
   public:

     int   GetMyStaticValue () const {  return MyStatic();  }
     int & GetMyStaticVar ()         {  return MyStatic();  }
     static bool isMyStatic (int & num) {  return & num == & MyStatic(); }

   private:

      static int & MyStatic ()
      {
         static int mStatic = 7;
         return mStatic;
      }
};

int main (int, char **)
{
   Foo obj;

   printf ("mystatic value %d\n", obj.GetMyStaticValue());
   obj.GetMyStaticVar () = 3;
   printf ("mystatic value %d\n", obj.GetMyStaticValue());

   int valMyS = obj.GetMyStaticVar ();
   int & iPtr1 = obj.GetMyStaticVar ();
   int & iPtr2 = valMyS;

   printf ("is my static %d %d\n", Foo::isMyStatic(iPtr1), Foo::isMyStatic(iPtr2));
}

这个输出

mystatic value 7
mystatic value 3
is my static 1 0

以下是一个简单例子中的所有可能性和错误……

#ifndef Foo_h
#define Foo_h

class Foo
{
  static const int a = 42; // OK
  static const int b {7};  // OK
  //static int x = 42; // ISO C++ forbids in-class initialization of non-const static member 'Foo::x'
  //static int y {7};  // ISO C++ forbids in-class initialization of non-const static member 'Foo::x'
  static int x;
  static int y;
  int m = 42;
  int n {7};
};

// Foo::x = 42;  // error: 'int Foo::x' is private
int Foo::x = 42; // OK in Foo.h if included in only one  *.cpp -> *.o file!
int Foo::y {7};  // OK

// int Foo::y {7};  // error: redefinition of 'int Foo::y'
   // ONLY if the compiler can see both declarations at the same time it, 
   // OTHERWISE you get a linker error

#endif // Foo_h

但最好把它放在Foo.cpp中。这样你就可以单独编译每个文件并在以后链接它们，否则Foo:x将出现在多个目标文件中，并导致链接器错误. ...

// Foo::x = 42;  // error: 'int Foo::x' is private, bad if Foo::X is public!
int Foo::x = 42; // OK in Foo.h if included in only one  *.cpp -> *.o file!
int Foo::y {7};  // OK

从c++ 17开始，静态成员可以在头文件中用inline关键字定义。

http://en.cppreference.com/w/cpp/language/static

静态数据成员可以内联声明。内联静态数据成员可以在类定义中定义，并且可以指定默认成员初始化式。它不需要一个类外定义:

struct X
{
    inline static int n = 1;
};

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

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

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

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

您遇到的链接器问题可能是由以下原因引起的:

在头文件中提供类和静态成员定义， 在两个或多个源文件中包含此头文件。

对于那些从c++开始学习的人来说，这是一个常见的问题。静态类成员必须在单个翻译单元中初始化，即在单个源文件中初始化。

不幸的是，静态类成员必须在类体之外初始化。这使得只写头的代码变得复杂，因此，我使用了完全不同的方法。你可以通过静态或非静态类函数来提供你的静态对象，例如:

class Foo
{
    // int& getObjectInstance() const {
    static int& getObjectInstance() {
        static int object;
        return object;
    }

    void func() {
        int &object = getValueInstance();
        object += 5;
    }
};