预期的行为是什么？

Question

下面是纯粹学术上发明的阶级层次结构。

struct X{
        void f1();
        void f2();
        void f3();
};

struct Y : private X{
        void f4();
};

struct Z : X{
};

struct D : Y, Z{
        using X::f2;
        using Z::X::f3;
};

int main(){}

我预计使用 X::f2 的声明是不明确的，因为“X”是“D”的不明确基数（X 的可见性与可访问性）。然而 g++ (ideone.com) 可以很好地编译它。

我检查了 Online Comeau，它在使用 X::f2 的声明时出现了预期的错误。然而，它也给使用 Z::X::f3 的声明带来了歧义。

那么预期的行为是什么？

编辑 1：

请参考该标准的相应部分。

编辑2：

我检查了VS 2010，它仅对using声明X::f2有异议。然而，这与“X”的歧义无关（如 gcc 和 Comeau 的情况）。它是关于“错误 C2876：'X'：并非所有重载均可访问”。

编辑 3：

struct X{
    void f(){}
};

struct Y : X{
    struct trouble{
        void f(){}
    };

};

struct trouble : X{
};

struct letscheck : Y, trouble{
    using trouble::f;
};

int main(){}

在这里，我尝试（有目的地）在 using 声明中创建类型问题。 Gcc 仍然可以很好地编译，VS2010 也是如此。 Comeau 仍然给出关于不明确类型“麻烦”的错误（如预期）。根据最初查询的解释，GCC 和 VS2010 似乎是错误的。这是正确的吗？

Answer 1

我不认为这些都是不规范的。首先，对于使用X::f2，会查找X，这将明确产生类类型X。然后查找X中的f2，这也是明确的（它不会在D中查找！）。

出于同样的原因，第二种情况也会起作用。

但是，如果您在 D 对象上调用 f2，则调用将是不明确的，因为名称 f2 被查找D 的 X 类型的所有子对象中都存在，并且 D 有两个这样的子对象，并且 f2 是一个非-静态成员函数。同样的原因也适用于第二种情况。无论您直接使用 Z::X 还是 X 命名 f3，都没有什么区别。这两个都指定类X。

为了使 using 声明具有歧义，您需要以不同的方式编写它。请注意，在 C++0x 中 using ThisClass::...; 无效。但在 C++03 中，只要整个名称引用基类成员即可。

相反，如果 C++0x 中允许这样做，则整个 using 声明也将有效，因为 C++0x 不会明确地考虑子对象进行名称查找：D::f2仅指一个声明（X中的声明）。请参阅 DR #39 和最终论文N1626。

struct D : Y, Z{
    // ambiguous: f2 is declared in X, and X is a an ambiguous base class
    using D::f2;
 
    // still fine (if not referred to by calls/etc) :)
    using Z::X::f3;
};

struct E : D {
  // ambiguous in C++03
  // fine in C++0x (if not referred to by an object-context (such as a call)).
  using D::f2;
};

C++03 标准在 10.2 和 3.4.3.1 段落中对此进行了描述。

---

Edit3的回应：

是的，GCC和VS2010是错误的。 trouble 指的是通过注入的类名 ::trouble 找到的类型以及以 Y::trouble 形式找到的嵌套类。 :: 之前的名称 trouble 使用非限定查找进行查找（通过 3.4.1/7，委托给 10.2< /code> 在第一个项目符号中）忽略任何对象、函数和枚举器名称（3.4.3/1 - 但在本例中没有这样的名称）。它违反了 10.2 的要求：

如果生成的声明集并非全部来自同一类型的子对象...则程序格式错误。

---

VS2010 和 GCC 对 C++0x 措辞的解释可能与 Comeau 不同，并追溯实现该措辞：

在用作成员声明的 using 声明中，嵌套名称说明符应命名所定义类的基类。

这意味着会考虑非基类，但如果命名非基类，则会出现错误。如果标准打算忽略非基类名称，它会说只能在这里，或者明确地拼写出来（两种做法都已完成）。然而，该标准并不因使用应和可以而产生。 GCC 实现了 C++0x 措辞，因为它拒绝其他完全良好的 C++03 代码，只是因为 using 声明包含其类名。

对于措辞不明确的示例，请考虑以下表达式：

a.~A();

这在语法上是不明确的，因为如果 a 是类对象，则它可以是成员函数调用，但它可以是伪析构函数调用（这是一个无操作）如果 a 具有标量类型（例如 int）。但标准所说的是分别在 5.2.4 和 5.2.5 处的伪析构函数调用和类成员访问的语法

点运算符的左侧应为标量类型。

对于第一个选项（点），第一个表达式（对象表达式）的类型应为“类对象”（完整类型）。

这是错误的用法，因为它根本无法消除歧义。它应该使用“can only”，并且编译器以这种方式解释它。正如一些委员会成员最近在新闻组上告诉我的那样，这主要是历史原因。请参见国际标准的结构和起草规则，附件 H。

Answer 2

使用 X::f2；由于以下代码的私有继承，不应该工作

struct Y : private X{
    void f4();
};

不可能通过 Y 访问 X 的成员。
所以 X::f2 会发生冲突。

Z::X::f2 应该可以工作。
或者 Z::f2 应该可以工作。

Answer 3

首先，澄清约翰内斯的答案。当您说 using Z::X::f2; 时，编译器不会“构建到 f2 的路径”来跟踪应如何访问它。由于 Z::X 与 X 相同，因此声明与 using X::f2; 完全相同。与此示例进行对比：

struct A { void f() {} void g() {} };
struct B { void f() {} void g() {} };
struct C { typedef A X; };
struct D { typedef B X; };
struct E : A, B {
    using C::X::f; // C::X == A
    using D::X::g; // D::X == B
};

语法 Z::X 之所以有效，不是因为继承或成员身份，而是因为标识符 X 可以从范围 Z 访问代码>.你甚至可以写出让人恶心的 Z::Z::Z::Z::X::X::X::X ，因为每个类都将自己的名称带入自己的作用域中。因此这里的 :: 并不表示继承。

现在，来解决问题。 f2 由 Y 和 Z 从 X 继承。因此，它是 Y 和 Z 的一流成员。 E 不需要了解 X，因为它是隐藏的实现细节。所以，你想

struct D : Y, Z{
    using Y::f2; // error: inaccessible
    using Z::f3;
};

---

按照你的要求用 9.1/2 来解释：

类名被插入到
声明的范围
紧接在类名之后
看到了。类名也被插入
进入类本身的范围；
这被称为
注入类名。

名称 X 作为 X::X 注入到 X 中。然后它被继承到 Y 和 Z 中。 Y 和 Z 不会在自己的作用域中隐式声明 X。

10.2/2：

以下步骤定义类中名称查找的结果
范围，C。首先，每个声明
班级和每个班级中的姓名
它的基类子对象是
经过考虑的。 ……
如果生成的声明集
并非全部来自子对象
相同类型，或者该集合有一个
非静态成员和包含成员
从不同的子对象中，有一个
歧义，程序是
格式不正确。否则该集合就是
查找结果。

请注意，我将复数单词子对象加粗。虽然名称X出现在两个子对象中，但它们都是相同的类型，即X。