Before you keep reading...
Runestone Academy can only continue if we get support from individuals like you. As a student you are well aware of the high cost of textbooks. Our mission is to provide great books to you for free, but we ask that you consider a $10 donation, more if you can or less if $10 is a burden.
Before you keep reading...
Making great stuff takes time and $$. If you appreciate the book you are reading now and want to keep quality materials free for other students please consider a donation to Runestone Academy. We ask that you consider a $10 donation, but if you can give more thats great, if $10 is too much for your budget we would be happy with whatever you can afford as a show of support.
In the last chapter we had some problems dealing with numbers that were
not integers. We worked around the problem by measuring percentages
instead of fractions, but a more general solution is to use
floating-point numbers, which can represent fractions as well as
integers. In C++, there are two floating-point types, called
double. In this book we will use doubles exclusively.
You can create floating-point variables and assign values to them using the same syntax we used for the other types. For example:
double pi; pi = 3.14159;
It is also legal to declare a variable and assign a value to it at the same time:
int x = 1; string empty = ""; double pi = 3.14159;
In fact, this syntax is quite common. A combined declaration and assignment is sometimes called an initialization.
It is important that you initialize any and all variables that you declare. Failure to do so will generate an error (if you’re lucky), or C++ will initialize the variable to leftover memory, which could lead to undefined behavior.
Although floating-point numbers are useful, they are often a source of confusion because there seems to be an overlap between integers and floating-point numbers. For example, if you have the value 1, is that an integer, a floating-point number, or both?
Strictly speaking, C++ distinguishes the integer value 1 from the floating-point value 1.0, even though they seem to be the same number. They belong to different types, and strictly speaking, you are not allowed to make assignments between types. For example, the following is illegal:
int x = 1.1;
because the variable on the left is an
int and the value on the right is
double. But it is easy to forget this rule, especially because there
are places where C++ automatically converts from one type to another.
double y = 1;
should technically not be legal, but C++ allows it by converting the
double automatically. This leniency is convenient, but it can cause
problems; for example:
double y = 1 / 3;
You might expect the variable y to be given the value 0.333333, which is a legal floating-point value, but in fact it will get the value 0.0. The reason is that the expression on the right appears to be the ratio of two integers, so C++ does integer division, which yields the integer value 0. Converted to floating-point, the result is 0.0.
It’s crucial that you understand that when given two integers, C++ performs integer division! This is a common logic error that can be hard to catch, since your program will compile without problems.
One way to solve this problem (once you figure out what it is) is to make the right-hand side a floating-point expression:
double y = 1.0 / 3.0;
This sets y to 0.333333, as expected.
All the operations we have seen—addition, subtraction, multiplication, and division—work on floating-point values, although you might be interested to know that the underlying mechanism is completely different. In fact, most processors have special hardware just for performing floating-point operations.
Identifying whether an operation carries out integer division or floating point division can get tricky when we have a mix of integers and doubles in our expression. The thing to remeber is if either the divisor or the dividend is a double then the program will carry out floating point division.
Run the code below to see what type of division occurs each time.