Hunter Liu's Website

3. Week 2 Tuesday: Trouble with Doubles; Increments and Decrements

Last time, we described some ways that the division operator / doesn’t work quite the way we expect when dealing with integers, and also how the modulo operator % helps us address this programatically. This week, we’ll introduce two new mathematical operators — the decrement and increment operators — as well as how one can force the computer to do decimal operations instead.

Increments and Decrements

The operation of adding or subtracting one from a number is a very common operation in C++. It’s used when counting number of occurrences of an event, keeping track of how many times a loop was repeated, and many others. If n is a numerical variable, the increments n++ and ++n add one to n, and the decrements n-- and --n subtract one from n.

We’ll focus on the increment operators; everything we say below will have analogous statements for the corresponding decrement operators.

One can think of both n++ and ++n as shortcuts for writing the statement n += 1. When n++ and ++n stand alone, the behaviour is identical:

1int n = 5;
2n++;
3cout << n << endl; // prints 6
4++n;
5cout << n << endl; // prints 7

However, there is one important difference: you can use n++ and ++n within a larger piece of code. This is where all the power of these operators comes in!

1int n = 5;
2cout << ++n << endl; // prints 6
3cout << n++ << endl; // prints ...6??

The above code highlights a subtlety of the two operators. ++n says to first increase n by one, then substitute its value into the code. Likewise, the n++ operator says to first substitute the value of n into the code, then increment its value.

Be very careful about using multiple increment/decrement operators in the same expression. One might be tempted to think that (n++)++ will increment n twice, but this does not even compile. The code (++n)++ does increment n twice (it increments n once, substitutes that value in, then increments again). However, the code ++(n++) does not compile.

Similarly, statements such as n++ + ++n, n + ++n, n * ++n, etc. produce undefined behaviour according to the C++ standard. That is, the code will compile, but you may get different results depending on your compiler and your computer.

The issue is one of the order of operations — C++ needs to substitute the values of n and ++n into the expression, but the order in which this substitution occurss both affects the resultant value and changes depending on the compiler. There are reasons for why these operators behave like this, but this is well beyond the scope of PIC 10A.

That being said, if one has two variables n and m, expressions such as ++n * ++m are perfectly okay. It’s when a single variable is being incremented or decremented and gets used more than once.

 1#include <iostream>
 2
 3using namespace std;
 4
 5int main() {
 6    int n = 15;
 7    int m = 17;
 8
 9    cout << n++ + ++m << endl;
10    cout << ++n + m-- << endl;
11    cout << --m * n-- << endl;
12    cout << m << endl;
13    cout << n << endl;
14
15    return 0;
16}

Trouble with Doubles

Recall that when dividing two integers, C++ will always truncate the answer and produce another integer. We saw that this has its applications last week, but there are definitely scenarios in which you would prefer to just work with the decimal values instead. These are double types rather than int types.

While one can always force a literal number to be a double by adding a .0 to the end of it, one has no such luxury with integer variables. Instead, one needs to “cast” integers into doubles. To do so, if a is an integer variable, then static_cast<double>(a) will turn a into a double.

1int a = 19; 
2int b = 3; 
3
4cout << a / b << endl;  // does integer division
5
6cout << static_cast<double>(a / b) << endl; // ??? 
7cout << static_cast<double>(a) / b << endl; 

Note the output of the second line! You need to cast to a double first, then perform the division. The second line prints out 6.0 because it does the division first (which produces the integer 6), then converts that into a double.

The problem of converting a double back into an integer is a similarly slippery problem, one that is perhaps best demonstrated with an example.

SAMPLE RUNS: 
Enter a time in seconds: 124.556
124.556s = 2min, 4s, and 556ms. 

Let’s first write some pseudocode for this:

1. Take a decimal input time from the user.
2. Define the integer ms = time * 1000.
3. Define the integer seconds = ms / 1000 and replace ms with ms % 1000.
4. Define the integer minutes = seconds / 60 and replace seconds with seconds % 60.
5. Print out the results to the screen.

We might naïvely cobble together the following program:

 1#include <iostream> 
 2
 3using namespace std; 
 4
 5int main() {
 6    // 1. take input from user 
 7    double time; 
 8    cout << "Enter a time in seconds: "; 
 9    cin >> time; 
10
11    // 2-4. compute ms, seconds, minutes 
12    int ms = time * 1000; 
13
14    int seconds = ms / 1000; 
15    ms = ms % 1000; 
16
17    int minutes = seconds / 60; 
18    seconds = seconds % 60; 
19
20    // 5. print everything out. 
21    cout << time << "s = " 
22         << minutes << "min, " 
23         << seconds << "s, and "
24         << ms << "ms." << endl; 
25
26    return 0; 
27} 

However, consider the following run of the code:

Enter a time in seconds: 16.002
16.002s = 0min, 16s, and 1ms.

Something went wrong, and it’s that C++ thinks 16.002 * 1000 is just barely less than 16002 due to the limited precision of a double! Thus it rounds it down to 16001 instead.

 1#include <cmath> // needed for floor, round, ceil 
 2
 3int main() {
 4    double d = 20.15; 
 5    int i1 = d * 100;        // truncates d * 100
 6    int i2 = floor(d * 100); 
 7    int i3 = round(d * 100); 
 8    int i4 = ceil(d * 100); 
 9
10    return 0; 
11} 

With that out of the way, try to fix the code we wrote above yourself before peeking at the best way to proceed!

 1#include <iostream> 
 2#include <cmath>    // needed for round 
 3
 4using namespace std; 
 5
 6int main() {
 7    // 1. take input from user 
 8    double time; 
 9    cout << "Enter a time in seconds: "; 
10    cin >> time; 
11
12    // 2-4. compute ms, seconds, minutes 
13    int ms = round(time * 1000); 
14
15    int seconds = ms / 1000; 
16    ms = ms % 1000; 
17
18    int minutes = seconds / 60; 
19    seconds = seconds % 60; 
20
21    // 5. print everything out. 
22    cout << time << "s = " 
23         << minutes << "min, " 
24         << seconds << "s, and "
25         << ms << "ms." << endl; 
26
27    return 0; 
28} 

In general, it’s a good idea to use the round function from the cmath library to convert from doubles to integers over using the default integer conversion in C++.

Sample run: 
INPUT   30.3571 
OUTPUT  7 

INPUT   -39.82113
OUTPUT  1

INPUT   5
OUTPUT  0