In addition to the relational operators, C++ also has three logical operators: &&, ||, and !, which respectively stand for and, or, and not. They are called logical operators because they operator on “logical” (Boolean) values. The results of these operators are similar to their meanings in English. For example:
x > 0 && x < 10 is true when x is greater than 0 and less than 10.
In order for an expression with && to be true, both sides of the && operator must be true. The && operator is equivalent to using nested if statements. For example, the following code:
C++ does not allow compound conditions like you would write in math. In C++, 0 < x < 10 does NOT test to see if if x is between 0 and 10. Instead, it tests if 0 is less than x, and produces a result of 0 or 1 (true or false). It then tests that value to see if it is less than 10, which will always be true. You MUST write this as two conditions combined with &&: 0 < x && x < 10`.
The || operator can simplify our logic where multiple different tests all should result in the same behavior. For example, there are two ways for this code to print the message:
// combined
if (x == 0 || y == 0) {
cout << "Either x or y is zero";
}
Warning7.7.2.
C++ also does not allow us to directly translate “x is equal to 3 or 4” as x == 3 || 4. Instead, you must write x == 3 || x == 4. The first expression would be interpreted as x == 3 or 4. Since 4 is always true, the expression would always be true.
bool isEven = true;
if (!isEven) {
// we know it's odd...
That if statement is equivalent to if (isEven == false), but most programmers prefer the version using !. It can also be used to reverse the value calculated by some other logical operation. For example, to test if health is not less than 0 we could do: !(health < 0). Notice that we need the parentheses to make it clear that we want to FIRST calculate “is health less than 0” and then calculate the opposite of that value. Of course we could also write that expression as (health >= 0) which more clearly expresses what we are looking for.
Logical operators evaluate the second expression only when necessary. For example, true || anything is always true, so C++ does not need to evaluate the expression anything. Likewise, false && anything is always false.
Ignoring the second operand, when possible, is called short-circuit evaluation, by analogy with an electrical circuit. Short-circuit evaluation can save time, especially if anything takes a long time to evaluate. It can also avoid unnecessary errors, if anything might fail. For example, dividing an integer by 0 is a runtime error that will stop a program. This code avoids that by testing b before dividing a by it. If a is 0, then the a != 0 is false and the second clause which involves division never gets executed:
Normally you don’t have to worry about short circuit evaluation (other than possibly to use it as a guard). But if the second part of a conditional has a side effect—if it changes some value—, the logic can be tricky to follow:
Here, if x is greater than 0, the y++ is never executed. But if x is less than or equal to 0, then y is incremented. It would be easy to expect that y always increases. A good rule of thumb is to avoid doing anything in a complex conditional that has a side effect.
