在C ++类中初始化静态变量？

我注意到，我在类中的某些函数实际上并未访问该对象，因此我将它们制成了static。然后编译器告诉我，它们访问的所有变量也必须是静态的-到目前为止，还可以理解。我有一堆字符串变量，例如

string RE_ANY = "([^\\n]*)";
string RE_ANY_RELUCTANT = "([^\\n]*?)";

等等。然后，我将它们全部制成，static const因为它们永不改变。但是，我的程序只有在将它们移出类时才进行编译：否则，MSVC ++ 2010会抱怨“只能在类中初始化静态常数积分变量”。

好吧，这很不幸。有解决方法吗？我想把它们留在他们所属的类中。

它们不能在类内部初始化，但是可以在类外部在源文件中初始化：

// inside the class
class Thing {
    static string RE_ANY;
    static string RE_ANY_RELUCTANT;
};

// in the source file
string Thing::RE_ANY = "([^\\n]*)";
string Thing::RE_ANY_RELUCTANT = "([^\\n]*?)";

更新资料

我只注意到你的问题的第一线-你不希望使这些功能static，你想他们const。使它们static成为对象意味着它们不再与对象关联（因此它们不能访问任何非静态成员），使数据成为静态对象意味着它将与该类型的所有对象共享。这可能不是您想要的。设置它们const只是意味着它们不能修改任何成员，但仍然可以访问它们。

迈克·西摩（Mike Seymour）为您提供了正确的答案，但要补充一点……正如编译器所告诉的那样，
C ++使您只能在类主体中声明和定义静态const整数类型。因此，您实际上可以执行以下操作：

class Foo
{
    static const int someInt = 1;
    static const short someShort = 2;
    // etc.
};

而且您不能使用任何其他类型来执行此操作，在这种情况下，应在.cpp文件中定义它们。

静态成员变量必须在类中声明，然后在其外部定义！

没有解决方法，只需将其实际定义放在源文件中即可。

从您的描述中，闻起来好像您没有以正确的方式使用静态变量。如果它们从不改变，则应改用常量变量，但是您的描述太笼统了，不能多说。

静态成员变量对于类的任何实例始终具有相同的值：如果您更改一个对象的静态变量，则所有其他对象的静态变量也会改变（实际上，您也可以在没有类实例的情况下访问它们-即：一个对象）。

从C ++ 11开始，可以使用来在类内部完成此操作constexpr。

class stat {
    public:
        // init inside class
        static constexpr double inlineStaticVar = 22;
};

现在可以通过以下方式访问该变量：

stat::inlineStaticVar

我觉得值得补充的是，静态变量与常量变量并不相同。

在类中使用常量

struct Foo{
    const int a;
    Foo(int b) : a(b){}
}

我们会像这样声明它

fooA = new Foo(5);
fooB = new Foo(10);
// fooA.a = 5;
// fooB.a = 10;

对于静态变量

struct Bar{
    static int a;
    Foo(int b){
        a = b;
    }
}
Bar::a = 0; // set value for a

像这样使用

barA = new Bar(5);
barB = new Bar(10);
// barA.a = 10;
// barB.a = 10;
// Bar::a = 10;

你看这里发生了什么。与Foo的每个实例一起实例化的常量变量，因为Foo的实例化对于Foo的每个实例具有单独的值，并且Foo根本不能更改它。

与Bar一样，它们仅是Bar :: a的一个值，无论制作了多少Bar实例。它们都共享此值，您也可以将其作为Bar的任何实例进行访问。静态变量还遵守public / private的规则，因此您可以使只有Bar的实例才能读取Bar :: a;的值。

只是在其他答案之上。为了初始化复杂的静态成员，您可以按照以下步骤进行操作：

照常声明静态成员。

// myClass.h
class myClass
{
static complexClass s_complex;
//...
};

如果不是很简单，请编写一个小函数来初始化您的类。这将仅在静态成员初始化时被调用。（请注意，将使用complexClass的副本构造函数，因此应明确定义）。

//class.cpp    
#include myClass.h
complexClass initFunction()
{
    complexClass c;
    c.add(...);
    c.compute(...);
    c.sort(...);
    // Etc.
    return c;
}

complexClass myClass::s_complex = initFunction();

一些答案似乎有点误导。

你不必...

• 分配一个值初始化的时候，因为赋值是一些静态的对象可选。
• 创建另一个.cpp文件进行初始化，因为它可以在同一Header文件中完成。

同样，您甚至可以使用inline关键字在同一类范围内初始化静态对象，就像普通变量一样。

在同一文件中没有任何值初始化

#include <string>
class A
{
    static std::string str;
    static int x;
};
std::string A::str;
int A::x;

用同一文件中的值初始化

#include <string>
class A
{
    static std::string str;
    static int x;
};
std::string A::str = "SO!";
int A::x = 900;

使用inline关键字在同一类范围内初始化

#include <string>
class A
{
    static inline std::string str = "SO!";
    static inline int x = 900;
};

如果您的目标是初始化标头文件（而不是* .cpp文件，如果您坚持使用“仅标头”的习惯用法，则可能要使用该标头）中的静态变量，则可以通过使用模板。模板化的静态变量可以在标头中初始化，而不会导致定义多个符号。

请参阅此处的示例：

类模板中的静态成员初始化

（可选）将所有常量移动到.cpp文件，而无需在.h文件中声明。使用匿名名称空间使它们在cpp模块之外不可见。

// MyClass.cpp

#include "MyClass.h"

// anonymous namespace
namespace
{
    string RE_ANY = "([^\\n]*)";
    string RE_ANY_RELUCTANT = "([^\\n]*?)";
}

// member function (static or not)
bool MyClass::foo()
{
    // logic that uses constants
    return RE_ANY_RELUCTANT.size() > 0;
}