C++类成员名称查找问题（关于标准 n3225 的措辞）

Question

我对标准10.2/13很困惑，

[ 注意：即使名称查找的结果明确，使用在多个子对象中找到的名称可能仍然不明确 (4.11, 5.2.5, 5.3.1, 11.2)。—end note ] [ 示例：< /p>

struct B1 {
  void f();
  static void f(int);
  int i;
};
struct B2 {
  void f(double);
};
struct I1: B1 { };
struct I2: B1 { };
struct D: I1, I2, B2 {
  using B1::f;
  using B2::f;
  void g() {
    f(); // Ambiguous conversion of this
    f(0); // Unambiguous (static)
    f(0.0); // Unambiguous (only one B2)
    int B1::* mpB1 = &D::i; // Unambiguous
    int D::* mpD = &D::i; // Ambiguous conversion
  }
};

我不明白为什么这是明确的 int B1::* mpB1 = &D::i; // Unambigious

Visual C++、Gcc 和 CLang 都说对 D::i 的访问是二义性的！

这个措辞似乎与核心问题#39有关 http://www.open-std.org/jtc1 /sc22/wg21/docs/cwg_defects.html#39，最终提案在这里：http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1626.pdf

我现在发现新的基于算法的措辞（10.2/3-10.2/6）更令人困惑，因为10.2/9、10.2/10、10.2/11和10.2/13中的注释均不完全符合10.2/3-10.2/6。我可以将 10.2/9-10.2/11 作为例外，但我对 10.2/13 特别困惑。我不知道10.2/13的意图。

10.2/13中的例子应该如何根据10.2/3-10.2/6进行查找？ 10.2/13的用意是什么，即10.2/13被视为10.2/3-10.2/6的例外情况是什么？

请给我一些提示。非常感谢。

---

经过一番思考，我认为10.2/13的意图对我来说更加清晰。

int B1::* mpB1 = &D::i; // 明确

这应该是明确的，当前的编译器在这方面是错误的。这是明确的，因为指向类成员初始化的指针尚不涉及访问对象。

int D::* mpD = &D::i; // 不明确的转换

这实际上意味着当从 int B1::*mpB1 转换为 int D::*mpD 时，由于基类不明确，转换是不明确的。

Answer 1

对于 B1::* 情况，解释是明确的，只是从 B1 的开头到 i 的偏移量。

在 5.3.1/3 中：

struct A { int i; };
struct B : A { };
... &B::i ... // has type int A::*

所以技巧是首先让 &D::i 的类型为 B1::* 。那么：

int B1::* mpB1 = &D::i; // Unambiguous

很简单。然后兴趣就来了：

int D::* mpD = &D::i; // Ambiguous conversion

这里的 RHS 是 B1::* 类型，需要转换，因为我们需要确定引用的是哪个基数。

Answer 2

这

int B1::* mpB1 = &D::i; // Unambiguous

是明确的，因为结果被分配给 B 类的成员指针。
因此，选择哪个 i 并不重要，因为偏移量是相对于 B 成员（而不是父 D 类）的。

所以它对你和我来说都是明确的，但我认为编译器无法处理它。

Answer 3

快速检查一下 ISO IEC 14882 2003 第 10 节，没有此示例或类似的内容。 C++0x 是草案标准，VC++/GCC/CLang 不符合它。

我的猜测：这是新的自动输入的一些副产品，在旧的 C++ 标准中找不到。

Answer 4

FWIW，我正在复制我对该问题的 usenet 副本的回答：

大家好，
 
我对标准n3225 10.2/13很困惑，
 
[ 注意：即使名称查找的结果明确，也可以使用
在多个子对象中找到的名称可能仍然不明确（4.11，
5.2.5, 5.3.1, 11.2).—尾注] [ 示例：
 

struct B1 {
  void f();
  static void f(int);
  int i;
};
struct B2 {
  void f(double);
};
struct I1: B1 { };
struct I2: B1 { };
struct D: I1, I2, B2 {
  using B1::f;
  using B2::f;
  void g() {
    f(); // Ambiguous conversion of this
    f(0); // Unambiguous (static)
    f(0.0); // Unambiguous (only one B2)
    int B1::* mpB1 = &D::i; // Unambiguous
    int D::* mpD = &D::i; // Ambiguous conversion
  }
};

我不明白为什么这是明确的 int B1::* mpB1 = &D::i; //
明确
 

&D::i 具有类型 int B1::*，并且明确引用 的数据成员 i
B1。如果您使用 D 对象取消引用它，或者将其分配给 int 
D::*，您将根据需要得到歧义。

Visual C++、Gcc 和 CLang 都说对 D::i 的访问不明确！
 

这些编译器都还没有实现 10.2。

这个措辞似乎与核心问题#39有关
http://www.open-std.org/jtc1 /sc22/wg21/docs/cwg_defects.html#39，以及
最终提案在这里：
http://www.open-std.org /jtc1/sc22/wg21/docs/papers/2004/n1626.pdf
 
我现在发现新的基于算法的写法（10.2/3-10.2/6）是
更令人困惑的是，10.2/9、10.2/10 中没有任何注释，
10.2/11和10.2/13完全符合10.2/3-10.2/6。我可以带
10.2/9-10.2/11作为例外，但我特别困惑
10.2/13。我不知道10.2/13的意图。
 

你需要举例说明你不明白的地方。 

10.2/13中的例子应该如何根据
10.2/3-10.2/6？ 10.2/13的意图是什么，即是什么
其中 10.2/13 被视为例外情况
10.2/3-10.2/6？
 

基于新算法的查找规则解耦了运行时问题（查找一个）
唯一的对象）从编译时/查找问题（找到一个声明，
名称指）。

以下内容采用新的措辞，格式良好：

struct Z { int z; };
struct X : Z { };
struct Y : Z { };
struct A : X, Y { };

struct B : A {
  using A::z;
};

声明 using A::x; 将一个成员名称引入到 B 中，该成员名称引用了
声明Z::z。在声明性上下文中，这完全没问题。一个
仅当您将 B::z 作为成员访问表达式访问时才会出现错误
(5.2.5)。

不要因为在成员指针的情况下犯了这样的错误而感到难过。 我过去也这样做过，相应的问题报告实际上已经变成了 C+ +0x 草稿。幸运的是，当他们注意到这一点时，将其改回改变是错误的。