The overall result of the logical AND operator is true
if and only if both its operands evaluate to true
. The logical OR (||
) operator evaluates as true
if either of its operands evaluates as true
.
The logical AND and OR operators always evaluate their left operand before the right. Moreover, the right operand is evaluated if and only if the left operand does not determine the result. This strategy is known as short-circuit evaluation:
• The right side of an &&
is evaluated if and only if the left side is true
.
• The right side of an ||
is evaluated if and only if the left side is false
.
Several of the programs in Chapter 3 used the logical AND operator. Those programs used the left-hand operand to test whether it was safe to evaluate the right-hand operand. For example, the for
condition on page 94:
index != s.size() && !isspace(s[index])
first checks that index
has not reached the end of its associated string
. We’re guaranteed that the right operand won’t be evaluated unless index
is in range.
As an example that uses the logical OR, imagine we have some text in a vector
of string
s. We want to print the string
s, adding a newline after each empty string
or after a string
that ends with a period. We’ll use a range-based for
loop (§ 3.2.3, p. 91) to process each element:
// note s as a reference to const; the elements aren't copied and can't be changed
for (const auto &s : text) { // for each element in text
cout << s; // print the current element
// blank lines and those that end with a period get a newline
if (s.empty() || s[s.size() - 1] == '.')
cout << endl;
else
cout << " "; // otherwise just separate with a space
}
After we print the current element, we check to see if we need to print a newline. The condition in the if
first checks whether s
is an empty string
. If so, we need to print a newline regardless of the value of the right-hand operand. Only if the string
is not empty do we evaluate the second expression, which checks whether the string
ends with a period. In this expression, we rely on short-circuit evaluation of ||
to ensure that we subscript s
only if s
is not empty.
It is worth noting that we declared s
as a reference to const
(§ 2.5.2, p. 69). The elements in text
are string
s, and might be large. By making s
a reference, we avoid copying the elements. Because we don’t need to write to the elements, we made s
a reference to const
.