Fundamental Types in C++

C++ gives every program a small set of built-in types that can be used without defining anything new. These are called fundamental types. Before we explain them, it helps to ask the computer a question about one of them and to predict the answer. The question is simple: how many bytes does a char occupy? Think about it before reading on, because the rest of this article is about what that number means and why it is not always the same everywhere.

Imagine you need a language in which a programmer can write a fast program with almost no hidden cost, where every operation maps onto something the machine actually does. C++ begins from that requirement. Its built-in types and operations are rich, but they are deliberately low-level. They reflect the capabilities of conventional computer hardware directly and efficiently, so there is no runtime layer standing between the program and the machine.

A low-level foundation has a consequence. The built-in types do not give you high-level facilities that make advanced applications easy to write. Those facilities come from a second layer, a set of abstraction mechanisms that programmers use to build higher-level facilities themselves. Keep this two-layer picture in mind, because the connection between the layers is what the next section explains.

Built-in types are the starting material. Abstraction mechanisms are the tools that turn that material into something larger. The source describes these mechanisms as a sophisticated set that C++ adds on top of the built-in types and operations. Their purpose is specific: they let programmers design and implement their own types, with suitable representations and operations, and they let other programmers use those types simply and elegantly once they exist. A type built this way is called a user-defined type. The source gives two names for this kind: classes and enumerations.

The diagram shows three relationships. Built-in types are augmented by abstraction mechanisms. Those mechanisms are the means by which user-defined types are built. User-defined types are also constructed out of the built-in types, so the built-in layer stays the foundation even at the top of the stack. The standard library mainly consists of user-defined types, so it is a good place to see this layering at work once the built-in foundation is clear.

The definition of a built-in type reads like a recipe with three inputs. The first input is the set of fundamental types. The second is the const modifier, which marks a value as one that should not change. The third is the set of declarator operators, which shape how a declaration names and structures a type. A built-in type is whatever the language lets you form by combining these three inputs.

Read a declaration like const int as a combination of parts rather than as one unbreakable word. Here the fundamental type int is combined with the const modifier, which is exactly the recipe the definition names. This example does not invent a new kind of type with its own operations. The source does not list every possible combination, so treat this as one illustration of the general principle rather than a complete catalogue.

C++ provides five fundamental types used here: bool, char, int, double, and unsigned. Each one has a distinct job and holds a different kind of value. The table below pairs each type with the kind of value it holds.

The names already hint at the differences. A bool is a yes-or-no kind of value, a char holds one character, an int holds whole numbers with a sign, a double holds decimal numbers, and an unsigned holds whole numbers that cannot go below zero. Choosing the right type starts with asking which of these kinds of value your data actually is.

A fundamental type is tied directly to what the hardware of the machine can do. Each one occupies a fixed amount of memory, and that fixed size limits the set of values the type can hold. A type that occupies more memory can distinguish more possible values, and a type that occupies less can distinguish fewer. So when you ask what range an int can hold, the honest first answer is the size of the int on the machine in question, because the range follows from the size.

The comparison above uses only the arithmetic of binary storage: each extra bit doubles the number of distinct patterns a type can store, so a 16-bit value has far more possible patterns than an 8-bit value. The source makes the general point that more memory means more distinguishable values. The exact range of a particular type on a particular machine still depends on its size there, which is why the next section introduces the sizeof operator as the way to ask.

The sizeof operator reports how many bytes a type occupies. Its result is a number you can print, compare, or use in calculations. The source gives two anchor values to remember: sizeof(char) equals 1, and sizeof(int) is often 4. The word often matters. A char is typically an 8-bit byte, and the sizes of other types are quoted in multiples of the size of a char. Because the size is implementation-defined, 4 for int is a common outcome rather than a rule the language guarantees on every machine.

Read the output as a fact about this program running on this machine. The first line is 1 on any conforming system, because sizeof(char) is defined as 1. The second line is 4 on many systems, but a different machine may print another number. The program does not tell you the range of int directly; it tells you the size, and the range follows from that size.