Returns the result of a boolean operation.
Operator name | Syntax | Overloadable | Prototype examples (for class T ) | |
---|---|---|---|---|
Inside class definition | Outside class definition | |||
negation | not a
| Yes | bool T::operator!() const; | bool operator!(const T &a); |
AND | a and b
| Yes | bool T::operator&&(const T2 &b) const; | bool operator&&(const T &a, const T2 &b); |
inclusive OR | a or b
| Yes | bool T::operator||(const T2 &b) const; | bool operator||(const T &a, const T2 &b); |
Notes
|
Explanation
The logical operators apply logic functions (NOT, AND, and inclusive OR) to boolean arguments (or types contextually-convertible to bool
), with a boolean result. Unlike the bitwise logic operators, these operators (in their built-in form) do not evaluate the second operand if the result is known after evaluating the first.
Builtin operators
The following built-in function signatures participate in overload resolution:
bool operator!(bool) | ||
bool operator&&(bool, bool) | ||
bool operator||(bool, bool) |
If the operand is not bool
, it is converted to bool
using contextual conversion to bool: it is only well-formed if the declaration bool t(arg)
is well-formed, for some invented temporary t
.
For the built-in logical NOT operator, the result is true
if the operand is false
. Otherwise, the result is false
.
For the built-in logical AND operator, the result is true
if both operands are true
. Otherwise, the result is false
. If the first operand is false
, the second operand is not evaluated.
For the built-in logical OR operator, the result is true
if either the first or the second operand (or both) is true
. If the firstoperand is true
, the second operand is not evaluated.
Results
a | true | false |
---|---|---|
!a | false | true |
and | a | ||
---|---|---|---|
true | false | ||
b | true | true | false |
false | false | false |
or | a | ||
---|---|---|---|
true | false | ||
b | true | true | true |
false | true | false |
Example
#include <iostream> #include <string> int main() { int n = 2; int* p = &n; // pointers are convertible to bool if( p && *p == 2 // "*p" is safe to use after "p &&" || !p && n != 2 ) // || has lower precedence than && std::cout << "true\n"; // streams are also convertible to bool std::cout << "Enter 'quit' to quit.\n"; for(std::string line; std::cout << "> " && std::getline(std::cin, line) && line != "quit"; ) ; }
Output:
true Enter 'quit' to quit. > test > quit
Standard library
Because the short-circuiting properties of operator&&
and operator||
do not apply to overloads, and because types with boolean semantics are uncommon, only two standard library classes overload these operators:
applies a unary arithmetic operator to each element of the valarray (public member function of std::valarray ) | |
applies binary operators to each element of two valarrays, or a valarray and a value (function template) | |
operator!
| checks if an error has occurred (synonym of fail() ) (public member function of std::basic_ios ) |
See also
Common operators | ||||||
---|---|---|---|---|---|---|
assignment | increment decrement | arithmetic | logical | comparison | member access | other |
|
|
|
|
|
|
|
Special operators | ||||||
|
Please login to continue.