03 - Types

In this previous chapter, we have seen that the same value can be interpreted in many different ways. The processor has no idea about this and will operate on the values as it is told to, without consideration for what these values represent (we will look into this in more details in the next chapter).

Yet, getting this wrong would lead to potentially catastrophic failures, so since the processor doesn't take care of it, someone or something else has to. Different languages have different solutions for this. In C++, the compiler helps the programmer keeping track of what values represent through its type system.

The C++ type system

The main job of this system is to prevent mistakes with how values should be interpreted while avoiding excessive friction. The programmer remains in control.

When specifying a value, the programmer is encouraged to also specify its type. The compiler keeps track of this type throughout the lifespan of the value and uses it to enforce some boundaries or warn the programmer about misuse or likely transgressions.

C++ is statically typed, which means that these verifications happen once when the application is built from the code (compile-time), and not during the application's execution (runtime).

But this information is not only for the compiler's benefit. It is extremely important for the programmer who writes or reads the code.

When a program mentions a pitch, it could be a short text introducing an idea, the specific frequency of a musical note, the distance between threads on a screw, a dark sticky polymer, or a football field. All these things can be designated by the same name: "pitch", but have a different meaning, different semantics, and thus should be interpreted differently.

The Type specifies the semantics (the meaning) and avoids ambiguities.

Keeping track of the "semantics"

On a typical architecture, these 5 types are strictly the same thing from the processor's point of view. But we should read their bits in very different ways.

In this case, the distinction between these types doesn't inform the processor on how these values should be processed; it informs the programmer of how they should be interpreted, and it informs the compiler of which of the processor operations are valid on these values.

Keeping track of the size

The type also encodes in the compiler the number of Bytes (the size) of the value.

In this case, in addition to carrying the information of how these values should be read (as unsigned integral values), the type also encodes the minimal size required to manipulate these values.

There is no value without a type

In C++, every value has a type, and this type cannot change throughout the entire program.

Literals

This type can be deduced from how we spell out the value. So we will have to be a little careful.

This might be intimidating at first, but it is actually somewhat convenient: note that we wrote what we meant, mostly. It allows us to pretty much ignore the underlying representation and its potential complexity.

Since a char should be interpreted through the ASCII lens, '£' is much clearer than 163.

By writing 163 as 163.0, we made it clear that we minded the decimal part, and that the correct representation would be a floating-point. And that saved us the headache of figuring out the underlying representation which is very complex.

For the most part, we don't have to worry too much about the underlying value: the C++ compiler takes care of this for us, as long as we don't stray from its protecting embrace.

Note that in the most common architectures, 163, 163u, and 163.0f will have a size of 4 Bytes, while 163.0 will take 8 Bytes, and '£' only 1 Byte. It will be important to be aware of these differences when we try to make our programs efficient.

Variables

A variable is a placeholder value. Instead of giving the value directly (42), we use a label, representing that value. And since there is no value without a type, we have to attach a type to this label as well.

The syntax to do so follows this pattern:

Type label;

The technical term for the label is "identifier", but we often call it the variable's "name".

char firstLetter;
bool isUppercase;
std::uint8_t alpha;

We can also give an initial value to our variable when we define it. We call this operation initialization. The syntax becomes:

Type label {value};

There are other ways to initialize variables, so don't be too surprised if you see something different in C++ code you read elsewhere.

char firstLetter {'@'};
bool isUppercase {true};
std::uint8_t alpha {42u};

Varying variables

Variables are labels for values, but sometimes, values can change over time. Suppose we read a file, and consider the line of the file we are currently reading. It is a value that will increase as we progress through the file.

std::size_t currentLine {0};
// Further in the program we could change that value.
// For instance when we reach the 10th line:
currentLine = 10uz;

Assigning a different value with = is only one way of varying the value a variable stands for. We will see other ways later.

Constant variables

Conversely, some values never change. Suppose I define the variable pi, for instance:

float pi {3.14159265f};

It would be odd to later change its value. It would likely be a mistake.

The type system gives us a tool to guard against such mistakes: we can declare that pi is meant to never change, to be constant, using the keyword const.

const float pi {3.14159265f};

Remember how the syntax is Type identifier {value};? Now, the type of pi is const float, which means it is a floating-point value that is meant to never change, or a "read-only floating-point".

int const * pI;

const int * pI;

const int * const pI;

int * * pI1;
const int * * pI2;
int * * const pI3;
const int * * const pI4;
int * const * const pI5;
const int * const * const pI6;

int * const * pI7;
const int * const * pI8;

using IntPtr = int *;
const IntPtr * pI7;  // No ambiguity

using ConstIntPtr = const int *;
const ConstIntPtr * pI8;

In practice

First an example where we do things properly. If you press "Run", it should say: This compiled and ran without error..

But if we attempt to do nonsensical things, like initializing a character from a number or an integral number from a floating point, or a 4-Byte floating point from a value it cannot hold, or a boolean from a number, the compiler stops us.

It stops us if we attempt to modify a variable we have indicated as being constant.