在这种情况下重载 bool 运算符是否危险

Question

我在 SoF 上看到 cmets 或答案指出将强制转换运算符重载为 bool 是危险的，我应该更喜欢 void* operator。不过我想问一下在我的用例中使用这个运算符是否是危险的做法，如果是，为什么。

我实现了一个简单的几何库，其中一个最基本的类是我通过以下方式定义的点：

struct point {
  double x, y;
  bool real;
  point(double x_, double y_): x(x_), y(y_), real(true) {}
  point(): x(0), y(0), real(true) {}

  operator bool() {
    return real;
  }
};

我将尝试解释为什么我需要强制转换运算符来布尔。我有另一个名为 line 的类，我有一个声明如下的函数：

point intersect(const line& a, const line& b);

现在已经将强制转换运算符重载为一个点的布尔值，我可以同时编写：point p = intersect(a,b); 和if (intersect(a,b))，因此要么获取两条线的交点，要么检查两条线是否相交。我也在其他地方使用它，但我相信这个例子足以展示 cast 运算符的用法。我使用演员表操作符有危险吗？如果有，请举例说明什么时候效果不符合预期？

编辑：感谢 juanchopanza 的一个小补充：在这个项目中，我仅限于不使用 c++11，所以我不能明确操作符。

Answer 1

虽然已经有一些非常好的答案，但我想组装一个更完整的答案，并解释为什么提出的解决方案确实有效。

1.为什么我的解决方案是错误的？ 编译器执行从 bool 到数字类型的隐式转换，导致定义了意外的运算符。例如：

point p;
if (p < 1)

会在我没想到的时候编译。将用于转换的运算符更改为 operator void*() 会有所改善，但只会略有改善，因为为 void * 定义了一些运算符（尽管小于 bool），并且它们的存在将再次导致意外行为。

2.那么正确的解决方案是什么。可以在here 找到正确的解决方案。但我将包含我的课程的代码，以便我可以解释它为什么有效以及我们为什么以这种方式解决问题：

class point {
  typedef void (point::*bool_type)() const;
  void not_supported() const; // NOTE: only declaration NO body!

public:
  double x, y;
  bool real;
  point(double x_, double y_): x(x_), y(y_), real(true) {}
  point(): x(0), y(0), real(true) {}

  operator bool_type() {
    return (real == true)? &point::not_supported : 0;
  }

  template<typename T>
  bool operator==(const T& rhs) const {
    not_supported();
    return false;
  }

  template<typename T>
  bool operator!=(const T& rhs) const {
    not_supported();
    return false;
  }
};

现在首先我将解释为什么我们必须使用函数指针而不是普通指针的类型。答案由史蒂夫杰索普在纳瓦兹答案下方的评论中陈述。 function pointers are not < comparable，因此任何尝试编写 p < 5 或点与其他类型之间的任何其他比较都将无法编译。

为什么我们需要一个没有主体的方法 (not_supported)？因为这样每次我们尝试实例化模板化方法进行比较时（即== 和!=），我们都会有一个没有主体的方法的函数调用，这会导致编译错误。

Answer 2

由于从 bool 到数值的隐式转换，您可能会遇到各种麻烦。 此外，您的线路类有一个（在我看来）危险成员“bool real”，用于携带函数调用的结果。如果线不相交，则返回交集值或 NaN 的交集函数可以解决您的问题。

例子

有一个（无限的）线类，包含一个原点 p 和一个向量 v：

struct Line {
    Point p;
    Vector v;

    Point operator () (double r) const {
        return p + r * v;
    }
};

还有一个计算交点值的函数

/// A factor suitable to be passed to line a as argument to calculate the
/// inersection point.
/// - A value in the range [0, 1] indicates a point between
///   a.p and a.p + a.v.
/// - The result is NaN if the lines do not intersect. 
double intersection(const Line& a, const Line& b) {
    double d = a.v.x * b.v.y - a.v.y * b.v.x;
    if( ! d) return std::numeric_limits<double>::quiet_NaN();
    else {
        double n = (b.p.x - a.p.x) * b.v.y
                 - (b.p.y - a.p.y) * b.v.x;
        return n/d;
    }
}

那么你可以这样做：

double d = intersection(a, b);
if(d == d) { // std::isnan is c++11
    Point p = a(d);
}

或者

if(0 <= d && d <= 1) {
    Point p = a(d);
}

Answer 3

例如，早期的 C++ 2003 标准类 std::basic_ios 有以下转换运算符

operator void*() const

现在因为新的 C++ 标准有关键字显式这个操作符被替换

explicit operator bool() const;

所以如果你为你的操作符添加显式关键字，我认为这不会是危险的。:)

另一种方法是定义运算符 bool 运算符 !() 而不是转换运算符。

Answer 4

奇怪的是那些人没有告诉你为什么重载operator bool()是危险的。

原因是 C++ 具有从 bool 到所有其他数字类型的隐式转换。因此，如果您重载operator bool()，那么您会丢失该类用户通常期望的大量类型检查。他们可以在任何需要int 或float 的地方提供point。

重载operator void*() 的危险性较小，因为void* 转换为的更少，但仍然存在void* 类型用于其他用途的相同基本问题。

安全布尔惯用语的想法是返回一个指针类型，该指针类型不会转换为任何 API 中使用的任何东西。

请注意，如果您愿意写if (intersect(a,b).real) 或if (intersect(a,b).exists())，则无需担心这一点。 C++03 确实有显式转换。任何具有一个参数的函数（或没有参数的非静态成员函数）都是一种转换。 C++03 只是没有显式转换运算符。

Answer 5

是的，这很危险。举个例子，让我们按原样考虑您的point，没有operator+ 的定义。尽管如此，如果我们尝试添加两个 point 对象，编译器根本不会反对：

point a, b;

std::cout << a + b;

这是通过将每个 point 转换为 bool，然后添加 bools 来实现的。在整数上下文中，false 转换为 0，true 转换为 1，因此我们可以期望上面的代码打印出 2。当然，我只是以加法为例。你也可以做减法、乘法、除法、按位运算、逻辑运算等。所有这些都会编译和执行，但显然会产生毫无价值的结果。同样，如果我们将point 传递给某个只接受数字类型的函数，编译器不会停止或抱怨——它只会转换为bool，并且该函数将得到0 或1 取决于 real 是否为真。

safe-bool 习惯用法是安全的（好吧，反正危险性较小），因为您可以在布尔上下文中测试 void *，但 void * 不会隐式转换为像 bool 这样的任何其他内容.您（主要是¹）不会意外地对它们进行算术、按位运算等。

---

1. 无论如何，有几个 漏洞，主要涉及调用其他对void * 进行某种显式转换的东西。能够标记转换运算符explicit 更好，但老实说，它们在可读性方面的改进比安全性要大得多。

Answer 6

这还不够好。既然你被 C++03 困住了，如果你需要这样的东西，你应该使用safe-bool idiom（否则，应该首选explicit 转换函数）。

另一种解决方案是返回boost:optional：

boost::optional<point> intersect(const line& a, const line& b);

我会采用这种方法（即使在 C++11 中），因为它在语义上看起来更好——平行线没有交点，所以返回值确实应该是 可选 （或 也许值）。