Question

例如：

operator bool() const 
{ 
    return col != 0; 
}

col是一个int。 operator bool() const如何运作？

Answer 1

表单的成员函数

operator TypeName()

是转化运算符。它们允许使用类类型的对象，就好像它们属于TypeName类型一样，当它们存在时，它们将使用转换函数转换为TypeName。

在这种特殊情况下，operator bool()允许使用类类型的对象，就好像它是bool一样。例如，如果您有一个名为obj的类类型的对象，则可以将其用作

if (obj)

这将调用operator bool()，返回结果，并将结果用作if的条件。

应该注意operator bool()是一个非常坏的想法，你真的不应该使用它。有关问题原因以及解决问题的详细说明，请参阅"The Safe Bool Idiom."

（C ++ 0x，即将推出的C ++标准版本，增加了对显式转换运算符的支持。这些将允许您编写一个正常工作的安全explicit operator bool()，而无需跳过实现安全布尔成语。）

Answer 2

operator bool() const 
{
    return col != 0;
}

定义类如何转换为布尔值，const后()表示此方法不变异（更改此类的成员）。

您通常会使用以下操作符：

airplaysdk sdkInstance;
if (sdkInstance) {
    std::cout << "Instance is active" << std::endl;
} else {
    std::cout << "Instance is in-active error!" << std::endl;
}

Answer 3

我想提供更多代码以明确说明。

struct A
{
    operator bool() const { return true; }
};

struct B
{
    explicit operator bool() const { return true; }
};

int main()
{
    A a1;
    if (a1) cout << "true" << endl; // OK: A::operator bool()
    bool na1 = a1; // OK: copy-initialization selects A::operator bool()
    bool na2 = static_cast<bool>(a1); // OK: static_cast performs direct-initialization

    B b1;     
    if (b1) cout << "true" << endl; // OK: B::operator bool()
    // bool nb1 = b1; // error: copy-initialization does not consider B::operator bool()
    bool nb2 = static_cast<bool>(b1); // OK: static_cast performs direct-initialization
}

Answer 4

这是用户定义的implicit转换功能，可将您的班级转换为true或false。

//usage
bool value = yourclassinstance; //yourclassinstance is converted into bool!

Answer 5

这是对bool的隐式转换。即只要允许隐式转换，您的类就可以通过调用该方法转换为bool。

Answer 6

正如其他人所说，这是类型转换，在这种情况下是bool。例如：

class A {
    bool isItSafe;

public:
    operator bool() const
    {
        return isItSafe;
    }

    ...
};

现在我可以使用这个类的对象，就好像它是一个布尔值：

A a;
...
if (a) {
    ....
}

Answer 7

在编写自己的unique_ptr时，我发现了这种情况。给定std::unique_ptr's operator==：

template<class T1, class D1, class T2, class D2>
bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);

template <class T, class D>
bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;

template <class T, class D>
bool operator==(nullptr_t, const unique_ptr<T, D>& x) noexcept;

还有libstdcxx中的这个测试案例：

  std::unique_ptr<int> ptr;
  if (ptr == 0)
    { }
  if (0 == ptr)
    { }
  if (ptr != 0)
    { }
  if (0 != ptr)
    { }

请注意，因为ptr有一个explicit operator bool() const noexcept;，所以operator overload resolution在这里工作正常，例如ptr == 0选择

 template <class T, class D>
 bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;`.

如果此处没有explicit关键字，则ptr中的ptr == 0将转换为bool，然后bool将转换为{{1} }，因为int是内置的，而bool operator==(int, int)是0。等待我们的是模棱两可的重载解析错误。

这里是Minimal, Complete, and Verifiable example：

int

gcc：

#include <cstddef>
struct A
{
    constexpr A(std::nullptr_t) {}
    operator bool() 
    {
        return true;
    }
};

constexpr bool operator ==(A, A) noexcept
{
    return true;
}

constexpr bool operator ==(A, std::nullptr_t) noexcept
{
    return true;
}

constexpr bool operator ==(std::nullptr_t, A) noexcept
{
    return true;
}

int main()
{
    A a1(nullptr);
    A a2(0);
    a1 == 0;
}

clang：

prog.cc: In function 'int main()':
prog.cc:30:8: error: ambiguous overload for 'operator==' (operand types are 'A' and 'int')
   30 |     a1 == 0;
      |     ~~ ^~ ~
      |     |     |
      |     A     int
prog.cc:30:8: note: candidate: 'operator==(int, int)' <built-in>
   30 |     a1 == 0;
      |     ~~~^~~~
prog.cc:11:16: note: candidate: 'constexpr bool operator==(A, A)'
   11 | constexpr bool operator ==(A, A) noexcept
      |                ^~~~~~~~
prog.cc:16:16: note: candidate: 'constexpr bool operator==(A, std::nullptr_t)'
   16 | constexpr bool operator ==(A, std::nullptr_t) noexcept
      |                ^~~~~~~~

Answer 8

另一个常见用途是std容器对自定义对象内的键值进行相等性比较

class Foo
{
    public: int val;
};

class Comparer { public:
bool operator () (Foo& a, Foo&b) const {
return a.val == b.val; 
};

class Blah
{
std::set< Foo, Comparer > _mySet;
};

“operator bool（）const”是什么意思

8 个答案: