Ambiguous string::operator= 调用隐式转换为 int 和 string 的类型

Question

给定以下程序：

#include <iostream>
#include <string>
using namespace std;
struct GenericType{
   operator string(){
      return "Hello World";
   }
   operator int(){
      return 111;
   }
   operator double(){
      return 123.4;
   }
};
int main(){
   int i = GenericType();
   string s = GenericType();
   double d = GenericType();
   cout << i << s << d << endl;
   i = GenericType();
   s = GenericType(); //This is the troublesome line
   d = GenericType();
   cout << i << s << d << endl;
}

它可以在 Visual Studio 11 上编译，但不能在 clang 或 gcc 上编译。它遇到了麻烦，因为它想从 GenericType 隐式转换为 int 到 char 但它也可能返回 string ，因此存在歧义（operator=(char) 和 operator=(string) 都匹配GenericType)。

但是，复制构造函数很好。

我的问题是：如何在不修改 main 内容的情况下解决这种歧义？我需要做些什么来修改GenericType 来处理这种情况？

Answer 1

我相信gcc和clang是正确的。

有两个operator= 重载在起作用：

string& operator=(string const& str); // (1)
string& operator=(char ch);           // (2)

这两个operator= 重载都需要从GenericType 类型的参数进行用户定义的转换。 (1) 需要使用到string 的转换。 (2) 需要使用到int 的转换，然后是到char 的标准转换。

重要的是这两个重载都需要用户定义的转换。要确定这些转换中的一个是否比另一个更好，我们可以查看重载解析规则，特别是 C++11 §13.3.3.2/3 中的以下规则（为清晰起见重新格式化）：

用户定义的转换序列U1是比另一个用户定义的转换序列U2更好的转换序列如果

1. 它们包含相同的用户定义的转换函数或构造函数或聚合初始化和

2. U1的第二个标准转换序列优于U2的第二个标准转换序列。

请注意，and 将规则的两个部分连接起来，因此必须满足两个部分。不满足规则的第一部分：两个自定义转换序列使用不同的自定义转换函数。

因此，两种转换都不是更好，而且调用是模棱两可的。

[关于如何在不更改main() 的定义的情况下解决问题，我没有很好的建议。隐式转换通常不是一个好主意；它们有时非常有用，但更常见的是它们可能会导致重载模糊或其他奇怪的重载行为。]

有一个 gcc 错误报告描述了这个问题，并按设计解决了：compiler incorrectly diagnoses ambigous operator overload.

Answer 2

我相信 GCC 是错误的。在 Bjarne Stroustrup 的“The C++ Programming Language”一书中，有一整章专门讨论运算符重载。在第 11.4.1 节中，第一段是这样说的：

“如果存在赋值运算符 X::operator=(Z) 使得 V 为 Z 或存在 V 到 Z 的唯一转换，则将 V 类型的值赋值给 X 类的对象是合法的。初始化被同等对待。”

在您的示例中，GCC 接受“string s = GenericType();”然而拒绝“s = GenericType();”，所以它显然没有像初始化一样对待赋值。那是我的第一个线索，在 GCC 中出现了问题。

GCC 在分配中报告了 3 个将 GenericType 转换为字符串的候选对象，都在 basic_string.h 中。一是转换正确，一是报告无效，三是造成歧义。这是导致歧义的 basic_string.h 中的运算符重载：

/**
*  @brief  Set value to string of length 1.
*  @param  c  Source character.
*
*  Assigning to a character makes this string length 1 and
*  (*this)[0] == @a c.
*/
basic_string& operator=(_CharT __c) { 
    this->assign(1, __c); 
    return *this;
}

这不是一个有效的转换，因为它接受的操作数与传递给它的对象类型不匹配。在任何地方都没有尝试分配给 char，因此这种转换根本不应该是一个候选者，更不用说导致歧义的一个候选者。 GCC 似乎将模板类型与其成员中的操作数类型混合在一起。

编辑：我不知道将整数分配给字符串实际上是合法的，因为整数可以转换为可以分配给字符串的字符（尽管字符串不能初始化为字符！）。 GenericType 定义了到 int 的转换，从而使该成员成为有效的候选者。但是，我仍然认为这不是一个有效的转换，原因是使用这种转换会导致两个用户定义的赋值隐式转换，首先从 GenericType 到 int，然后从 int 到 string。正如同一本书 11.4.1 中所述，“只有一级用户定义的隐式转换是合法的。”

Answer 3

我的问题是：如何在不修改 main 内容的情况下解决这种歧义？

创建您自己的名为 string 的类，该类没有不明确的 operator=，然后不要将 using std 之一。

显然这不是一个很好的解决方案，但它可以工作，main 不必更改。

我认为您无法以任何其他方式获得您想要的行为。

Answer 4

此解决方案有效

#include <iostream>
#include <string>
#include <type_traits>
using namespace std;
struct GenericType{

   operator string(){
      return "Hello World";
   }
   
   template <typename T, typename = std::enable_if_t <
                                    std::is_same<T, double>::value ||
                                    std::is_same<T, int>::value>>
   operator T(){
      return 123.4;
   }
};
int main(){
   int i = GenericType();
   string s = GenericType();
   double d = GenericType();
   cout << i << s << d << endl;
   i = GenericType();
   s = GenericType();
   d = GenericType();
   cout << i << s << d << endl;
}

还有一个更通用的解决方案。我认为您不需要为每种算术类型创建运算符，因为隐式转换可以解决问题。

// ...

template <typename T, typename = std::enable_if_t 
    <std::is_arithmetic<T>::value && !std::is_same<T, char>::value>>
operator T() const
{
    return std::stod("123.4");
}

//...