C++ Primer Plus

7E5                 // same as 7.0E+05

-18.32e13           // can have + or - sign in front

1.69e12             // 2010 Brazilian public debt in reais

5.98E24             // mass of earth in kilograms

9.11e-31            // mass of an electron in kilograms

As you might have noticed, E notation is most useful for very large and very small numbers.

E notation guarantees that a number is stored in floating-point format, even if no decimal point is used. Note that you can use either E or e, and the exponent can have a positive or negative sign (see Figure 3.3). However, you can’t have spaces in the number, so, for example, 7.2 E6 is invalid.

Figure 3.3. E notation.

To use a negative exponent means to divide by a power of 10 instead of to multiply by a power of 10. So 8.33E-4 means 8.33 / 10⁴, or 0.000833. Similarly, the electron mass 9.11e-31 kg means 0.000000000000000000000000000000911 kg. Take your choice. (Incidentally, note that 911 is the usual emergency telephone number in the United States and that telephone messages are carried by electrons. Coincidence or scientific conspiracy? You be the judge.) Note that –8.33E4 means –83300. A sign in front applies to the number value, and a sign in the exponent applies to the scaling.

Note

The form d.dddE+n means move the decimal point n places to the right, and the form d.dddE-n means move the decimal point n places to the left. This moveable decimal point is the origin of the term “floating-point.”

Floating-Point Types

Like ANSI C, C++ has three floating-point types: float, double, and long double. These types are described in terms of the number of significant figures they can represent and the minimum allowable range of exponents. Significant figures are the meaningful digits in a number. For example, writing the height of Mt. Shasta in California as 14,162 feet uses five significant figures, for it specifies the height to the nearest foot. But writing the height of Mt. Shasta as about 14,000 feet tall uses two significant figures, for the result is rounded to the nearest thousand feet; in this case, the remaining three digits are just placeholders. The number of significant figures doesn’t depend on the location of the decimal point. For example, you can write the height as 14.179 thousand feet. Again, this uses five significant digits because the value is accurate to the fifth digit.

In effect, the C and C++ requirements for significant digits amount to float being at least 32 bits, double being at least 48 bits and certainly no smaller than float, and long double being at least as big as double. All three can be the same size. Typically, however, float is 32 bits, double is 64 bits, and long double is 80, 96, or 128 bits. Also the range in exponents for all three types is at least –37 to +37. You can look in the cfloat or float.h header files to find the limits for your system. (cfloat is the C++ version of the C float.h file.) Here, for example, are some annotated entries from the float.h file for Borland C++Builder:

// the following are the minimum number of significant digits

#define DBL_DIG 15         // double

#define FLT_DIG 6          // float

#define LDBL_DIG 18        // long double

// the following are the number of bits used to represent the mantissa

#define DBL_MANT_DIG     53

#define FLT_MANT_DIG     24

#define LDBL_MANT_DIG    64

// the following are the maximum and minimum exponent values

#define DBL_MAX_10_EXP   +308

#define FLT_MAX_10_EXP   +38

#define LDBL_MAX_10_EXP  +4932

#define DBL_MIN_10_EXP   -307

#define FLT_MIN_10_EXP   -37

#define LDBL_MIN_10_EXP  -4931

Listing 3.8 examines types float and double and how they can differ in the precision to which they represent numbers (that’s the significant figure aspect). The program previews an ostream method called setf() from Chapter 17, “Input, Output, and Files.” This particular call forces output to stay in fixed-point notation so that you can better see the precision. It prevents the program from switching to E notation for large values and causes the program to display six digits to the right of the decimal. The arguments ios_base::fixed and ios_base::floatfield are constants provided by including iostream.

Listing 3.8. floatnum.cpp

// floatnum.cpp -- floating-point types

#include

int main()

{

    using namespace std;

    cout.setf(ios_base::fixed, ios_base::floatfield); // fixed-point

    float tub = 10.0 / 3.0;     // good to about 6 places

    double mint = 10.0 / 3.0;   // good to about 15 places

    const float million = 1.0e6;

    cout << "tub = " << tub;

    cout << ", a million tubs = " << million * tub;

    cout << ",\nand ten million tubs = ";

    cout << 10 * million * tub << endl;

    cout << "mint = " << mint << " and a million mints = ";

    cout << million * mint << endl;

    return 0;

}

Here is the output from the program in Listing 3.8:

tub = 3.333333, a million tubs = 3333333.250000,

and ten million tubs = 33333332.000000

mint = 3.333333 and a million mints = 3333333.333333