The most common value to add (or subtract) and then reassign into a variable is 1 . In C++, increasing a value by 1 is called incrementing...

The most common value to add (or subtract) and then reassign into a variable is 1. In C++, increasing a value by 1 is called incrementing, and decreasing by 1 is called decrementing. There are special operators to perform these actions.
The increment operator (++) increases the value of the variable by 1, and the decrement operator (--) decreases it by 1. Thus, if you have a variable, C, and you want to increment it, you would use this statement:
```C++;               // Start with C and increment it.
```
This statement is equivalent to the more verbose statement
```C = C + 1;
```
which you learned is also equivalent to the moderately verbose statement
```C += 1;
```

#### Prefix and Postfix

Both the increment operator (++) and the decrement operator(--) come in two varieties: prefix and postfix. The prefix variety is written before the variable name (++myAge); the postfix variety is written after (myAge++).
In a simple statement, it doesn't much matter which you use, but in a complex statement, when you are incrementing (or decrementing) a variable and then assigning the result to another variable, it matters very much. The prefix operator is evaluated before the assignment, the postfix is evaluated after.
The semantics of prefix is this: Increment the value and then fetch it. The semantics of postfix is different: Fetch the value and then increment the original.
This can be confusing at first, but if x is an integer whose value is 5 and you write
```int a = ++x;
```
you have told the compiler to increment x (making it 6) and then fetch that value and assign it to a. Thus, a is now 6 and x is now 6.
If, after doing this, you write
```int b = x++;
```
you have now told the compiler to fetch the value in x (6) and assign it to b, and then go back and increment x. Thus, b is now 6, but x is now 7. Listing 4.3 shows the use and implications of both types.

Listing 4.3. A demonstration of prefix and postfix operators.

1: // Listing 4.3 - demonstrates use of
2: // prefix and postfix increment and
3: // decrement operators
4: #include <iostream.h>
5: int main()
6: {
7: int myAge = 39; // initialize two integers
8: int yourAge = 39;
9: cout << "I am: " << myAge << " years old.\n";
10: cout << "You are: " << yourAge << " years old\n";
11: myAge++; // postfix increment
12: ++yourAge; // prefix increment
13: cout << "One year passes...\n";
14: cout << "I am: " << myAge << " years old.\n";
15: cout << "You are: " << yourAge << " years old\n";
16: cout << "Another year passes\n";
17: cout << "I am: " << myAge++ << " years old.\n";
18: cout << "You are: " << ++yourAge << " years old\n";
19: cout << "Let's print it again.\n";
20: cout << "I am: " << myAge << " years old.\n";
21: cout << "You are: " << yourAge << " years old\n";
22: return 0;
23: }
Output: I am 39 years old
You are 39 years old
One year passes
I am 40 years old
You are 40 years old
Another year passes
I am 40 years old
You are 41 years old
Let's print it again
I am 41 years old
You are 41 years old

Analysis: On lines 7 and 8, two integer variables are declared, and each is initialized with the value 39. Their values are printed on lines 9 and 10.
On line 11, myAge is incremented using the postfix increment operator, and on line 12, yourAge is incremented using the prefix increment operator. The results are printed on lines 14 and 15, and they are identical (both 40).
On line 17, myAge is incremented as part of the printing statement, using the postfix increment operator. Because it is postfix, the increment happens after the print, and so the value 40 is printed again. In contrast, on line 18, yourAge is incremented using the prefix increment operator. Thus, it is incremented before being printed, and the value displays as 41.
Finally, on lines 20 and 21, the values are printed again. Because the increment statement has completed, the value in myAge is now 41, as is the value in yourAge.
Name