const 正确性和安全 bool 习惯用法

Question

我还有另一个与安全 bool 习惯用法相关的问题：

typedef void (Testable::*bool_type)() const;             // const necessary?
void this_type_does_not_support_comparisons() const {}   // const necessary?

operator bool_type() const
{
    return ok_ ? &Testable::this_type_does_not_support_comparisons : 0;
}

为什么 bool_type （typedef）和 this_type_does_not_support_comparisons 是 const？ 无论如何，没有人应该通过返回指针实际调用成员函数，对吗？ 这里需要const吗？否则operator bool_type（成员函数）会违反常量正确性吗？

Answer 1

“safe bool idiom”是对“我想要一辆既是跑车又是拖拉机，也许是船”这个问题的技术答案。实际答案不是技术答案……

也就是说，它解决的问题只是给出一个可转换为 bool 的结果，但不能转换为任何其他内容（否则该类的实例可能会作为实际参数传递，例如，形式参数是 int）。数据指针可以转换为void*。函数指针不是，至少在 C++ 标准中是这样（Posix 是别的东西，也可以练习）。

给定来自安全布尔运算符的指针，使用成员函数指针可以防止意外调用该函数。 const 对其进行了一些限制，但如果命运使某人走上了犯最大数量愚蠢错误的道路，那么该人仍然可能设法调用不执行任何操作的函数。我想我应该让它有一个私有类型的参数，而不是 const ，而其他代码不能提供这样的参数，然后它就不必是一个愚蠢的不再是成员函数类型了。

可以看起来像这样：

#include <stdio.h>

class Foo
{
private:
    enum PrivateArg {};
    typedef void (*SafeBool)( PrivateArg );
    static void safeTrue( PrivateArg ) {}

    bool    state_;

public:
    Foo( bool state ): state_( state ) {}

    operator SafeBool () const
    { return (state_? &safeTrue : 0); }
};

int main()
{
    if( Foo( true ) ) { printf( "true\n" ); }
    if( Foo( false ) ) { printf( "false\n" ); } // No output.

    //int const x1 = Foo( false );        // No compilado!
    //void* const x2 = Foo( false );      // No compilado!
}

当然，实际的答案是这样的：

#include <stdio.h>

class Foo
{
private:
    bool    isEmpty_;

public:
    Foo( bool asInitiallyEmpty )
        : isEmpty_( asInitiallyEmpty )
    {}

    bool isEmpty() const { return isEmpty_; }
};

int main()
{
    if( Foo( true ).isEmpty() ) { printf( "true\n" ); }
    if( Foo( false ).isEmpty() ) { printf( "false\n" ); } // No output.

    //bool const x0 = Foo( false );       // No compilado!
    //int const x1 = Foo( false );        // No compilado!
    //void* const x2 = Foo( false );      // No compilado!
}

Summary wrt。提出的问题：

• 为什么 bool_type (typedef) 和 this_type_does_not_support_comparisons 是 const？

有人不太明白他们编码的内容。或者也许他们打算稍微限制一下打电话的能力。但这样的措施是徒劳的。

• 无论如何，没有人应该通过返回指针实际调用成员函数，对吧？

正确的。

• 这里const有必要吗？

否。否则，

• operator bool_type（成员函数）会违反 const 正确性吗？

不。

干杯&呵呵，

Answer 2

8.3.5/ cv-qualifier-seq 只能是函数类型的一部分
非静态成员函数，指针指向的函数类型
成员引用，或函数 typedef 的顶级函数类型
宣言。函数声明符中 cv-qualifier-seq 的作用
与在函数顶部添加简历资格不同
类型，即它不会创建 cv 限定的函数类型。

如果我没看错，您可以在 const 成员函数中返回指向非 const 成员的指针。您只是无法使用非常量对象来调用它。

禁止调用的一种方法是：

private:
    struct private_ 
    {
        void this_type_does_not_support_comparisons() {}
    };

public:
    typedef void (private_::*bool_type)() const;

    operator bool_type() const
    {
        return ok_ ? &private_::this_type_does_not_support_comparisons : 0;
    }

仍然可以比较指向成员函数的指针是否相等。您必须为触发错误的 Testable::bool_type 类型编写 operator== 和 operator!= 。使用安全 bool 习惯用法的 CRTP 形式更容易实现，因为这些运算符成为模板，因此可能具有错误的主体。

示例：

template <typename T>
class safe_bool_concept
{
    // Implementation detail of safe bool
protected:
    ~safe_bool_concept() {}

public:
    operator safe_bool() const
    {
        return static_cast<const T*>(this)->is_null() ? ...;
    }
};

struct Foo : safe_bool_concept<Foo>
{
    ...

private:
    friend class safe_bool_concept<Foo>;
    bool is_null() const { ... }
};

那么你可以这样做（与 != 做同样的事情）：

template <typename T>
void operator==(const safe_bool_concept<T>& x, const safe_bool_concept<T>&)
{
    x.some_private_member(); // invalid, but won't be generated
                             // unless safe_bool classes are compared
}

这意味着如果你想禁止比较，应该通过 CRTP 实现 safe bool 习惯用法。然而与零的比较仍然有效。

如果您采用非成员函数路线，则必须提供 <、>、<= 和 >= 也是如此。

Answer 3

虽然这很旧，但安全 bool 习语有其历史意义，我决定写一个完整的答案，因为我真的不同意 接受的答案< /a>.

重要的是我们不能孤立地回答这个问题。该函数被称为 this_type_does_not_support_comparisons 是有原因的。它不仅仅是一些随机的私人成员。意图很明确：该函数还用于避免两个测试对象之间的意外比较。例如，如果我们查看此处的实现，我们可以看到该函数实际上被调用了。

class Testable {
    bool ok_;
    typedef void (Testable::*bool_type)() const;
    void this_type_does_not_support_comparisons() const {}
  public:
    explicit Testable(bool b=true):ok_(b) {}

    operator bool_type() const {
      return ok_ ? 
        &Testable::this_type_does_not_support_comparisons : 0;
    }
};
template <typename T>
bool operator!=(const Testable& lhs, const T&) {
    lhs.this_type_does_not_support_comparisons();   
    return false;
}
template <typename T>
bool operator==(const Testable& lhs, const T&) {
    lhs.this_type_does_not_support_comparisons();
    return false;
}

首先请注意，此代码无法在现代编译器上编译，因为无论 T 是什么，函数体都无条件地格式错误。不过，让我们从历史的角度来考虑一下。在较旧的 C++ 中
这确保了在两个可测试对象上调用 operator== 时，比较消息可以很好地指示真正的问题。例如，GCC 4.1.2 生成以下错误消息。

错误：'无效
Testable::this_type_does_not_support_comparisons() const' 是私有的

这就是为什么首先调用该函数 this_type_does_not_support_comparison 的原因。 const 需要在那里，因为该函数实际上是在需要 const 的上下文中调用的，即 templatebool 运算符==(const Testable&lhs, const T&)。请注意，不能从第一个参数中删除 const，否则它无法检测 const 对象与另一个对象之间的比较，并且再次可以静默转换为 bool。

以下是我对以下问题的回答：

• 为什么 bool_type （typedef）和 this_type_does_not_support_comparisons 是 const？

因为该函数实际上被调用，并且 const 对于抑制在operator== 上下文中隐式转换为 bool 是必要的。这绝对不是因为有人不理解他们写的内容，也不是为了阻止使用 (testable.*testable)() 语法调用可测试对象（这已经是一种非常奇特的用法，没有人使用bool 之类的，所以这根本不应该被认为是要防止的意外误用，而且，如果你尝试它，它实际上不会编译）。

• 无论如何，没有人应该通过返回指针实际调用成员函数，对吧？

大部分是对的。成员函数不应该从外部调用，但实际上是在类本身的比较运算符中调用的。很容易错过这个用法，因为它没有包含在问题的原始片段中。

• 这里const有必要吗？

再说一次，如果我们将自己限制在发布的代码片段中，则不会；如果我们考虑如何实现规范的 safe bool 习惯用法的更广泛的背景，那么是的。

• 否则operator bool_type（成员函数）会违反常量正确性吗？

如果我们只考虑发布的片段，则不会。是的，在更广泛的背景下。在 Alexandre C.的回答中，已经解决了为什么在 const 中返回指向非 const 成员的指针-限定成员函数不违反常量正确性。

当然，现在是 2023 年，如果有人拥有支持 c++11 的现代编译器，他们应该只使用显式运算符 bool() 并忘记所有这些。然而，可能仍然有一些可怜的人需要使用仅限于 c++03 的遗留环境，在这种情况下，可能的答案是 Alexandre C. 提供了一个可能更好的选择。毕竟，即使标准设置为 c++03，原始版本的 safe bool idiom 也无法使用新编译器进行编译。