There are five mathematical operators: addition ( + ), subtraction ( - ), multiplication ( * ), division ( / ), and modulus ( % ). Additi...

There are five mathematical operators: addition (

`+`), subtraction (`-`), multiplication (`*`), division (`/`), and modulus (`%`).Addition and subtraction work as you would expect, although subtraction with

`unsigned`integers can lead to surprising results, if the result is a negative number. You saw something much like this yesterday, when variable overflow was described. Listing 4.2 shows what happens when you subtract a large`unsigned`number from a small`unsigned`number.**Listing 4.2. A demonstration of subtraction and integer overflow**

**.**

1: // Listing 4.2 - demonstrates subtraction and

2: // integer overflow

3: #include <iostream.h>

4:

5: int main()

6: {

7: unsigned int difference;

8: unsigned int bigNumber = 100;

9: unsigned int smallNumber = 50;

10: difference = bigNumber - smallNumber;

11: cout << "Difference is: " << difference;

12: difference = smallNumber - bigNumber;

13: cout << "\nNow difference is: " << difference <<endl;

14: return 0;

`15: }`

Output: Difference is: 50

Now difference is: 4294967246

**Analysis:**

**The subtraction operator is invoked on line 10, and the result is printed on line 11, much as we might expect. The subtraction operator is called again on line 12, but this time a large**

`unsigned`number is subtracted from a small

`unsigned`number. The result would be negative, but because it is evaluated (and printed) as an

`unsigned`number, the result is an overflow, as described yesterday. This topic is reviewed in detail in Appendix A, "Operator Precedence."

#### Integer Division and Modulus

Integer division is somewhat different from everyday division. When you divide 21 by 4, the result is a real number (a number with a fraction). Integers don't have fractions, and so the "remainder" is lopped off. The answer is therefore 5. To get the remainder, you take 21 modulus 4 (21 % 4) and the result is 1. The modulus operator tells you the remainder after an integer division.

Finding the modulus can be very useful. For example, you might want to print a statement on every 10th action. Any number whose value is 0 when you modulus 10 with that number is an exact multiple of 10. Thus 1 % 10 is 1, 2 % 10 is 2, and so forth, until 10 % 10, whose result is 0. 11 % 10 is back to 1, and this pattern continues until the next multiple of 10, which is 20. We'll use this technique when looping is discussed on Day 7, "More Program Flow."

**WARNING:**`if`statements:`if(SomeValue < 10); SomeValue = 10;`

- What was intended here was to test whether
`SomeValue`is less than 10, and if so, to set it to`10`, making`10`the minimum value for`SomeValue`. Running this code snippet will show that`SomeValue`is always set to`10`! Why? The`if`statement terminates with the semicolon (the do-nothing operator). Remember that indentation has no meaning to the compiler. This snippet could more accurately have been written as:`if (SomeValue < 10) // test ; // do nothing SomeValue = 10; // assign`

- Removing the semicolon will make the final line part of the
`if`statement and will make this code do what was intended.

### Combining the Assignment and Mathematical Operators

It is not uncommon to want to add a value to a variable, and then to assign the result back into the variable. If you have a variable

`myAge`and you want to increase the value by two, you can write```
int myAge = 5;
int temp;
temp = myAge + 2; // add 5 + 2 and put it in temp
myAge = temp; // put it back in myAge
```

This method, however, is terribly convoluted and wasteful. In C++, you can put the same variable on both sides of the assignment operator, and thus the preceding becomes

```
myAge = myAge + 2;
```

which is much better. In algebra this expression would be meaningless, but in C++ it is read as "add two to the value in

`myAge`and assign the result to`myAge`."Even simpler to write, but perhaps a bit harder to read is

```
myAge += 2;
```

The self-assigned addition operator (

`+=`) adds the rvalue to the lvalue and then reassigns the result into the lvalue. This operator is pronounced "plus-equals." The statement would be read "`myAge`plus-equals two." If`myAge`had the value`4`to start, it would have`6`after this statement.There are self-assigned subtraction (

`-=`), division (`/=`), multiplication (`*=`), and modulus (`%=`) operators as well.