为什么我不能在类中初始化非常量静态成员或静态数组？

Question

为什么我不能在类中初始化非 const static 成员或 static 数组？

class A
{
    static const int a = 3;
    static int b = 3;
    static const int c[2] = { 1, 2 };
    static int d[2] = { 1, 2 };
};

int main()
{
    A a;

    return 0;
}

编译器发出以下错误：

g++ main.cpp
main.cpp:4:17: error: ISO C++ forbids in-class initialization of non-const static member ‘b’
main.cpp:5:26: error: a brace-enclosed initializer is not allowed here before ‘{’ token
main.cpp:5:33: error: invalid in-class initialization of static data member of non-integral type ‘const int [2]’
main.cpp:6:20: error: a brace-enclosed initializer is not allowed here before ‘{’ token
main.cpp:6:27: error: invalid in-class initialization of static data member of non-integral type ‘int [2]’

我有两个问题：

1. 为什么我不能在类中初始化static 数据成员？
2. 为什么我不能在课堂上初始化static数组，甚至是const数组？

Answer 1

为什么我不能初始化类中的static 数据成员？

C++ 标准只允许在类中初始化静态常量整数或枚举类型。这就是a 允许初始化而其他不允许初始化的原因。

参考：
C++03 9.4.2 静态数据成员
§4

如果静态数据成员是 const 整数或 const 枚举类型，它在类定义中的声明可以指定一个常量初始化器，它应该是一个整数常量表达式 (5.19)。在这种情况下，成员可以出现在整型常量表达式中。如果在程序中使用该成员，则该成员仍应在命名空间范围内定义，并且命名空间范围定义不应包含初始值设定项。

什么是整数类型？

C++03 3.9.1 基本类型
§7

bool、char、wchar_t 类型以及有符号和无符号整数类型统称为整数类型。43) 整数类型的同义词是整数类型。

脚注：

⁴³⁾ 因此，枚举（7.2）不是整数；但是，枚举可以提升为 int、unsigned int、long 或 unsigned long，如 4.5 中所述。

解决方法：

您可以使用 枚举技巧 在您的类定义中初始化一个数组。

class A 
{
    static const int a = 3;
    enum { arrsize = 2 };

    static const int c[arrsize] = { 1, 2 };

};

为什么标准不允许这样做？

Bjarne 恰当地解释了这一点here：

一个类通常在头文件中声明，头文件通常包含在许多翻译单元中。但是，为了避免复杂的链接器规则，C++ 要求每个对象都有唯一的定义。如果 C++ 允许在类内定义需要作为对象存储在内存中的实体，则该规则将被打破。

为什么只允许 static const 整数类型和枚举类内初始化？

答案隐藏在 Bjarne 的引文中仔细阅读，
“C++ 要求每个对象都有一个唯一的定义。如果 C++ 允许在类内定义需要存储的实体，则该规则将被打破在内存中作为对象。”

请注意，只有static const 整数可以被视为编译时常量。编译器知道整数值不会随时改变，因此它可以应用自己的魔法并应用优化，编译器只是内联此类成员，即它们不再存储在内存中，因为不需要存储在内存中，它为这些变量提供了 Bjarne 提到的规则的例外。

这里值得注意的是，即使static const 整数值可以进行类内初始化，也不允许获取此类变量的地址。当（且仅当）静态成员具有类外定义时，可以获取静态成员的地址。这进一步验证了上述推理。

枚举是允许的，因为枚举类型的值可以在需要整数的地方使用。^{参见上面的引用}

---

这在 C++11 中有何变化？

C++11在一定程度上放宽了限制。

C++11 9.4.2 静态数据成员
§3

如果静态数据成员是 const 字面量类型，它在类定义中的声明可以指定一个 brace-or-equal-initializer，其中每个 initializer-clause即 assignment-expression 是一个常量表达式。文字类型的静态数据成员可以在类定义中用constexpr specifier; 声明，如果是这样，它的声明应指定一个brace-or-equal-initializer，其中每个initializer-clause 即 assignment-expression 是一个常量表达式。 [ 注意：在这两种情况下，成员都可能出现在常量表达式中。 —end note ] 如果在程序中使用该成员，则该成员仍应在命名空间范围内定义，并且命名空间范围定义不应包含初始化程序。

此外，C++11 将允许（§12.6.2.8）一个非静态数据成员在它被声明的地方（在其类中）进行初始化。这将意味着更简单的用户语义。

请注意，这些功能尚未在最新的 gcc 4.7 中实现，因此您可能仍会遇到编译错误。

Answer 2

这似乎是过去简单链接器的遗留物。您可以在静态方法中使用静态变量作为解决方法：

// header.hxx
#include <vector>

class Class {
public:
    static std::vector<int> & replacement_for_initialized_static_non_const_variable() {
        static std::vector<int> Static {42, 0, 1900, 1998};
        return Static;
    }
};

int compilation_unit_a();

和

// compilation_unit_a.cxx
#include "header.hxx"

int compilation_unit_a() {  
    return Class::replacement_for_initialized_static_non_const_variable()[1]++;
}

和

// main.cxx
#include "header.hxx"

#include <iostream>

int main() {
    std::cout
    << compilation_unit_a()
    << Class::replacement_for_initialized_static_non_const_variable()[1]++
    << compilation_unit_a()
    << Class::replacement_for_initialized_static_non_const_variable()[1]++
    << std::endl;
}

构建：

g++ -std=gnu++0x -save-temps=obj -c compilation_unit_a.cxx 
g++ -std=gnu++0x -o main main.cxx compilation_unit_a.o

运行：

./main

这个工作的事实（始终如一，即使类定义包含在不同的编译单元中）表明今天的链接器（gcc 4.9.2）实际上足够聪明。

有趣：在手臂上打印0123，在 x86 上打印3210。

Answer 3

这是因为A::a只能有一个定义，所有翻译单元都使用。

如果您在包含在所有翻译单元中的标头中的类中执行static int a = 3;，那么您将获得多个定义。因此，静态的非行外定义会强制导致编译器错误。

使用static inline 或static const 可以解决此问题。 static inline 仅在符号用于翻译单元时将其具体化，并确保链接器仅在由于它位于 comdat 组中而在多个翻译单元中定义时选择并保留一个副本。文件范围内的const 使编译器永远不会发出符号，因为它总是在代码中立即被替换，除非使用extern，这在类中是不允许的。

需要注意的一点是static inline int b; 被视为定义，而static const int b 或static const A b; 仍被视为声明，如果您未在类中定义它，则必须离线定义它。有趣的是，static constexpr A b; 被视为定义，而static constexpr int b; 是一个错误，必须有一个初始化程序（这是因为它们现在变成了定义，并且像文件范围内的任何 const/constexpr 定义一样，它们需要一个 int 没有的初始化程序' t 有但一个类类型有，因为当它是一个定义时它有一个隐式的= A()——clang 允许这样做，但 gcc 要求你显式初始化，否则它是一个错误。这不是 inline 的问题）。 static const A b = A(); 是不允许的，并且必须是 constexpr 或 inline 以便允许具有类类型的静态对象的初始化程序，即使类类型的静态成员多于声明。所以是的，在某些情况下A a; 与显式初始化A a = A(); 不同（前者可以是声明，但如果该类型只允许声明，则后者是错误的。后者只能用于定义。constexpr 使其成为定义）。如果您使用constexpr 并指定默认构造函数，则构造函数将需要为constexpr

#include<iostream>

struct A
{
    int b =2;
    mutable int c = 3; //if this member is included in the class then const A will have a full .data symbol emitted for it on -O0 and so will B because it contains A.
    static const int a = 3;
};

struct B {
    A b;
    static constexpr A c; //needs to be constexpr or inline and doesn't emit a symbol for A a mutable member on any optimisation level
};

const A a;
const B b;

int main()
{
    std::cout << a.b << b.b.b;
    return 0;
}

静态成员是一个直接的文件范围声明extern int A::a;（只能在类中进行，并且行外定义必须引用类中的静态成员并且必须是定义并且不能包含外部）而非-static 成员是类的完整类型定义的一部分，并且与没有extern 的文件范围声明具有相同的规则。它们是隐含的定义。所以 int i[]; int i[5]; 是一个重定义，而 static int i[]; int A::i[5]; 不是，但与 2 个 extern 不同，如果你在类中执行 static int i[]; static int i[5];，编译器仍然会检测到重复的成员。

Answer 4

我认为这是为了防止您混淆声明和定义。 （想想如果在多个位置包含文件可能会出现的问题。）

Answer 5

静态变量特定于一个类。构造函数特别为实例初始化属性。