Introduction to Data Types

Data types of the variables

As the name suggests, data type represents the name of the type of data. In C++, when creating any variable, we need to specify its data type so that the compiler knows how much memory should be allocated for that particular variable. Such a language, where the programmer needs to tell the compiler the data type of the variable at the compile time, is called a statically-typed language.

In the previous chapter, we only used the int data type that stores only an integer value. Let’s learn about the primitive data typesdata types that are native to the language and do not require user definition in C++.

Data types can be subdivided into integral and floating-point data types.

Integral data types include whole numbers or integers only, whereas floating-point data types include decimal numbers.

The respective allocated sizes and the value ranges of each integral data type are given in the table below:

Counting the number of possible different numbers

It is not hard to show that if you have a two digits number with decimal digits, where every digit could be any value between $0-9$, the total possibility for this number could be $10 \times 10 = 100$, represented as $00, 01, 02, ..., 99$. Furthermore, for a base 5 representation, we’re allowed to use digits between $0-4$. Since we have 5 unique digits to choose from for both places of a two-digit number, we get $5 \times 5 = 25$ possibilities for such a number. This numeric range starts from $00, 01, 02, 03, 04, 10, ...$ and ends at $44$. It’s important to understand that we jumped from $04$ to $10$ since we ran out of unique digits. Similarly, for a base 2 number, we’ll have $2 \times 2$ possibilities since we are only allowed to use the digits $0$ and $1$ that would produce the number range $00, 01, 10, 11$.

Generally speaking, if we have an $n$ digit number in a base $b$ where the total number of symbols for each place is from $0, 1, ... , b-1$ for each digit, then the total possibilities of the $n$ digit number will be $b \times b \times ... \times b = b^n$ ($b$ multiplied $n$ times) and its range will be from $0$ to $b^n-1$ (in decimal). In base $b$ it will be from 0 to all the $n$ digits with value $b-1$.

Hence, the byte is an 8 digit number with base 2, hence having the total number of possibilities as $2^{8}$ ranging from $00000000, 00000001, 00000010, 00000011, ... , 11111111$ for the representation of $0$ till $2^8-1 = 255$.

Similarly, for any $T$-byte integral data type, the total number of possibilities in base 2 should be $2^{T\times 8}$.

The respective allocated sizes and the value ranges of each floating-point data type are given in the table below:

Here is an example from which the size of these data types can be determined.

The sizes of these data types may vary depending on the machine’s architecture (32-bit or 64-bit) and the compiler we use.

To determine the size of the data type, we used sizeof on the name of the data type. We can also use sizeof on the name of the variable.

Now, let us write code to determine the possible maximum and minimum values of the int data type.

If we run the code above, we see that 2147483647 is the maximum value that can be stored in an int type of variable.

We can also see that when printing a number greater than the maximum, say, with a value equal to 2147483649, it prints -2147483647 and not the actual value.

While we print a value within its range, it prints the value just fine.

So to handle cases where we need values greater than the maximum range of a data type, we can use data type modifiers.

We have to include #include<limits.h> to use the predefined constants in the header files for INT_MAX, INT_MIN and several other limits of predefined data types.

Data type modifiers

We can modify the ranges and the amount of allocated space of data types using the data type modifiers. We can use type modifiers with the int, double, and char data types. The type modifiers include:

• short: It’s used with int. It decreases the size to 2 bytes
• long: It’s used with int and double. It increases the size by 4 bytes.
  • The size of a long int would be 4 bytes in a 32-bit machine and 8 bytes on a 64-bit machine.
• signed: It’s used with char and int. It allows us to store both positive and negative values. For a signed int, the range is from -2,147,483,648 to 2,147,483,647. For a signed char, the range is from -128 to 127.
• unsigned: It’s used with char and int. It allows us to store positive values only. For an unsigned int, the range is from 0 to 4294967295. For an unsigned char, the range is from 0 to 255.

The animation below shows the size and range of the int data type. The int data type is signed by default which means that it can represent positive as well as negative numbers.

The int data type

The int memory is of $4$ bytes. Therefore, it has a binary bit representation of 64 bits and its total number of representation power is $2^{64}$. We can use a signed and unsigned int.

• signed int or int: Due to the last bit reserved for a sign, for example, if the last bit is $1$, the value stored in the remaining $31$ bits are -ve, hence a range of $-2^{31}$ to +ve range of $2^{31} - 1$. We subtracted 1 because we need to include $0$ in the +ve range.
• unsigned int: Here, there is no sign bit, therefore, all the bits are represented as +ve numbers. The range will be as much as $32$ bits can store, i.e., $0$ to $2^{32}-1$.

The char data type

The char data type is of 1 byte, hence its signed representation has the range $-2^7$ to $2^7-1$, and its unsigned char representation has a range of $0$ to $2^8-1$.

The animation below shows the size and range of the char data type. The char data type behaves as unsigned by default.

The bool data type

Though bool is a one-byte memory, it stores only 0 or 1 values inside; zero is considered as false, and 1 is considered as true.

The animation below shows the size and range of the bool data type.

The float data type

The float data type is also a 4-byte memory. It reserves one byte for a sign, 8 bits for saving the exponent, and the remaining 23 bits for the significant. That makes it store the largest floating value of $\pm 3.40282 \times 10^{38}$, both the +ve and -ve values, and the smallest possible floating value of $\pm 1.17549 \times 10^{-38}$.

The animation below shows the size and range of the float data type.

The double data type

The double data type is an 8-byte floating memory. Hence, its range is large.

Explore the animation below. It shows the size and range of the double data type.

Other data types

There are other data types that are worth exploring. For example the long long data type is an integer of 8 bytes, hence, a larger number of possible representations of $2^{64}$. Similarly, there is a long double data type that has 16 bytes and larger ranges.

The long data type is the short form of long int or long long int. Similarly, short is the short form of short int.

Explore the ranges of data types

Run the program below, and explore the ranges of each data type.

There is no need to remember the range. We can use the above code to see the ranges.