c++重载运算符 bool() 给出了一个含糊不清的重载错误：operator+

Question

我正在编译 MegaInt 类的一些 C++ 代码，该类是一个正十进制类型类，允许对大数进行算术运算。

我想重载运算符 bool 以允许这样的代码：

MegaInt m(45646578676547676);  
if(m)  
    cout << "YaY!" << endl;

这就是我所做的：

header:

class MegaInt
{
    public:
        ...
    operator bool() const;
};

const MegaInt operator+(const MegaInt & left, const MegaInt & right);
const MegaInt operator*(const MegaInt & left, const MegaInt & right);

implementation:

MegaInt::operator bool() const
{
    return *this != 0;
}
const MegaInt operator+(const MegaInt & left, const MegaInt & right)
{
    MegaInt ret = left;
    ret += right;
    return ret;
}

现在，问题是如果我这样做：

MegaInt(3424324234234342) + 5;

它给了我这个错误：

“operator+(const MegaInt&, const MegaInt&)”中“operator+”的重载不明确 注意：候选者是：operator+(int, int) | 注意： const MegaInt 运算符+(const MegaInt&, const MegaInt&)|

我不知道为什么。重载的 bool() 是如何导致operator+变得不明确的？¸

谢谢。

---

好吧，每个人都给了我很好的答案，不幸的是，他们似乎都没有完全解决我的问题。

void* 或 Safe Bool Idiom 都可以。除了一个小问题外，我希望有一个解决方法：

与 0 比较时，例如：

if (aMegaInt == 0)

编译器再次给出不明确的重载错误。我明白为什么：它不知道我们是在与 false 还是与值为 0 的 MegaInt 进行比较。尽管如此，在这种情况下，我希望它转换为 MegaInt(0)。有没有办法强制这个？

再次感谢您。

Answer 1

C++ 编译器可以自动将 bool 转换为 int，这就是它在这里要做的事情。

解决这个问题的方法是使用safe bool idiom。

从技术上讲，创建 operator void* 不是安全 bool 习惯用法的示例，但在实践中它足够安全，因为您遇到的 bool/int 问题是一个常见的错误，并且弄乱了一些完全合理且正确的代码（正如您从问题中看到的那样），但是 void* 转换的误用并不常见。

Answer 2

维基百科条目关于C++0x 的显式转换运算符有一个不错的总结为什么您会在 C++0x 之前看到此错误。基本上，bool 转换运算符是整型转换类型，因此它将用在整型算术表达式中。 C++0x 之前的修复是使用 void * 作为转换运算符； void * 可以转换为布尔表达式，但不能转换为整数表达式。

Answer 3

正如 Erik 的回答所述，这里的问题是，通过提供到 bool 的隐式转换，您为可以表示多种含义的表达式打开了大门；在这种情况下，编译器会抱怨不明确并给出错误。

但是，请注意，提供到 void* 的隐式转换不会让您摆脱困境；它只会改变出现问题的表达式集。

对于此问题，有两种无懈可击的解决方案：

• 显式转换为 bool（如果该类表示具有直观“真/假”值的实体，则这可能是不可取的）
• 使用 safe bool idiom （这确实涵盖了所有基础，但生活中有很多美好的事物，而 C++ 太复杂了 - - 你付出代价）

Answer 4

问题是 bool 可以自由转换为 int。因此，表达式 MegaInt(3424324234234342) + 5; 可以同样有效地解释为：

(bool)(MegaInt(3424324234234342)) + 5;

或者：

MegaInt(3424324234234342) + MegaInt(5);

这些表达式中的每一个都涉及一个用户定义的转换，并且在编译器看来是相等的。由于这个原因，转换为 bool 是非常有问题的。如果能有一种方法来表明它只应该发生在明确需要 bool 的上下文中，那就太好了，但事实并非如此。 :-/

其他人建议的转换为 void * 是一种解决方法，但我认为作为一种解决方法，它有自己的问题，我不会这样做。

Answer 5

MegaInt(3424324234234342) + 5;

MegaInt + int;

编译器应该将您的 MegaInt 转换为整数（bool 是整数类型）还是将整数转换为 MegaInt（您有一个 int 构造函数）？

您可以通过创建 operator void * 而不是 operator bool 来解决此问题：

operator void *() const { return (*this != 0) ? ((void *) 1) : ((void *) 0); }

Answer 6

其他人提到了 Safe Bool 习语。然而，对于像你这样的对象，当你想要完整的代数支持时，添加所有这些令人讨厌的特殊逻辑是一个坏主意。

您正在定义自定义整数类型。通过定义“operator==”和“operator!=”，然后实现“operator bool()”，您可以得到更多的成果：

operator bool()
{
   return (*this != 0);
}

仅从这 3 个函数中，您就可以获得整数的所有“if”惯用语，对于您的自定义整数，它们的行为与内置整数相同：“if(a==b)”、“if(a!=b)”、“if(a)”、“if(!a” ）”。你隐含的“bool”规则也将（如果你小心的话）直观地工作。

此外，完整的“Safe Bool Idiom”是不必要的。想想看 - 您唯一需要它的时候是“1）2个对象的比较定义不明确或未定义，2）强制转换为（int）或其他原始类型需要保护，3）对象有效性定义明确（返回布尔值的实际来源）。”

好吧，如果您确实希望支持转换为 int 或 float 等数字类型，则 2) 只是一个考虑因素。但是对于没有明确定义的相等概念的对象（#1），提供这样的强制转换不可避免地会产生“if(a==b)”逻辑炸弹的风险，该习惯用法应该可以保护您免受这种风险。只需声明“operator int()”和这样的私有，就像对不可复制对象上的复制构造函数所做的那样，然后就可以完成它：

class MyClass {
private:
   MyClass(const MyClass&);
   operator int();
   operator long();
   // float(), double(), etc. ...
public:
   // ctor & dtor ..
   bool operator==(const MyClass& other) const { //check for equality logic... }
   bool operator!=(const MyClass& other) const { return !(*this == other); }
   operator bool() { return (*this != 0); }
};