“显式”构造函数对重载决议的影响

Question

为什么下面的代码无法编译，当我在A类中去掉构造函数前的显式关键字时，它会编译？

使用 Visual Studio 2013：

enum E { e1_0, e1_1 };

template<typename T>
struct A
{
    A() {}
    explicit A(unsigned long) {}
    A(T) {}
};

struct B
{
    B() {}
    B(E) {}
};


void F(B) {};
void F(A<short>) {};

void test()
{
    F(e1_0);
}

错误：

1>------ Build started: Project: exp_construct_test, Configuration: Debug Win32 ------
1>  exp_construct_test.cpp
1>e:\exp_construct_test\exp_construct_test.cpp(23): error C2668: 'F' : ambiguous call to overloaded function
1>          e:\exp_construct_test\exp_construct_test.cpp(19): could be 'void F(A<short>)'
1>          e:\exp_construct_test\exp_construct_test.cpp(18): or       'void F(B)'
1>          while trying to match the argument list '(E)'
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

编辑：我下载了 clang 并使用 clang-cl 编译，这两种情况都报告了错误。因此，正如评论中所指出的，歧义在A<short>(short) 和B(E) 之间。

所以也许 VC++ 中存在一个错误，当我从 A(unsigned long) 中删除 explicit 时，无论出于何种意图，编译器都会选择 B(E) 来引发歧义错误。谁能确认 clang 行为符合标准，而 VC++ 有问题？

我加了

void G(E) {};
void G(short) {};

然后像这样调用 G：

G(e1_0);

不会引发任何错误。 为什么这里G(E)是首选，而对于候选人A<short>::A(short)和B::B(E)，他们是模棱两可的？

结束编辑

谢谢 --joja

Answer 1

让我们一个接一个地看看您的示例的各种变体。

1. 调用f(e0)的原始示例。

   enum E {e0, e1};
   
   template<typename T>
   struct A
   {
     A();  // (1)
     explicit A(unsigned long);  // (2)
     A(T);  // (3)
   };
   
   struct B
   {
     B();  // (4)
     B(E);  // (5)
   };
   
   void f(A<short>);  // (6)
   void f(B);  // (7)
   
   void g(E);  // (8)
   void g(short);  // (9)
   

   三种可能性中

   • 将e0 转换为unsigned long，通过构造函数(2) 从中创建A<short> 并调用重载(6)，
   • 将e0 转换为short，通过构造函数(3) 从中创建A<hort> 并调用重载(6) 和
   • 通过构造函数 (5) 从 e0 创建 B 并调用重载 (7)

   第一个选项不适用，因为 (2) 是 explicit。其余两个都涉及用户定义的转换，它们被认为同样好，没有一个是有利于另一个的。调用不明确，程序格式错误。

2. 让我们从构造函数中删除explicit并调用f(e0)。

   template<typename T>
   struct A
   {
     A();  // (1)
     A(unsigned long);  // (2)
     A(T);  // (3)
   };
   
   struct B
   {
     B();  // (4)
     B(E);  // (5)
   };
   

   这三个选项保持不变，但这次，所有三个都适用，而且调用（甚至更）模棱两可，程序格式错误。

3. 让我们将两个构造函数都设为explicit 并调用f(e0)。

   template<typename T>
   struct A
   {
     A();  // (1)
     explicit A(unsigned long);  // (2)
     explicit A(T);  // (3)
   };
   
   struct B
   {
     B();  // (4)
     B(E);  // (5)
   };
   

   这使得隐式构造 A<short> 和调用明确引用重载 (5) 成为不可能。

4. 让我们也将B 的构造函数设为explicit 并调用f(e0)。

   template<typename T>
   struct A
   {
     A();  // (1)
     explicit A(unsigned long);  // (2)
     explicit A(T);  // (3)
   };
   
   struct B
   {
     B();  // (4)
     explicit B(E);  // (5)
   };
   

   这一次，三种转换路径中的 无 是适用的，因为每个转换路径都将通过 explicit 构造函数。没有适用的f 重载并且程序格式错误。

5. 致电g(e0)。

   这里有两种可能：

   • 调用重载 (8) 没有任何转换或
   • 将 e0 转换为 short 并调用重载 (9)。

   在这两个中，第一个选项显然是有利的，因为它不涉及转换。电话是明确的。 （即使构造函数（5）不是explicit。）

请注意，默认构造函数 (1) 和 (4) 实际上对本次讨论没有任何贡献。使用 GCC 4.9.1 进行测试，所有五个示例的行为都符合预期。