Numeric Types—Fundamentals

Reminder: All Data Is Bits

Inside the computer, memory just stores binary data (zeros and ones). If your computer has 16 GiB of RAM, it has 17,179,869,184 (\( 16 \times 2^{30} \)) distinct memory locations, each holding one byte of data (8 bits). When a program runs, it has some fraction of the computer's memory to work with, and it gets to decide how to use that memory. If we have 1000 bytes of RAM, it might hold:

• A 10 px × 25 px color (RGBA) bitmap image.
• A Python array list holding 24 numbers
• A C array containing 250 32-bit integers.
• The first 118 words read from the dictionary.

What the contents of memory actually represent is up to the program running on the machine using that memory (and the language that program is written in).

Number Types in C++

C++ defines a bunch of different types for variables that store numbers. Those types differ based on

• How many bits they use.
• What they use those bits to represent.

Fundamental Integer Types in C and C++

C++'s integer types are based on its C heritage.

Type	Minimum Size (Bits)	Minimum Size (Bytes)
char	8	1
short int	16	2
int	16	2
long int	32	4
long long int	64	8

Notice that these sizes are only minimums. C and C++ allow any given computer system to adopt larger values, so long as they follow the rule that, when it comes the sizes of these types,

• sizeof(char) ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long long)

In practice, there are only four “memory models” that have caught on. On modern 64-bit systems, you're likely to only see LP64 (Mac and Linux) or LLP64 (Windows). The table below shows how many bits each type uses in these different models:

Type	C++ standard	LP32	ILP32	LLP64	LP64
char	at least 8	8	8	8	8
short int	at least 16	16	16	16	16
int	at least 16	16	32	32	32
long int	at least 32	32	32	32	64
long long int	at least 64	64	64	64	64

Signed and Unsigned Integers

So far, we've only talked about how many bits the fundamental types might have, not the range of values they can store. When we have \( n \) bits, we have \( 2^n \) distinct bit patterns, but we have a choice for how to use them.

• unsigned: We could use all of them for non-negative values; or
• signed: We could use half of them for non-negative values and half of them for negative values.

To be more specific, let's imagine using a 16-bit short int. We have two choices:

• unsigned short int: Represent \( 2^{16} \) distinct non-negative values from \( 0\ldots{}65535 \).
• signed short int: Represent \( 2^{15} \) distinct non-negative values from \( 0\ldots{}32767 \) and \( 2^{15} \) distinct negative values, from \( -32768\ldots{}\!\!-1 \), for a total range of \( -32768\ldots{}32767 \).

For all the int types (i.e., everything except char), the default is signed so we it's redundant to say signed. If we want the unsigned option, we have to ask for it.

Other Integer Types

C++ has some other integer types that can be useful. These include:

• bool—can only store 0 or 1 (but it's unspecified how large it is!)
• size_t—an unsigned integer type of some sort with enough bits to represent the size of any object
• ptrdiff_t—a signed integer type of some sort with enough bits to represent the difference between any two sizes (e.g., the offset of one thing compared to another).

And

• int8_t—a signed int guaranteed to be 8 bits
• int16_t—a signed int guaranteed to be 16 bits
• int32_t—a signed int guaranteed to be 32 bits
• int64_t—a signed int guaranteed to be 64 bits
• uint8_t—an unsigned int guaranteed to be 8 bits
• uint16_t—an unsigned int guaranteed to be 16 bits
• uint32_t—an unsigned int guaranteed to be 32 bits
• uint64_t—an unsigned int guaranteed to be 64 bits

With the exception of bool, these types are just alternative names for some other type on the system (e.g., on the (imaginary) Trend-Tastic system, int32_t is another name for int, but on the (fictitious) History-O-Matic system, it's another name for long).

Floating-Point Numbers

Integer types have no way of storing, say, 4.2 or 70.7 or 3.1415926. Floating-point types can store fractional values like these. They do so using a computer equivalent of scientific notation.

For example, if we asked most people to calculate the number of ways to shuffle a deck of cards (i.e., 52! = 52 × 51 × &cdots × 2 × 1), they're more likely to say 8.0658175170943877 × 10⁶⁷, rather than the exact value, which is 80,658,175,170,943,877,224,137,984,000,000,000,000,000,000,000,000,000,000,000.

The scientific notation variant is clearly less exact, but in many contexts having the answer to a reasonable number of significant digits is usually good enough. And, of course, some numbers, like the results of sines, cosines, and logarithms can be irrational numbers with no finite numerical representation anyway.

In scientific notation, there are three parts:

1. The Base (e.g., the highlighted part of 8.0658175170943877 × 10⁶⁷, namely 10), also known as the radix.
2. The Significand (e.g., the first number in 8.0658175170943877 × 10⁶⁷).
3. The Exponent (e.g., the last number in 8.0658175170943877 × 10⁶⁷, namely 67)

For floating point in a computer, the radix is usually base-two (a.k.a. "binary–floating point"), but the same concepts apply. In a binary–floating- point number, with \( n \) bits, some bits are used for the exponent and the rest are used for the significand.

Like integers, C and C++ support different floating point types that use different numbers of bits, and there is a similar size hierarchy to the one we saw for integer types:

• sizeof(float) ≤ sizeof(double) ≤ sizeof(long double)

The C and C++ standards don't make many other firm promises about what else might be true about floating point types, but they recommend that float and double follow the IEEE-754/IEC-559 standard for floating point. When that is the case (which it usually is), we can say the following:

IEEE 754 Type	C++ Type	Total Bits	Significand Bits	Exponent Bits
Half Precision		16	11	5
Single Precision	float	32	24	8
Double Precision	double	64	53	11
Quadruple Precision		128	113	15

Review

(When logged in, completion status appears here.)

Previous Page Next Page