虚拟继承中的主导地位

Question

C++98/C++03 标准和 C++0x 未来标准的具体规则是什么 虚拟继承中的主导地位？

我不只是要求特定的段落，尽管我也要求特定的段落（我猜是在第 10 节的某个地方）。

我还想问标准语的后果，标准语解释得很清楚。

Answer 1

我认为这就是您正在寻找的语言。在 C++03 ISO 规范的 §10.2/2 中，我们有以下内容：

以下步骤定义了类作用域 C 中名称查找的结果。首先，每个声明
考虑类及其每个基类子对象中的名称。如果 A 是 B 的基类子对象，则一个子对象 B 中的成员名称 f 会隐藏子对象 A 中的成员名称 f。任何声明
那些如此隐藏的东西被排除在考虑之外。这些声明中的每一个都是由
using-declaration 被认为来自 C 的每个子对象，该子对象的类型包含 using-declaration 指定的声明。如果结果声明集并非全部来自子对象
具有相同类型，或者集合具有非静态成员并包含来自不同子对象的成员，则有
含糊不清，程序格式不正确。否则该集合就是查找的结果。

从较高的层次来看，这意味着当您尝试查找名称时，它会在所有基类和类本身中查找以查找该名称的声明。然后，您逐个类，如果其中一个基对象具有具有该名称的内容，它将隐藏该对象的任何基类中引入的所有名称。

这里的一个重要细节是这一行：

任何声明
如此隐藏的内容被排除在考虑范围之外。

重要的是，这表示如果某物被任何东西隐藏，则它被视为隐藏并删除。因此，例如，如果我这样做：

                            class D {
                            public:
                                void f();
                            }

   class B: virtual public D {        class C: virtual public D {
   public:                            public:
        void f();                         /* empty */
   };                                 };

                       class A: public B, public C {
                       public:
                           void doSomething() {
                                f(); // <--- This line
                           }
                       };

在指定的行上，对 f() 的调用将按如下方式解析。首先，我们将 B::f 和 D::f 添加到可以考虑的名称集中。 D::f 不会隐藏任何内容，因为 D 没有基类。但是，B::f 确实隐藏了 D::f，因此即使可以从 A< 访问 D::f /code> 没有看到 B::f，它被视为隐藏并从可以命名为 f 的对象集中删除。由于只剩下 B::f ，因此这就是被调用的那个。 ISO 规范提到 (§10.2/7)

当使用虚拟基类时，可以沿着通过子对象的路径到达隐藏声明
不通过隐藏声明的格子。这并不是含糊之处。 [...]

我认为这是因为上述规则。

在 C++11 中（根据草案规范 N3242），规则的拼写比以前更加明确，并且给出了实际的算法来计算名称的含义。这是语言，一步一步。

我们从 §10.2/3 开始：

C 中 f 的查找集称为 S(f, C)，由两个组件集组成：声明集，一组成员
名为f；以及子对象集，这是一组子对象，其中找到了这些成员的声明（可能包括 using 声明）。在声明集中，使用声明被替换为它们的成员。
指定，类型声明（包括注入类名）被它们指定的类型替换。
S(f,C)计算如下：

在本上下文中，C 指的是查找发生的范围。换句话说，集合 S(f, C) 的意思是“当我尝试在类作用域 Cf 时，可见的声明是什么”代码>？”为了回答这个问题，规范定义了一个算法来确定这个问题。第一步如下：(§10.2/4)

如果 C 包含名称 f 的声明，则声明集包含在中声明的 f 的每个声明
C 满足查找发生的语言结构的要求。 [...] 如果生成的声明集不为空，则子对象集包含 C
本身，计算完成。

换句话说，如果类本身声明了名为 f 的东西，那么声明集就是在该类中定义的名为 f 的东西的集合（或使用using 声明）。但是，如果我们找不到名为 f 的任何内容，或者名为 f 的所有内容的排序错误（例如，当我们需要类型时，却是函数声明），然后我们继续下一步：(§10.2/5)

否则（即，C 不包含 f 的声明或结果声明集为空），S(f, C) 最初为空。如果C有基类，计算每个直接基类子对象B_i中f的查找集，并依次合并每个这样的查找集S(f, B_i)代入 S(f, C)。

换句话说，我们将查看基类，计算名称在这些基类中可以引用的内容，然后将所有内容合并在一起。执行合并的实际方式在下一步中指定。这确实很棘手（它分为三个部分），所以这里是逐一介绍的。原文如下：(§10.2/6)

以下步骤定义将查找集 S(f, B_i) 合并到中间 S(f, C) 的结果：

• 如果 S(f, B_i) 的每个子对象成员是至少一个子对象的基类子对象
  S(f, C) 的成员，或者如果 S(f, B_i) 为空，则 S(f, C) 不变并且合并完成。相反，如果 S(f, C) 的每个子对象成员是至少一个的基类子对象
  S(f, B_i) 的子对象成员，或者如果 S(f, C) 为空，则新的 S(f, C) 是 S(f, Bi ) 的副本。

• 否则，如果 S(f, B_i) 和 S(f, C) 的声明集不同，则合并不明确：新的
  S(f, C) 是具有无效声明集和子对象集的并集的查找集。在随后的
  合并时，无效的声明集被视为与任何其他声明集不同。

• 否则，新的 S(f, C) 是一个具有共享声明集和声明的并集的查找集
  子对象集。

好吧，让我们一次一个地把它拆开。这里的第一条规则有两个部分。第一部分说，如果您尝试将一组空声明合并到整个集合中，则您根本不需要执行任何操作。这是有道理的。它还说，如果您尝试合并迄今为止已合并的所有内容的基类中的某些内容，那么您根本不需要执行任何操作。这很重要，因为这意味着如果您隐藏了某些内容，您不想通过将其合并回来而意外地重新引入它。

第一条规则的第二部分表示，如果您要合并的内容源自到目前为止已合并的所有内容，您都可以用为派生类型计算的数据替换到目前为止计算的集合。这本质上是说，如果您将许多看似互不相关的类合并在一起，然后合并到一个统一所有这些类的类中，则丢弃旧数据并仅使用您已经计算过的派生类型的数据。

现在让我们来看第二条规则。这花了我一段时间才理解，所以我可能有这个错误，但我认为它是说，如果你在两个不同的基类中进行查找并返回不同的东西，那么名称是不明确的，你应该报告某些东西是如果您此时尝试查找该名称，则错误。

最后一条规则说，如果我们不属于这两种特殊情况，则没有任何问题，您应该将它们结合起来。

唷……这太难了！让我们看看当我们追踪上面的钻石继承时会发生什么。我们想要查找以 A 开头的名称 f。由于 A 没有定义 f，因此我们计算从 B 和 开始查找 f 的值>f 从 C 开始。让我们看看会发生什么。当计算 B 中 f 的含义时，我们看到定义了 B::f，因此我们停止查找。在B中查找f的值是集合(B::f, B}。了解f在C中的含义，我们查看C，发现它没有定义f，所以我们再次从 D 中递归查找值。 D 产生 {D::f, D}，当我们将所有内容合并在一起时，我们发现规则 1 的后半部分适用（因为子对象集中的每个对象都是 D 的基数，这是毫无疑问的事实），因此 C 的最终值由 {D::fD::f 给出代码>，<代码>D}

。需要将 B 和 C 的值合并在一起，这会尝试合并 {D::f, D}。和 {B::f, B} ，这就是有趣的地方。假设我们按这个顺序合并。 code>, D} 和空集产生{D::f, D}。当我们现在合并到 {B::f, B} 时。 ，然后因为 D 是 B 的基数，根据规则一的后半部分，我们覆盖旧的集合并最终得到 {B::f< /代码>，<代码>B}。因此，f 的查找是B 中f 的版本。

另一方面，如果我们以相反的顺序合并，我们从 {B::f, B} 开始，并尝试在 {D:: f，D}。但由于 D 是 B 的基数，因此我们忽略它，留下 {B::f, B }。我们得到了相同的结果。很酷吧？我很惊讶这效果这么好！

现在你明白了——旧规则确实很简单，而新规则则复杂得难以置信，但无论如何都能解决。

希望这有帮助！