你必须在类定义之外定义你的静态成员，并在那里提供初始化式。

第一个

// In a header file (if it is in a header file in your case)
class A {   
private:      
  static const string RECTANGLE;
};

然后

// In one of the implementation files
const string A::RECTANGLE = "rectangle";

您最初尝试使用的语法(类定义中的初始化式)只允许整型和枚举类型。

从c++ 17开始，你有另一个选项，这与你最初的声明非常相似:内联变量

// In a header file (if it is in a header file in your case)
class A {   
private:      
  inline static const string RECTANGLE = "rectangle";
};

不需要额外的定义。

在c++ 17中，你可以使用内联变量:

class A {
 private:
  static inline const std::string my_string = "some useful string constant";
};

注意，这与深渊不同。7的回答:它定义了一个真正的std::string对象，而不是const char*

快进到2018年和c++ 17。

do not use std::string, use std::string_view literals please do notice the 'constexpr' bellow. This is also an "compile time" mechanism. no inline does not mean repetition no cpp files are not necessary for this static_assert 'works' at compile time only using namespace std::literals; namespace STANDARD { constexpr inline auto compiletime_static_string_view_constant() { // make and return string view literal // will stay the same for the whole application lifetime // will exhibit standard and expected interface // will be usable at both // runtime and compile time // by value semantics implemented for you auto when_needed_ = "compile time"sv; return when_needed_ ; } };

以上是一个适当的、合法的标准c++公民。它可以很容易地涉及到任何和所有std::算法、容器、实用程序等。例如:

// test the resilience
auto return_by_val = []() {
    auto return_by_val = []() {
        auto return_by_val = []() {
            auto return_by_val = []() {
return STANDARD::compiletime_static_string_view_constant();
            };
            return return_by_val();
        };
        return return_by_val();
    };
    return return_by_val();
};

// actually a run time 
_ASSERTE(return_by_val() == "compile time");

// compile time 
static_assert(
   STANDARD::compiletime_static_string_view_constant() 
   == "compile time" 
 );

享受标准c++吧

类静态变量可以在头文件中声明，但必须在.cpp文件中定义。这是因为一个静态变量只能有一个实例，而编译器无法决定将它放在哪个生成的对象文件中，所以你必须做出决定。

将静态值的定义与c++ 11中的声明保持一致 可以使用嵌套的静态结构。在本例中是static成员 是一个结构，必须在.cpp文件中定义，但值 都在头文件中。

class A
{
private:
  static struct _Shapes {
     const std::string RECTANGLE {"rectangle"};
     const std::string CIRCLE {"circle"};
  } shape;
};

不是初始化单个成员，而是在.cpp中初始化整个静态结构:

A::_Shapes A::shape;

访问这些值

A::shape.RECTANGLE;

或者——因为成员是私有的，只能从A - with中使用

shape.RECTANGLE;

注意，这个解决方案仍然受到的顺序问题的影响 静态变量的初始化。当使用静态值时 初始化另一个静态变量，第一个可能没有初始化， 然而。

// file.h
class File {
public:
  static struct _Extensions {
    const std::string h{ ".h" };
    const std::string hpp{ ".hpp" };
    const std::string c{ ".c" };
    const std::string cpp{ ".cpp" };
  } extension;
};

// file.cpp
File::_Extensions File::extension;

// module.cpp
static std::set<std::string> headers{ File::extension.h, File::extension.hpp };

在这种情况下，静态变量头将包含{""} 或{".h"， ".hpp"}，这取决于链接器创建的初始化顺序。

正如@abyss提到的。7如果变量的值可以在编译时计算，你也可以使用constexpr。但是如果你用静态constexpr const char*声明你的字符串，并且你的程序使用std::string，否则就会有开销，因为每次你使用这样的常量都会创建一个新的std::string对象:

class A {
public:
   static constexpr const char* STRING = "some value";
};
void foo(const std::string& bar);
int main() {
   foo(A::STRING); // a new std::string is constructed and destroyed.
}

在c++ 11中，你现在可以做到:

class A {
 private:
  static constexpr const char* STRING = "some useful string constant";
};

你可以使用上面提到的const char*解决方案，但是如果你总是需要字符串，你将会有很多开销。 另一方面，静态字符串需要动态初始化，因此如果你想在另一个全局/静态变量初始化期间使用它的值，你可能会遇到初始化顺序的问题。为了避免这种情况，最便宜的方法是通过getter访问静态字符串对象，getter检查对象是否已初始化。

//in a header  
class A{  
  static string s;   
public:   
  static string getS();  
};  
//in implementation  
string A::s;  
namespace{  
  bool init_A_s(){  
    A::s = string("foo");   
    return true;  
  }  
  bool A_s_initialized = init_A_s();  
}  
string A::getS(){      
  if (!A_s_initialized)  
    A_s_initialized = init_A_s();  
  return s;  
}  

记住只使用A::getS()。因为任何线程只能由main()启动，并且A_s_initialized在main()之前初始化，所以即使在多线程环境中也不需要锁。默认情况下A_s_initialized为0(在动态初始化之前)，因此如果在s初始化之前使用getS()，则可以安全地调用init函数。

顺便说一句，在上面的答案:“static const std::string RECTANGLE() const”，静态函数不能是const，因为它们不能改变任何对象的状态(没有this指针)。