ssrs upc-a TeamLRN in Software

Drawer EAN / UCC - 13 in Software TeamLRN

CHAP. 2]

2.9 FLOATING-POINT TYPES C++ supports three real number types: float, double, and long double. On most systems, double uses twice as many bytes as float. Typically, float uses 4 bytes, double uses 8 bytes, and long double uses 8, 10, 12, or 16 bytes. Types that are used for real numbers are called floating-point types because of the way they are stored internally in the computer. On most systems, a number like 123.45 is first converted to binary form: 123.45 = 1111011.011100112 27 Then the point is floated so that all the bits are on its right. In this example, the floating-point form is obtained by floating the point 7 bits to the left, producing a mantissa 27 times smaller. So the original number is 123.45 = 0.1111011011100112 27 This number would be represented internally by storing the mantissa 111101101110011 and the exponent 7 separately. For a 32-bit float type, the mantissa is stored in a 23-bit segment and the exponent in an 8-bit segment, leaving 1 bit for the sign of the number. For a 64-bit double type, the mantissa is stored in a 52-bit segment and the exponent in an 11-bit segment. EXAMPLE 2.7 Floating-Point Arithmetic

This program is nearly the same as the one in Example 2.4. The important difference is that these variables are declared to have the floating-point type double instead of the integer type int. int main() { // tests the floating-point operators +, -, *, and /: double x=54.0; double y=20.0; cout << "x = " << x << " and y = " << y << endl; cout << "x+y = " << x+y << endl; // 54.0+20.0 = 74.0 cout << "x-y = " << x-y << endl; // 54.0-20.0 = 34.0 cout << "x*y = " << x*y << endl; // 54.0*20.0 = 1080.0 cout << "x/y = " << x/y << endl; // 54.0/20.0 = 2.7 } x = 55 and y = 20 x+y = 75 x-y = 35 x*y = 1100 x/y = 2.7 Unlike integer division, floating-point division does not truncate the result: 54.0/20.0 = 2.7.

The next example can be used on any computer to determine how many bytes it uses for each type. The program uses the sizeof operator which returns the size in bytes of the type specified. EXAMPLE 2.8 Using the sizeof Operator

This program tells you how much space each of the 12 fundamental types uses: int main() { // prints the storage sizes of the fundamental types: cout << "Number of bytes used:\n";

"\t char: "\t short: "\t int: "\t long: "\t unsigned char: "\tunsigned short: "\t unsigned int: "\t unsigned long: "\t signed char: "\t float: "\t double: "\t long double:

" " " " " " " " " " " "

<< sizeof(char) << sizeof(short) << sizeof(int) << sizeof(long) << sizeof(unsigned char) << sizeof(unsigned short) << sizeof(unsigned int) << sizeof(unsigned long) << sizeof(signed char) << sizeof(float) << sizeof(double) << sizeof(long double)

endl; endl; endl; endl; endl; endl; endl; endl; endl; endl; endl; endl;

} Number of bytes used: char: short: int: long: unsigned char: unsigned short: unsigned int: unsigned long: signed char: float: double: long double:

1 2 4 4 1 2 4 4 1 4 8 8

The output below shows the sizes for a typical UNIX workstation. On this machine, int and long are equivalent, unsigned int and unsigned long are equivalent, and double and long double are equivalent. In other words, long is no different from regular on this computer.

The next program can be used to investigate floating-point types on any computer system. It reads the values of various constants from the <cfloat> header file. To access it, the program must include the preprocessor directive: