Operator precedence and associativity

Transcription

1 Operator precedence and associativity In mathematics, an operation is a mathematical calculation involving zero or more input values (called operands) that produces an output value. Common operations (such as addition) use special symbols (such as +) that denote the operation. These symbols are called operators. Operators in programming work the same way except the names may not always be a symbol. Operators work analogously to functions that take input parameters and return a value, except they are more concise. For example, + * is much easier to read than add(, mult(, ))! In order to properly evaluate an expression such as + *, we must understand both what the operators do, and the correct order to apply them. The order in which operators are evaluated in a compound expression is called operator precedence. Using normal mathematical precedence rules (which state that multiplication is resolved before addition), we know that the above expression should evaluate as + ( * ) to produce the value 0. In C++, when the compiler encounters an expression, it must similarly analyze the expression and determine how it should be evaluated. To assist with this, all operators are assigned a level of precedence. Those with the highest precedence are evaluated first. You can see in the table below that multiplication and division (precedence level ) have a higher precedence than addition and subtraction (precedence level ). The compiler uses these levels to determine how to evaluate expressions it encounters. Thus, + * evaluates as + ( * ) because multiplication has a higher level of precedence than addition. If two operators with the same precedence level are adjacent to each other in an expression, the operator associativity rules tell the compiler whether to evaluate the operators from left to right or from right to left. For example, in the expression * /, the multiplication and division operators are both precedence level. Level has an associativity of left to right, so the expression is resolved from left to right: ( * ) / =.

2 Table of operators Notes: Precedence level is the highest precedence level, and level is the lowest. Operators with a higher precedence level get evaluated first. L->R means left to right associativity. R->L means right to left associativity. Lvalue (locator value), rvalue Prec/ Ass None :: :: L->R R->L ! ~ Operator Description Pattern () () () } type() type} []. -> ++ typeid const_cast dynamic_ca st reinterpret_ cast static_cast Global scope (unary) Class scope (binary) Parentheses Function call Initialization Uniform initialization (C+ +) Functional cast Functional cast (C++) Array subscript Member access from object Member access from object ptr Post-increment Post-decrement Run-time type information Cast away const Run-time type-checked cast Cast one type to another Compile-time typechecked cast Unary plus Unary minus Pre-increment Pre-decrement Logical NOT Bitwise NOT ::name class_name::member_name (expression) function_name(parameters) type name(expression) type nameexpression} new_type(expression) new_typeexpression} pointer[expression] object.member_name object_pointer- >member_name lvalue++ lvalue typeid(type) or typeid(expression) const_cast<type>(expression ) dynamic_cast<type>(express ion) reinterpret_cast<type>(expre ssion) static_cast<type>(expression ) +expression -expression ++lvalue lvalue!expression ~expression

3 L->R ->*.* L->R L->R + - (type) sizeof & * new new[] delete delete[] * / % L->R << >> 8 L->R < <= > >= 9 L->R ==!= 0 L- >R L- >R L- >R L- >R L- >R C-style cast Size in bytes Address of Dereference Dynamic memory allocation Dynamic array allocation Dynamic memory deletion Dynamic array deletion Member pointer selector Member object selector Multiplication Division Modulus Addition Subtraction Bitwise shift left Bitwise shift right Comparison less than Comparison less than or equals Comparison greater than Comparison greater than or equals Equality Inequality (new_type)expression sizeof(type) or sizeof(expression) &lvalue *expression new type new type[expression] delete pointer delete[] pointer object_pointer- >*pointer_to_member object.*pointer_to_member expression * expression expression / expression expression % expression expression + expression expression - expression expression << expression expression >> expression expression < expression expression <= expression expression > expression expression >= expression expression == expression expression!= expression & Bitwise AND expression & expression ^ Bitwise XOR expression ^ expression Bitwise OR expression expression && Logical AND expression && expression Logical OR expression expression R-?: Conditional (see note expression? expression :

4 >L R- >L = *= /= %= += -= <<= >>= &= = ^= below) Assignment Multiplication assignment Division assignment Modulus assignment Addition assignment Subtraction assignment Bitwise shift left assignment Bitwise shift right assignment Bitwise AND assignment Bitwise OR assignment Bitwise XOR assignment expression lvalue = expression lvalue *= expression lvalue /= expression lvalue %= expression lvalue += expression lvalue -= expression lvalue <<= expression lvalue >>= expression lvalue &= expression lvalue = expression lvalue ^= expression throw Throw expression throw expression L-, Comma operator expression, expression >R Note: The expression in the middle of the conditional operator?: is evaluated as if it were parenthesized. A few operators you should already recognize: +, -, *, /, (), =, <, >, <=, and >=. These arithmetic and relational operators have the same meaning in C++ as they do in every-day usage. However, unless you have experience with another programming language, it s likely the majority of the operators in this table will be incomprehensible to you right now. That s expected at this point. We ll cover many of them in this chapter, and the rest will be introduced as there is a need for them. The above table is primarily meant to be a reference chart that you can refer back to in the future to resolve any precedence or associativity questions you have. That said, if you have an expression that uses operators of different types, it is a best practice to use parenthesis to explicitly disambiguate the order of evaluation. Rule: If your expression uses different operators, use parenthesis to make it clear how the expression should evaluate, even if they are technically

5 unnecessary. How do I do exponents? You ll note that the ^ operator (commonly used to denote exponentiation in standard mathematical nomenclature) is a Bitwise XOR operation in C++. C++ does not include an exponent operator. To do exponents in C++, #include the <cmath> header, and use the pow() function: #include <cmath> double x = pow(.0,.0); // to the th power Note that the parameters and return value of pow are of type double. Note that due to rounding errors in floating point numbers, the results of pow() may not be precise (slightly smaller or larger than what you d expect). If you want to do integer exponents, you re best off just using your own function to do so, like this one (that uses the exponentiation by squaring algorithm for efficiency): // note: exp must be non-negative int pow(int base, int exp) int result = ; while (exp) if (exp & ) result *= base; exp >>= ; base *= base; } return result; }

6 Don t worry if you don t understand all of the parts of this function yet. Just beware of overflowing your integer result, which can happen very quickly if either argument is large. Arithmetic operators Unary arithmetic operators There are two unary arithmetic operators, plus (+), and minus (-). If you remember, unary operators are operators that only take one operand. Operator Symb ol Unary plus For m Operation + +x Value of x Unary Negation - -x minus of x The unary plus operator returns the value of the operand. In other words, + =, and +x = x. Generally you won t need to use this operator since it s redundant. It was added largely to provide symmetry with the unary minus operator. The unary minus operator returns the operand multiplied by -. In other words, if x =, -x = -. For best effect, both of these operators should be placed immediately preceding the operand (eg. -x, not - x). Do not confuse the unary minus operator with the binary subtraction operator, which uses the same symbol. For example, in the expression x = - -;, the first minus is the subtraction operator, and the second is the unary minus operator. Binary arithmetic operators There are binary arithmetic operators. Binary operators are operators that take a left and right operand.

7 Operator Addition + Symb ol For m x + y x plus y Subtraction - x - y x minus y Multiplication * x * y Operation x multiplied by y Division / x / y x divided by y Modulus x % The remainder of x % (Remainder) y divided by y The addition, subtraction, and multiplication operators work just like they do in real life, with no caveats. Division and modulus (remainder) need some additional explanation. Integer and floating point division It is easiest to think of the division operator as having two different modes. If both of the operands are integers, the division operator performs integer division. Integer division drops any fractions and returns an integer value. For example, / = because the fraction is dropped. Note that integer division does not round. If either or both of the operands are floating point values, the division operator performs floating point division. Floating point division returns a floating point value, and the fraction is kept. For example,.0 / =., /.0 =., and.0 /.0 =.. Note that trying to divide by 0 (or 0.0) will generally cause your program to crash, as the results are undefined! Using static_cast<> to do floating point division with integers We can similarly use static_cast<> to convert an integer to a floating point number so that we can do floating point division instead of integer division. Consider the following code: #include <iostream> int main()

8 8 9 0 int x = ; int y = ; std::cout << "int / int = " << x / y << "\n"; std::cout << "double / int = " << static_cast<double>(x) / y << "\n"; std::cout << "int / double = " << x / static_cast<double>(y) << "\n"; std::cout << "double / double = " << static_cast<double>(x) / static_cast<double>(y) << "\n"; } return 0; This produces the result: int / int = double / int =. int / double =. double / double =. Modulus (remainder) The modulus operator is also informally known as the remainder operator. The modulus operator only works on integer operands, and it returns the remainder after doing integer division. For example, / = remainder, thus % =. As another example, / = remainder, thus % =. Modulus is very useful for testing whether a number is evenly divisible by another number: if x % y == 0, then we know that y divides evenly into x. For example, say we wanted to write a program that printed every number from to 00 with 0 numbers per line. We could use the modulus operator to determine where to do the line breaks. Even though you haven t seen a while statement yet, the following program should be pretty comprehensible: #include <iostream> int main() // count holds the current number to print

9 int count = ; // start at // Loop continually until we pass number 00 while (count <= 00) std::cout << count << " "; // print the current number // if count is evenly divisible by 0, print a new line if (count % 0 == 0) std::cout << "\n"; count = count + ; // go to next number } // end of while return 0; } // end of main() This results in: We ll discuss while statements in a future lesson. A warning about integer division and modulus with negative numbers

10 prior to C++ Prior to C++, if either of the operands of integer division are negative, the compiler is free to round up or down! For example, - / can evaluate to either - or -, depending on which way the compiler rounds. However, most modern compilers truncate towards 0 (so - / would equal -). The C++ specification changed this to explicitly define that integer division should always truncate towards 0 (or put more simply, the fractional component is dropped). Also prior to C++, if either operand of the modulus operator is negative, the results of the modulus can be either negative or positive! For example, - % can evaluate to either or -. The C++ specification tightens this up so that a % b always resolves to the sign of a. Arithmetic assignment operators Operator Symb ol Form Operation Assignment = x = y Assign value y to x Addition assignment += Subtraction assignment Multiplication assignment -= *= Division assignment /= x += y x -= y x *= y Add y to x Subtract y from x Multiply x by y x /= y Divide x by y x %= Put the remainder of x / Modulus assignment %= y y in x Up to this point, when you ve needed to add to a variable, you ve likely done the following: x = x + ; This works, but it s a little clunky, and takes two operators to execute. Because writing statements such as x = x + is so common, C++ provides arithmetic assignment operators for convenience. Instead of writing x = x +, you can write x +=. Instead of x = x * y, you can write x *= y.

11 Where s the exponent operator? Astute readers will note that there is no exponent operator. Instead, you have to use the pow() function that lives in the cmath library. pow(base, exponent) is the equivalent of base exponent. It s worth noting that the parameters to pow() are doubles, so it can handle non-integer exponents #include <cmath> // needed for pow() #include <iostream> int main() std::cout << "Enter the base: "; double base; std::cin >> base; } std::cout << "Enter the exponent: "; double exp; std::cin >> exp; std::cout << base << "^" << exp << " = " << pow(base, exp) << "\n"; return 0; Increment/decrement operators, and side effects Incrementing (adding to) and decrementing (subtracting from) a variable are

12 so common that they have their own operators in C. There are actually two versions of each operator -- a prefix version and a postfix version. Operator Prefix increment (preincrement) Prefix decrement (predecrement) Postfix increment (postincrement) Symb ol For m ++ ++x x ++ x++ Operation Increment x, then evaluate x Decrement x, then evaluate x Evaluate x, then increment x Postfix decrement (postdecrement) decrement x Evaluate x, then - - x- - The prefix increment/decrement operators are very straightforward. The value of x is incremented or decremented, and then x is evaluated. For example: int x = ; int y = ++x; // x is now equal to, and is assigned to y The postfix increment/decrement operators are a little more tricky. The compiler makes a temporary copy of x, increments or decrements the original x (not the copy), and then evaluates the temporary copy of x. The temporary copy of x is then discarded. int x = ; int y = x++; // is assigned to y, and x is now equal to Let s examine how this last line works in more detail. First, the compiler makes a temporary copy of x that starts with the same value as x (). Then it increments the original x from to. Then the compiler evaluates the temporary copy, which evaluates to, and assigns that value to y. Then the temporary copy is discarded. Consequently, y ends up with the value of, and x ends up with the value. Here is another example showing the difference between the prefix and postfix versions: int x =, y = ; cout << x << " " << y << endl; cout << ++x << " " << --y << endl; // prefix

13 cout << x << " " << y << endl; cout << x++ << " " << y-- << endl; // postfix cout << x << " " << y << endl; This produces the output: On the third line, x and y are incremented/decremented before they are evaluated, so their new values are printed by cout. On the fifth line, a temporary copy of the original values (x=, y=) is sent to cout, and then the original x and y are incremented. That is why the changes from the postfix operators don t show up until the next line. Rule: Favor pre-increment and pre-decrement over post-increment and postdecrement. The prefix versions are not only more performant, you re less likely to run into strange issues with them. Side effects A function or expression is said to have a side effect if it modifies some state (e.g. any stored information in memory), does input or output, or calls other functions that have side effects. Most of the time, side effects are useful: x = ; ++x; std::cout << x; The assignment operator in the above example has the side effect of changing the value of x permanently. Even after the statement has finished executing, x will have the value. Operator++ has the side effect of incrementing x. The outputting of x has the side effect of modifying the console. However, side effects can also lead to unexpected results: int add(int x, int y)

14 8 9 0 return x + y; } int main() int x = ; int value = add(x, ++x); // is this +, or +? It depends on what order your compiler evaluates the function arguments in std::cout << value; // value could be or, depending on how the above line evaluates! return 0; } C++ does not define the order in which function arguments are evaluated. If the left argument is evaluated first, this becomes a call to add(, ), which equals. If the right argument is evaluated first, this becomes a call to add(, ), which equals! Note that this is only a problem because one of the argument to function add() has a side effect. Here s another popular example: 8 int main() int x = ; x = x++; std::cout << x; return 0; } What value does this program print? The answer is: it s undefined. If the ++ is applied to x before the assignment, the answer will be (postfix operator++ increments x from to, but it evaluates to, so the expression becomes x = ). If the ++ is applied to x after the assignment, the answer will be (this evaluates as x = x, then postfix operator++ is applied, incrementing x from to ).

15 There are other cases where C++ does not specify the order in which certain things are evaluated, so different compilers will make different assumptions. Even when C++ does make it clear how things should be evaluated, some compilers implement behaviors involving variables with side-effects incorrectly. These problems can generally all be avoided by ensuring that any variable that has a side-effect applied is used no more than once in a given statement. Rule: Don t use a variable that has a side effect applied to it more than once in a given statement. If you do, the result may be undefined. Please don t ask why your programs that violate the above rule produce results that don t seem to make sense. That s what happens when you write programs that have undefined behavior. Sizeof, comma, and conditional operators Sizeof operator Operator Symbol Form Operation Sizeof sizeof sizeof(type) sizeof(variable) Returns size of type or variable in bytes Note that sizeof can also be used on a variable, and will return the size of that variable: #include <iostream> int main() double d =.0; std::cout << sizeof(d); // will print the size of variable d in bytes } Comma operator Operator Symbol Comma, Operation Evaluate x then y, returns value of y

16 The comma operator allows you to evaluate multiple expressions wherever a single expression is allowed. The comma operator evaluates to its rightmost operand. For example: int x = 0; int y = ; int z = (++x, ++y); // increment x and y z would be assigned the result of evaluating ++y, which equals. In almost every case, a statement written using a comma would be better written as separate statements. For example, the above code should be written as: int x = 0; int y = ; ++x; ++y; int z = y; Note that comma has the lowest precedence of all the operators, even lower than assignment. Because of this, the following two lines of code do different things: z = (a, b); // evaluate (a, b) first to get result of b, then assign that value to variable z. z = a, b; // evaluates as "(z = a), b", so z gets assigned the value of a, and b is discarded. Most programmers do not use the comma operator at all, with the single exception of inside for loops, where its use is fairly common. We discuss for loops in a future lesson. Note that although a comma is used to separate the parameters in a function call, this is not using the comma operator. int sum = add(x, y); // this comma is not the comma operator Similarly, when declaring multiple variables on a single line, the comma there is just a normal separator, not the comma operator

17 int x(), y(); // this comma is not the comma operator either Rule: Avoid using the comma operator, except within for loops. Conditional operator Operator Symbol Form Operation If c is nonzero (true) then evaluate x, Conditional?: c? x : y otherwise evaluate y The conditional operator (?:) (also known as the arithmetic if operator) is C+ + s only ternary operator (it takes operands). Because of this, it s also sometimes referred to as the ternary operator (we suggest you avoid calling it this in case C++ adds another ternary operator in the future). The?: operator provides a shorthand method for doing a particular type of if/else statement. If/else statements in the following form: if (condition) expression; else other_expression; can be rewritten as: (condition)? expression : other_expression; Note that the operands of the conditional operator must be expressions themselves (not statements). For example, an if/else statement that looks like this: if (condition) x = some_value else x = some_other_value can be rewritten as: x = (condition)? some_value : some_other_value; Many people find this more compact form easier to read.

18 As another example, to put the larger of values x and y in variable larger, we could write this: if (x > y) larger = x; else larger = y; Or this: larger = (x > y)? x : y; It is common to put the conditional part of the expression inside of parenthesis, both to make it easier to read, and also to make sure the precedence is correct. It is also worth noting that the expression between the? and : is evaluated as if it were parenthesized. Keep in mind that the?: operator has a very low precedence. If doing anything other than assigning the result to a variable, the?: statement needs to be wrapped in parenthesis. For example to print the larger of values x and y to the screen, we could do this: if (x > y) std::cout << x; else std::cout << y; Or we could do this: std::cout << ((x > y)? x : y); Because the << operator has higher precedence than the?: operator, the statement: std::cout << (x > y)? x : y; would evaluate as: (std::cout << (x > y))? x : y; That would print (true) if x > y, or 0 (false) otherwise! The conditional operator gives us a convenient way to simplify simple if/else

19 statements, particularly when assigning the result to a variable or returning the result as part of a function return. It should not be used for complex if/else statements, as it quickly becomes both unreadable and error prone. Rule: Only use the conditional operator for simple conditionals where it enhances readability. The conditional operator evaluates as an expression It s worth noting that the conditional operator evaluates as an expression, whereas if/else evaluates as statements. This means the conditional operator can be used in some places where if/else can not. For example, when initializing a const variable: bool inbigclassroom = false; const int classsize = inbigclassroom? 0 : 0; There s no satisfactory if/else statement for this, since const variables must be initialized when defined, and the initializer can t be a statement. Relational operators (comparisons) There are relational operators: Operator Symb ol For m Operation Greater than > x > y true if x is greater than y, false otherwise Less than < x < y true if x is less than y, false otherwise Greater than or equals Less than or equals >= <= Equality == x >= y x <= y x == y true if x is greater than or equal to y, false otherwise true if x is less than or equal to y, false otherwise true if x equals y, false otherwise Inequality!= x!= true if x does not equal y, false otherwise

20 y You have already seen how all of these work, and they are pretty intuitive. Each of these operators evaluates to the boolean value true (), or false (0). Here s some sample code using these operators with integers: #include <iostream> int main() std::cout << "Enter an integer: "; int x; std::cin >> x; std::cout << "Enter another integer: "; int y; std::cin >> y; if (x == y) std::cout << x << " equals " << y << "\n"; if (x!= y) std::cout << x << " does not equal " << y << "\n"; if (x > y) std::cout << x << " is greater than " << y << "\n"; if (x < y) std::cout << x << " is less than " << y << "\n"; if (x >= y) std::cout << x << " is greater than or equal to " << y << "\n"; if (x <= y) std::cout << x << " is less than or equal to " << y << "\n"; return 0; } And the results from a sample run: Enter an integer: Enter another integer: does not equal is less than is less than or equal to These operators are extremely straightforward to use when comparing integers.

21 Comparison of floating point values Directly comparing floating point values using any of these operators is dangerous. This is because small rounding errors in the floating point operands may cause unexpected results. Here s an example of rounding errors causing unexpected results: #include <iostream> int main() double d( ); // should equal 0.0 double d(0-9.99); // should equal 0.0 } if (d == d) std::cout << "d == d" << "\n"; else if (d > d) std::cout << "d > d" << "\n"; else if (d < d) std::cout << "d < d" << "\n"; return 0; This program prints an unexpected result: d > d In the above program, d = and d = Both numbers are close to 0.0, but d is greater than, and d is less than. And neither are equal. Sometimes the need to do floating point comparisons is unavoidable. In this case, the less than and greater than operators (>, >=, <, and <=) are often used with floating point values as normal. The operators will produce the correct result most of the time, only potentially failing when the two operands are close. Due to the way these operators tend to be used, a wrong result often only has slight consequences. The equality operator is much more troublesome since even the smallest of rounding errors makes it completely inaccurate. Consequently, using operator== or operator!= on floating point numbers is not

22 advised. The most common method of doing floating point equality involves using a function that calculates how close the two values are to each other. If the two numbers are "close enough", then we call them equal. The value used to represent "close enough" is traditionally called epsilon. Epsilon is generally defined as a small number (e.g ). New developers often try to write their own close enough function like this: #include <cmath> // for fabs() bool isalmostequal(double a, double b, double epsilon) // if the distance between a and b is less than epsilon, then a and b are "close enough" return fabs(a - b) <= epsilon; } fabs() is a function in the <cmath> library that returns the absolute value of its parameter. fabs(a - b) returns the distance between a and b as a positive number. This function checks if the distance between a and b is less than whatever epsilon value representing close enough was passed in. If a and b are close enough, the function returns true. While this works, it s not great. An epsilon of is good for inputs around.0, too big for numbers around , and too small for numbers like 0,000. This means every time we call this function, we have to pick an epsilon that s appropriate for our inputs. If we know we re going to have to scale epsilon in proportion to our inputs, we might as well modify the function to do that for us. Donald Knuth, a famous computer scientist, suggested the following method in his book The Art of Computer Programming, Volume II: Seminumerical Algorithms (Addison-Wesley, 99) : #include <cmath> // return true if the difference between a and b is within epsilon percent of the larger of a and b bool approximatelyequal(double a, double b, double epsilon) return fabs(a - b) <= ( (fabs(a) < fabs(b)? fabs(b) : fabs(a)) * epsilon); }

23 In this case, instead of using epsilon as an absolute number, we re using epsilon as a multiplier, so its effect is relative to our inputs. Let s examine in more detail how the approximatelyequal() function works. On the left side of the <= operator, the absolute value of a - b tells us the distance between a and b as a positive number. On the right side of the <= operator, we need to calculate the largest value of "close enough" we're willing to accept. To do this, the algorithm chooses the larger of a and b (as a rough indicator of the overall magnitude of the numbers), and then multiplies it by epsilon. In this function, epsilon represents a percentage. For example, if we want to say "close enough" means a and b are within % of the larger of a and b, we pass in an epsilon of % (% = /00 = 0.0). The value for epsilon can be adjusted to whatever is most appropriate for the circumstances (e.g. 0.0% = an epsilon of 0.000). To do inequality (!=) instead of equality, simply call this function and use the logical NOT operator (!) to flip the result: if (!approximatelyequal(a, b, 0.00)) std::cout << a << " is not equal to " << b << "\n"; Note that while the approximatelyequal() function will work for many cases, it is not perfect, especially as the numbers approach zero: #include <iostream> int main() // a is really close to.0, but has rounding errors, so it's slightly smaller than.0 double a = ; // First, let's compare a (almost.0) to.0. std::cout << approximatelyequal(a,.0, e-8) << "\n"; // Second, let's compare a-.0 (almost 0.0) to 0.0 std::cout << approximatelyequal(a-.0, 0.0, e-8) << "\n"; } Perhaps surprisingly, this returns: 0

24 The second call didn t perform as expected. The math simply breaks down close to zero. One way to avoid this is to use both an absolute epsilon (as we did in the first approach) and a relative epsilon (as we did in Knuth s approach): // return true if the difference between a and b is less than absepsilon, or within relepsilon percent of the larger of a and b bool approximatelyequalabsrel(double a, double b, double absepsilon, double relepsilon) // Check if the numbers are really close -- needed when comparing numbers near zero. double diff = fabs(a - b); if (diff <= absepsilon) return true; // Otherwise fall back to Knuth's algorithm return diff <= ( (fabs(a) < fabs(b)? fabs(b) : fabs(a)) * relepsilon); } In this algorithm, we ve added a new parameter: absepsilon. First, we check to see if the distance between a and b is less than our absepsilon, which should be set at something very small (e.g. e-). This handles the case where a and b are both close to zero. If that fails, then we fall back to Knuth s algorithm. Here s our previous code testing both algorithms: #include <iostream> int main() // a is really close to.0, but has rounding errors double a = ; std::cout << approximatelyequal(a,.0, e-8) << "\n"; // compare "almost.0" to.0 std::cout << approximatelyequal(a-.0, 0.0, e-8) << "\n"; // compare "almost 0.0" to 0.0 std::cout << approximatelyequalabsrel(a-.0, 0.0, e-, e-8) << "\n"; // compare "almost 0.0" to 0.0 }

25 You can see that with an appropriately picked absepsilon, approximatelyequalabsrel() handles the small inputs correctly. Comparison of floating point numbers is a difficult topic, and there s no one size fits all algorithm that works for every case. However, the approximatelyequalabsrel() should be good enough to handle most cases you ll encounter. Logical operators While relational (comparison) operators can be used to test whether a particular condition is true or false, they can only test one condition at a time. Often we need to know whether multiple conditions are true at once. For example, to check whether we ve won the lottery, we have to compare whether all of the multiple numbers we picked match the winning numbers. In a lottery with numbers, this would involve comparisons, all of which have to be true. Other times, we need to know whether any one of multiple conditions is true. For example, we may decide to skip work today if we re sick, or if we re too tired, or if won the lottery in our previous example. This would involve checking whether any of comparisons is true. Logical operators provide us with this capability to test multiple conditions. C++ provides us with logical operators: Operator Symb ol Logical NOT Logical AND Form Operation!!x true if x is false, or false if x is true && x && y Logical x y OR Logical NOT true if both x and y are true, false otherwise true if either x or y are true, false otherwise We can summarize the effects of logical NOT like so:

26 true Logical NOT (operator!) Right operand false Result false true If logical NOT s operand evaluates to true, logical NOT evaluates to false. If logical NOT s operand evaluates to false, logical NOT evaluates to true. In other words, logical NOT flips a boolean value from true to false, and viceversa. Logical NOT is often used in conditionals: bool btoolarge = (x > 00); // btoolarge is true if x > 00 if (!btoolarge) // do something with x else // print an error One thing to be wary of is that logical NOT has a very high level of precedence. New programmers often make the following mistake: int x = ; int y = ; if (! x == y) cout << "x does not equal y"; else cout << "x equals y"; This program prints x equals y! But x does not equal y, so how is this possible? The answer is that because the logical NOT operator has higher precedence than the equality operator, the expression! x == y actually evaluates as (!x) == y. Since x is,!x evaluates to 0, and 0 == y is false, so the else statement executes! Reminder: any non-zero integer value evaluates to true when used in a boolean context. Since x is, x evaluates to true, and!x evaluates to false (0). Mixing integer and boolean operations like this can be very confusing, and should be avoided!

27 The correct way to write the above snippet is: int x = ; int y = ; if (!(x == y)) cout << "x does not equal y"; else cout << "x equals y"; This way, x == y will be evaluated first, and then logical NOT will flip the boolean result. Rule: If logical NOT is intended to operate on the result of other operators, the other operators and their operands need to be enclosed in parenthesis. Rule: It s a good idea to always use parenthesis to make your intent clear -- that way, you don t even have to remember the precedence rules. Simple uses of logical NOT, such as if (!bvalue) do not need parenthesis because precedence does not come into play. Logical OR The logical OR operator is used to test whether either of two conditions is true. If the left operand evaluates to true, or the right operand evaluates to true, the logical OR operator returns true. If both operands are true, then logical OR will return true as well. Left operand Logical OR (operator ) Right operand false false false false true true true false true Result true true true For example, consider the following program: #include <iostream> int main()

28 8 9 0 } std::cout << "Enter a number: "; int value; std::cin >> value; if (value== 0 value== ) std::cout << "You picked 0 or " << std::endl; else std::cout << "You did not pick 0 or " << std::endl; return 0; In this case, we use the logical OR operator to test whether either the left condition (value == 0) or the right condition (value == ) is true. If either (or both) are true, the logical OR operator evaluates to true, which means the if statement executes. If neither are true, the logical OR operator evaluates to false, which means the else statement executes. You can string together many logical OR statements: if (value == 0 value == value == value == ) std::cout << "You picked 0,,, or " << std::endl; New programmers sometimes confuse the logical OR operator ( ) with the bitwise OR operator ( ). Even though they both have OR in the name, they perform different functions. Mixing them up will probably lead to incorrect results. Logical AND The logical AND operator is used to test whether both conditions are true. If both conditions are true, logical AND returns true. Otherwise, it returns false. Logical AND (operator &&) Left operand Right operand Result false false false false true false

29 true false false true true true For example, we might want to know if the value of variable x is between 0 and 0. This is actually two conditions: we need to know if x is greater than 0, and also whether x is less than #include <iostream> int main() std::cout << "Enter a number: "; int value; std::cin >> value ; if (value > 0 && value < 0) std::cout << "Your value is between 0 and 0" << std::endl; else std::cout << "Your value is not between 0 and 0" << std::endl; return 0; } In this case, we use the logical AND operator to test whether the left condition (value > 0) AND the right condition (value < 0) are both true. If both are true, the logical AND operator evaluates to true, and the if statement executes. If neither are true, or only one is true, the logical AND operator evaluates to false, and the else statement executes. As with logical OR, you can string together many logical AND statements: if (value > 0 && value < 0 && value!= ) // do something else // do something else If all of these conditions are true, the if statement will execute. If any of these conditions are false, the else statement will execute.

30 Short circuit evaluation In order for logical AND to return true, both operands must evaluate to true. If the first operand evaluates to false, logical AND knows it must return false regardless of whether the second operand evaluates to true or false. In this case, the logical AND operator will go ahead and return false immediately without even evaluating the second operand! This is known as short circuit evaluation, and it is done primarily for optimization purposes. Similarly, if the first operand for logical OR is true, then the entire OR condition has to evaluate to true, and the second operand does not need to be evaluated. Short circuit evaluation presents another opportunity to show why operators that cause side effects should not be used in compound expressions. Consider the following snippet: if (x == && y++ == ) // do something if x does not equal, the conditional must be false, so y++ never gets evaluated! Thus, y will only be incremented if x evaluates to, which is probably not what the programmer intended! As with logical and bitwise OR, new programmers sometimes confuse the logical AND operator (&&) with the bitwise AND operator (&). Mixing ANDs and ORs Mixing logical AND and logical OR operators in the same expression often can not be avoided, but it is an area full of potential dangers. Many programmers assume that logical AND and logical OR have the same precedence (or forget that they don t), just like addition/subtraction and multiplication/division do. However, logical AND has higher precedence than logical OR, thus logical AND operators will be evaluated ahead of logical OR operators (unless they have been parenthesized). As a result of this, new programmers will often write expressions such as value value && value. Because logical AND has higher precedence, this evaluates as value (value && value), not

31 (value value) && value. Hopefully that s what the programmer wanted! If the programmer was assuming left to right evaluation (as happens with addition/subtraction, or multiplication/division), the programmer will get a result he or she was not expecting! When mixing logical AND and logical OR in the same expression, it is a good idea to explicitly parenthesize each operator and its operands. This helps prevent precedence mistakes, makes your code easier to read, and clearly defines how you intended the expression to evaluate. For example, rather than writing value && value value && value, it is better to write (value && value) (value && value). De Morgan s law Many programmers also make the mistake of thinking that!(x && y) is the same thing as!x &&!y. Unfortunately, you can not distribute the logical NOT in that manner. De Morgan s law tells us how the logical NOT should be distributed in these cases:!(x && y) is equivalent to!x!y!(x y) is equivalent to!x &&!y In other words, when you distribute the logical NOT, you also need to flip logical AND to logical OR, and vice-versa! This can sometimes be useful when trying to make up complex expressions easier to read. Where s the logical exclusive or (XOR) operator? Logical XOR is a logical operator provided in some languages that is used to test whether an odd number of conditions is true. Left operand Logical XOR Right operand false false false false true true true false true Result

32 true true false C++ doesn t provide a logical XOR operator. Unlike logical OR or logical AND, XOR cannot be short circuit evaluated. Because of this, making an XOR operator out of logical OR and logical AND operators is challenging. However, you can easily mimic logical XOR using the not equals operator (!=): if (a!= b)... // a XOR b, assuming a and b are booleans This can be extended to multiple operands as follows: if (a!= b!= c!= d)... // a XOR b XOR c XOR d, assuming a, b, c, and d are booleans Note that the above XOR patterns only work if the operands are booleans (not integers). If you want this to work with integers, you can static_cast them to bools. If you need a form of XOR that works with non-boolean operands, you can use this slightly more complicated form: if (static_cast<bool>(a)!= static_cast<bool>(b)!= static_cast<bool>(c)!= static_cast<bool>(d))... // a XOR b XOR c XOR d, for any type that can be converted to bool