93

在 C++11 之前，我们只能对整型或枚举类型的静态 const 成员进行类内初始化。Stroustrup 在他的 C++ FAQ 中讨论了这一点，并给出了以下示例：

class Y {
  const int c3 = 7;           // error: not static
  static int c4 = 7;          // error: not const
  static const float c5 = 7;  // error: not integral
};

以及以下推理：

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

但是，C++11 放宽了这些限制，允许对非静态成员进行类内初始化（第 12.6.2/8 节）：

在非委托构造函数中，如果给定的非静态数据成员或基类不是由mem-initializer-id指定的（包括由于构造函数没有ctor-initializer而没有mem-initializer-list的情况）并且实体不是抽象类（10.4）的虚拟基类，则

  • 如果实体是具有大括号或相等初始化器的非静态数据成员，则实体按照 8.5 中的规定进行初始化；
  • 否则，如果实体是变体成员（9.5），则不执行初始化；
  • 否则，实体被默认初始化（8.5）。

9.4.2 节还允许对非常量静态成员进行类内初始化，如果它们用说明constexpr符标记的话。

那么我们在 C++03 中受到限制的原因是什么？我们只是简单地接受“复杂的链接器规则”还是进行了其他更改以使其更易于实现？

4

3 回答 3

70

简短的回答是他们保持链接器大致相同，但代价是使编译器比以前更复杂。

即，这不会导致链接器排序的多个定义，它仍然只导致一个定义，并且编译器必须对其进行排序。

它还导致程序员也需要整理一些更复杂的规则，但它大多足够简单，没什么大不了的。当您为单个成员指定了两个不同的初始化程序时，就会出现额外的规则：

class X { 
    int a = 1234;
public:
    X() = default;
    X(int z) : a(z) {}
};

现在，此时的额外规则处理a使用非默认构造函数时用于初始化的值。答案相当简单：如果您使用的构造函数没有指定任何其他值，那么1234将用于初始化a- 但如果您使用指定其他值的构造函数，则1234基本上会被忽略。

例如：

#include <iostream>

class X { 
    int a = 1234;
public:
    X() = default;
    X(int z) : a(z) {}

    friend std::ostream &operator<<(std::ostream &os, X const &x) { 
        return os << x.a;
    }
};

int main() { 
    X x;
    X y{5678};

    std::cout << x << "\n" << y;
    return 0;
}

结果：

1234
5678
于 2012-12-01T18:51:40.480 回答
9

理论上So why do these inconvenient restrictions exist?...理由是有效的，但它很容易被绕过，而这正是 C++ 11 所做的。

当您包含一个文件时，它只是包含该文件并忽略任何初始化。仅当您实例化类时才初始化成员。

也就是说，初始化还是和构造函数绑定的，只是记法不同，更方便。如果未调用构造函数，则不会初始化值。

如果调用构造函数，则使用类内初始化（如果存在）初始化值，或者构造函数可以使用自己的初始化覆盖它。初始化的路径本质上是一样的，都是通过构造函数。

这从 Stroustrup 自己的 C++ 11常见问题中可以看出。

于 2016-06-06T15:56:15.383 回答
9

我猜推理可能是在模板最终确定之前编写的。毕竟静态成员的类内初始化程序所需的所有“复杂的链接器规则”对于 C++11 支持模板的静态成员来说已经/是必要的。

考虑

struct A { static int s = ::ComputeSomething(); }; // NOTE: This isn't even allowed,
                                                   // thanks @Kapil for pointing that out

// vs.

template <class T>
struct B { static int s; }

template <class T>
int B<T>::s = ::ComputeSomething();

// or

template <class T>
void Foo()
{
    static int s = ::ComputeSomething();
    s++;
    std::cout << s << "\n";
}

编译器的问题在所有三种情况下都是相同的：它应该在哪个翻译单元中发出定义s和初始化它所需的代码？简单的解决方案是在任何地方发出它并让链接器对其进行排序。这就是为什么链接器已经支持诸如__declspec(selectany). 没有它就不可能实现 C++03。这就是为什么不需要扩展链接器的原因。

说得更直白一点：我认为旧标准中给出的推理是完全错误的。

更新

正如 Kapil 指出的那样，我的第一个示例在当前标准（C++14）中甚至是不允许的。无论如何我都把它留下了，因为 IMO 是实现（编译器、链接器）最困难的情况。我的观点是：即使这种情况并不比已经允许的情况更难，例如在使用模板时。

于 2016-01-29T18:29:34.943 回答