blocks|key|1601635|text|这是到bool的隐式转换。也就是说，只要允许隐式转换，您的类就可以通过调用该方法转换为bool。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1601636|entityMap^0|3|4|17|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

It's an implicit conversion to <code>bool</code>. I.e. wherever implicit conversions are allowed, your class can be converted to <code>bool</code> by calling that method.

blocks|key|2568021|text|它是用户定义的implicit转换函数，可以将您的类转换为true或false。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2568022|//usage
bool+value+=+yourclassinstance;+//yourclassinstance+is+converted+into+bool!|code-block|syntax|javascript|2568023|entityMap^0|7|8|T|4|Y|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

It's user-defined <code>implicit</code> conversion function to convert your class into either <code>true</code> or <code>false</code>.

<pre><code>//usage
bool value = yourclassinstance; //yourclassinstance is converted into bool!
</code></pre>

blocks|key|2568108|text|表单的成员函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2568109|operator+TypeName()|code-block|syntax|javascript|2568110|是转换运算符。它们允许使用类类型的对象，就像它们是TypeName类型的对象一样，当它们是类型时，使用转换函数将它们转换为TypeName。|offset|length|style|CODE|2568111|在这种情况下，operator+bool()允许使用类类型的对象，就好像它是一个bool一样。例如，如果您有一个名为obj的类类型的对象，则可以将其用作|2568112|if+(obj)|2568113|这将调用operator+bool()，返回结果，并将结果用作if的条件。|2568114|应该注意的是，operator+bool()是一个非常糟糕的想法，你真的不应该使用它。有关它不好的原因以及问题的解决方案的详细解释，请参阅"The+Safe+Bool+Idiom."|2568115|(即将推出的C%2B%2B标准修订版C%2B%2B0x增加了对显式转换运算符的支持。这些将允许您编写一个正确工作的安全explicit+operator+bool()，而不必跳过实现安全布尔惯用法的繁琐步骤。)|2568116|entityMap|0|LINK|mutability|MUTABLE|url|http://www.artima.com/cppsource/safebool.html^0|0|0|P|8|1P|8|0|7|F|14|4|1M|3|0|0|4|F|V|2|0|7|F|1X|M|0|0|1F|O|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@$I|17|J|18|K|L]|$I|19|J|1A|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1B|8|@$I|1C|J|1D|K|L]|$I|1E|J|1F|K|L]|$I|1G|J|1H|K|L]]|9|@]|A|$]]|$1|O|3|P|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1J|8|@$I|1K|J|1L|K|L]|$I|1M|J|1N|K|L]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1O|8|@$I|1P|J|1Q|K|L]]|9|@$I|1R|J|1S|1|1T]]|A|$]]|$1|U|3|V|5|6|7|1U|8|@$I|1V|J|1W|K|L]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

Member functions of the form 

<pre><code>operator TypeName()
</code></pre>

are conversion operators. They allow objects of the class type to be used as if they were of type <code>TypeName</code> and when they are, they are converted to <code>TypeName</code> using the conversion function. 

In this particular case, <code>operator bool()</code> allows an object of the class type to be used as if it were a <code>bool</code>. For example, if you have an object of the class type named <code>obj</code>, you can use it as

<pre><code>if (obj)
</code></pre>

This will call the <code>operator bool()</code>, return the result, and use the result as the condition of the <code>if</code>.

It should be noted that <code>operator bool()</code> is A Very Bad Idea and you should really never use it. For a detailed explanation as to why it is bad and for the solution to the problem, see <a href="http://www.artima.com/cppsource/safebool.html">"The Safe Bool Idiom."</a>

(C++0x, the forthcoming revision of the C++ Standard, adds support for explicit conversion operators. These will allow you to write a safe <code>explicit operator bool()</code> that works correctly without having to jump through the hoops of implementing the Safe Bool Idiom.)

blocks|key|2568147|text|正如其他人所说，它用于类型转换，在本例中为bool。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2568148|class+A+{
++++bool+isItSafe;

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

++++...
};|code-block|syntax|javascript|2568149|现在我可以像使用布尔值一样使用这个类的对象：|2568150|A+a;
...
if+(a)+{
++++....
}|2568151|entityMap^0|L|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

As the others have said, it's for type conversion, in this case to a <code>bool</code>. For example:

<pre><code>class A {
 bool isItSafe;

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

 ...
};
</code></pre>

Now I can use an object of this class as if it's a boolean:

<pre><code>A a;
...
if (a) {
 ....
}
</code></pre>

blocks|key|501187|text|operator+bool()+const+
{
++++return+col+!=+0;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|501188|定义如何将类转换为布尔值，()之后的const用于指示此方法不会发生变化(更改此类的成员)。|unstyled|offset|length|style|CODE|501189|您通常会按如下方式使用运算符：|501190|airplaysdk+sdkInstance;
if+(sdkInstance)+{
++++std::cout+<<+"Instance+is+active"+<<+std::endl;
}+else+{
++++std::cout+<<+"Instance+is+in-active+error!"+<<+std::endl;
}|501191|entityMap^0|0|D|2|I|5|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@$G|S|H|T|I|J]|$G|U|H|V|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$B|C]]|$1|O|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>operator bool() const 
{
 return col != 0;
}
</code></pre>

Defines how the class is convertable to a boolean value, the <code>const</code> after the <code>()</code> is used to indicate this method does not mutate (change the members of this class).

You would usually use such operators as follows:

<pre><code>airplaysdk sdkInstance;
if (sdkInstance) {
 std::cout &lt;&lt; "Instance is active" &lt;&lt; std::endl;
} else {
 std::cout &lt;&lt; "Instance is in-active error!" &lt;&lt; std::endl;
}
</code></pre>

blocks|key|4165254|text|std容器的另一个常见用法是对自定义对象中的键值进行相等比较|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4165255|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;
};|code-block|syntax|javascript|4165256|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another common use is for std containers to do equality comparison on key values inside custom objects

<pre><code>class Foo
{
 public: int val;
};

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

class Blah
{
std::set&lt; Foo, Comparer &gt; _mySet;
};
</code></pre>

blocks|key|501229|text|为了清楚起见，我想给出更多的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|501230|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
}|code-block|syntax|javascript|501231|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I'd like to give more codes to make it clear.

<pre><code>struct A
{
 operator bool() const { return true; }
};

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

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

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

blocks|key|501275|text|在编写我自己的unique_ptr时，我发现了这种情况。给定std::unique_ptr's+operator==|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|501276|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;|code-block|syntax|javascript|501277|下面是来自libstdcxx的测试案例：|501278|++std::unique_ptr<int>+ptr;
++if+(ptr+==+0)
++++{+}
++if+(0+==+ptr)
++++{+}
++if+(ptr+!=+0)
++++{+}
++if+(0+!=+ptr)
++++{+}|501279|注意，因为ptr有一个explicit+operator+bool()+const+noexcept;，所以operator+overload+resolution在这里工作得很好，例如，ptr+==+0选择|501280|+template+<class+T,+class+D>
+bool+operator==(const+unique_ptr<T,+D>&+x,+nullptr_t)+noexcept;`.|501281|如果这里没有explicit关键字，则ptr+==+0中的ptr将被转换为bool，然后bool将被转换为int，因为bool+operator==(int,+int)是内置的，而0是int。等待我们的是不明确的重载解析错误。|501282|这是一个Minimal,+Complete,+and+Verifiable+example|501283|#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;
}|501284|gcc：|501285|prog.cc:+In+function+'int+main()':
prog.cc:30:8:+error:+ambiguous+overload+for+'operator=='+(operand+types+are+'A'+and+'int')
+++30+%7C+++++a1+==+0;
++++++%7C+++++~~+%5E~+~
++++++%7C+++++%7C+++++%7C
++++++%7C+++++A+++++int
prog.cc:30:8:+note:+candidate:+'operator==(int,+int)'+<built-in>
+++30+%7C+++++a1+==+0;
++++++%7C+++++~~~%5E~~~
prog.cc:11:16:+note:+candidate:+'constexpr+bool+operator==(A,+A)'
+++11+%7C+constexpr+bool+operator+==(A,+A)+noexcept
++++++%7C++++++++++++++++%5E~~~~~~~
prog.cc:16:16:+note:+candidate:+'constexpr+bool+operator==(A,+std::nullptr_t)'
+++16+%7C+constexpr+bool+operator+==(A,+std::nullptr_t)+noexcept
++++++%7C++++++++++++++++%5E~~~~~~~|501286|clang：|501287|prog.cc:30:8:+error:+use+of+overloaded+operator+'=='+is+ambiguous+(with+operand+types+'A'+and+'int')
++++a1+==+0;
++++~~+%5E++~
prog.cc:16:16:+note:+candidate+function
constexpr+bool+operator+==(A,+std::nullptr_t)+noexcept
+++++++++++++++%5E
prog.cc:11:16:+note:+candidate+function
constexpr+bool+operator+==(A,+A)+noexcept
+++++++++++++++%5E
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+int)
++++a1+==+0;
+++++++%5E
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(int,+unsigned+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(float,+unsigned+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(double,+unsigned+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+double,+unsigned+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(__float128,+unsigned+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long,+unsigned+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(long+long,+unsigned+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(__int128,+unsigned+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+int,+unsigned+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long,+unsigned+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+long+long,+unsigned+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+float)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+long+double)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+__float128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+__int128)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+unsigned+int)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+unsigned+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+unsigned+long+long)
prog.cc:30:8:+note:+built-in+candidate+operator==(unsigned+__int128,+unsigned+__int128)
1+error+generated.|501288|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/memory/unique_ptr/operator_cmp|1|https://github.com/gcc-mirror/gcc/blob/master/libstdc%252B%252B-v3/testsuite/20_util/unique_ptr/comparison/42925.cc|2|https://stackoverflow.com/help/mcve|3|https://wandbox.org/permlink/vEqfBUZMfU9M3CMv|4|https://wandbox.org/permlink/VTJmyxeltlKkbNdD^0|U|F|1C|A|U|S|0|0|0|5|9|1|0|0|5|3|B|14|1I|S|2M|8|0|0|6|8|J|8|T|3|11|4|18|4|1H|3|1N|P|2I|1|2K|3|0|4|15|2|0|0|0|3|3|0|0|0|5|4|0|0^^$0|@$1|2|3|4|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]]|D|@$9|1R|A|1S|1|1T]]|E|$]]|$1|F|3|G|5|H|7|1U|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1V|8|@]|D|@$9|1W|A|1X|1|1Y]]|E|$]]|$1|M|3|N|5|H|7|1Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|20|8|@$9|21|A|22|B|C]|$9|23|A|24|B|C]|$9|25|A|26|B|C]|$9|27|A|28|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|29|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|2A|8|@$9|2B|A|2C|B|C]|$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]|$9|2J|A|2K|B|C]|$9|2L|A|2M|B|C]|$9|2N|A|2O|B|C]|$9|2P|A|2Q|B|C]|$9|2R|A|2S|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|2T|8|@]|D|@$9|2U|A|2V|1|2W]]|E|$]]|$1|W|3|X|5|H|7|2X|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|2Y|8|@]|D|@$9|2Z|A|30|1|31]]|E|$]]|$1|10|3|11|5|H|7|32|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|33|8|@]|D|@$9|34|A|35|1|36]]|E|$]]|$1|14|3|15|5|H|7|37|8|@]|D|@]|E|$I|J]]|$1|16|3|-4|5|6|7|38|8|@]|D|@]|E|$]]]|17|$18|$5|19|1A|1B|E|$1C|1D]]|1E|$5|19|1A|1B|E|$1C|1F]]|1G|$5|19|1A|1B|E|$1C|1H]]|1I|$5|19|1A|1B|E|$1C|1J]]|1K|$5|19|1A|1B|E|$1C|1L]]]]

When writing my own unique_ptr, I found this case. Given <a href="https://en.cppreference.com/w/cpp/memory/unique_ptr/operator_cmp" rel="nofollow noreferrer"><code>std::unique_ptr</code>'s <code>operator==</code></a>:

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

template &lt;class T, class D&gt;
bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;

template &lt;class T, class D&gt;
bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;
</code></pre>

And this test case from <a href="https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/testsuite/20_util/unique_ptr/comparison/42925.cc" rel="nofollow noreferrer">libstdcxx</a>: 

<pre><code> std::unique_ptr&lt;int&gt; ptr;
 if (ptr == 0)
 { }
 if (0 == ptr)
 { }
 if (ptr != 0)
 { }
 if (0 != ptr)
 { }
</code></pre>

Note because that <code>ptr</code> has a <code>explicit operator bool() const noexcept;</code>, so <code>operator overload resolution</code> works fine here, e.g., <code>ptr == 0</code> chooses 

<pre><code> template &lt;class T, class D&gt;
 bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;`.
</code></pre>

If it has no <code>explicit</code> keyword here, <code>ptr</code> in <code>ptr == 0</code> will be converted into <code>bool</code>, then <code>bool</code> will be converted into <code>int</code>, because <code>bool operator==(int, int)</code> is built-in and <code>0</code> is <code>int</code>. What is waiting for us is ambiguous overload resolution error. 

Here is a <a href="https://stackoverflow.com/help/mcve">Minimal, Complete, and Verifiable example</a>:

<pre><code>#include &lt;cstddef&gt;
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;
}
</code></pre>

<a href="https://wandbox.org/permlink/vEqfBUZMfU9M3CMv" rel="nofollow noreferrer">gcc</a>: 

<pre><code>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)' &lt;built-in&gt;
 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
 | ^~~~~~~~
</code></pre>

<a href="https://wandbox.org/permlink/VTJmyxeltlKkbNdD" rel="nofollow noreferrer">clang</a>: 

<pre><code>prog.cc:30:8: error: use of overloaded operator '==' is ambiguous (with operand types 'A' and 'int')
 a1 == 0;
 ~~ ^ ~
prog.cc:16:16: note: candidate function
constexpr bool operator ==(A, std::nullptr_t) noexcept
 ^
prog.cc:11:16: note: candidate function
constexpr bool operator ==(A, A) noexcept
 ^
prog.cc:30:8: note: built-in candidate operator==(int, int)
 a1 == 0;
 ^
prog.cc:30:8: note: built-in candidate operator==(float, int)
prog.cc:30:8: note: built-in candidate operator==(double, int)
prog.cc:30:8: note: built-in candidate operator==(long double, int)
prog.cc:30:8: note: built-in candidate operator==(__float128, int)
prog.cc:30:8: note: built-in candidate operator==(int, float)
prog.cc:30:8: note: built-in candidate operator==(int, double)
prog.cc:30:8: note: built-in candidate operator==(int, long double)
prog.cc:30:8: note: built-in candidate operator==(int, __float128)
prog.cc:30:8: note: built-in candidate operator==(int, long)
prog.cc:30:8: note: built-in candidate operator==(int, long long)
prog.cc:30:8: note: built-in candidate operator==(int, __int128)
prog.cc:30:8: note: built-in candidate operator==(int, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(int, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(int, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(int, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(long, int)
prog.cc:30:8: note: built-in candidate operator==(long long, int)
prog.cc:30:8: note: built-in candidate operator==(__int128, int)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, int)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, int)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, int)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, int)
prog.cc:30:8: note: built-in candidate operator==(float, float)
prog.cc:30:8: note: built-in candidate operator==(float, double)
prog.cc:30:8: note: built-in candidate operator==(float, long double)
prog.cc:30:8: note: built-in candidate operator==(float, __float128)
prog.cc:30:8: note: built-in candidate operator==(float, long)
prog.cc:30:8: note: built-in candidate operator==(float, long long)
prog.cc:30:8: note: built-in candidate operator==(float, __int128)
prog.cc:30:8: note: built-in candidate operator==(float, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(float, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(float, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(float, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(double, float)
prog.cc:30:8: note: built-in candidate operator==(double, double)
prog.cc:30:8: note: built-in candidate operator==(double, long double)
prog.cc:30:8: note: built-in candidate operator==(double, __float128)
prog.cc:30:8: note: built-in candidate operator==(double, long)
prog.cc:30:8: note: built-in candidate operator==(double, long long)
prog.cc:30:8: note: built-in candidate operator==(double, __int128)
prog.cc:30:8: note: built-in candidate operator==(double, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(double, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(double, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(double, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(long double, float)
prog.cc:30:8: note: built-in candidate operator==(long double, double)
prog.cc:30:8: note: built-in candidate operator==(long double, long double)
prog.cc:30:8: note: built-in candidate operator==(long double, __float128)
prog.cc:30:8: note: built-in candidate operator==(long double, long)
prog.cc:30:8: note: built-in candidate operator==(long double, long long)
prog.cc:30:8: note: built-in candidate operator==(long double, __int128)
prog.cc:30:8: note: built-in candidate operator==(long double, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(long double, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(long double, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(long double, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(__float128, float)
prog.cc:30:8: note: built-in candidate operator==(__float128, double)
prog.cc:30:8: note: built-in candidate operator==(__float128, long double)
prog.cc:30:8: note: built-in candidate operator==(__float128, __float128)
prog.cc:30:8: note: built-in candidate operator==(__float128, long)
prog.cc:30:8: note: built-in candidate operator==(__float128, long long)
prog.cc:30:8: note: built-in candidate operator==(__float128, __int128)
prog.cc:30:8: note: built-in candidate operator==(__float128, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(__float128, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(__float128, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(__float128, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(long, float)
prog.cc:30:8: note: built-in candidate operator==(long, double)
prog.cc:30:8: note: built-in candidate operator==(long, long double)
prog.cc:30:8: note: built-in candidate operator==(long, __float128)
prog.cc:30:8: note: built-in candidate operator==(long, long)
prog.cc:30:8: note: built-in candidate operator==(long, long long)
prog.cc:30:8: note: built-in candidate operator==(long, __int128)
prog.cc:30:8: note: built-in candidate operator==(long, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(long, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(long, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(long, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(long long, float)
prog.cc:30:8: note: built-in candidate operator==(long long, double)
prog.cc:30:8: note: built-in candidate operator==(long long, long double)
prog.cc:30:8: note: built-in candidate operator==(long long, __float128)
prog.cc:30:8: note: built-in candidate operator==(long long, long)
prog.cc:30:8: note: built-in candidate operator==(long long, long long)
prog.cc:30:8: note: built-in candidate operator==(long long, __int128)
prog.cc:30:8: note: built-in candidate operator==(long long, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(long long, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(long long, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(long long, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(__int128, float)
prog.cc:30:8: note: built-in candidate operator==(__int128, double)
prog.cc:30:8: note: built-in candidate operator==(__int128, long double)
prog.cc:30:8: note: built-in candidate operator==(__int128, __float128)
prog.cc:30:8: note: built-in candidate operator==(__int128, long)
prog.cc:30:8: note: built-in candidate operator==(__int128, long long)
prog.cc:30:8: note: built-in candidate operator==(__int128, __int128)
prog.cc:30:8: note: built-in candidate operator==(__int128, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(__int128, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(__int128, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(__int128, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, float)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, double)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, long double)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, __float128)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, long)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, float)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, double)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, long double)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, __float128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, float)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, double)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, long double)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, __float128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, float)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, double)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, long double)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, __float128)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, long)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, unsigned __int128)
1 error generated.
</code></pre>

For example:

<pre><code>operator bool() const 
{ 
 return col != 0; 
}
</code></pre>

<code>col</code> is an int.
How does <code>operator bool() const</code> work?

What is the meaning of "operator bool() const"

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

例如：operator bool() const {     return col != 0; }col是一个整数。operator bool() const是如何工作的？

问“运算符bool() const”是什么意思？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“运算符bool() const”是什么意思？EN