This recipe will show all the primitive data types defined by the C++ standard, as well as their size.

In this section, we'll have a closer look at what primitives the C++ standard defines and what other information is important. We'll also learn that although the standard does not define a size for each, it defines another important parameter:

1. First, open a new Terminal and type in the following program:

#include <iostream>
#include <limits>
 
int main ()
 {
    // integral types section
    std::cout << "char " << int(std::numeric_limits<char>::min())
              << "-" << int(std::numeric_limits<char>::max())
              << " size (Byte) =" << sizeof (char) << std::endl;
    std::cout << "wchar_t " << std::numeric_limits<wchar_t>::min()
              << "-" <<  std::numeric_limits<wchar_t>::max()
              << " size (Byte) ="
              << sizeof (wchar_t) << std::endl;
    std::cout << "int " << std::numeric_limits<int>::min() << "-"
              << std::numeric_limits<int>::max() << " size
                  (Byte) ="
              << sizeof (int) << std::endl;
    std::cout << "bool " << std::numeric_limits<bool>::min() << "-"
              << std::numeric_limits<bool>::max() << "
                  size (Byte) ="
              << sizeof (bool) << std::endl;
    
    // floating point types
    std::cout << "float " << std::numeric_limits<float>::min() <<    
                  "-"
              << std::numeric_limits<float>::max() << " size
                  (Byte) ="
              << sizeof (float) << std::endl;
    std::cout << "double " << std::numeric_limits<double>::min()
                  << "-"
              << std::numeric_limits<double>::max() << " size
                  (Byte) ="
              << sizeof (double) << std::endl;
    return 0;
 }

2. Next, build (compile and link) g++ primitives.cpp.
3. This will produce an executable file with the (default) name of a.out.

The output of the preceding program will be something like this:

This represents the minimum and maximum values that a type can represent and the size in bytes for the current platform.

The C++ standard does not define the size of each type, but it does define the minimum width:

• char: Minimum width = 8
• short int: Minimum width = 16
• int: Minimum width = 16
• long int: Minimum width = 32
• long int int: Minimum width = 64

This point has huge implications as different platforms can have different sizes and a programmer should cope with this. To help us get some guidance regarding data types, there is the concept of a data model. A data model is a set of choices (a specific size for each type) made by each implementation (the psABI of the architecture that compilers and operating systems adhere to) to define all the primitive data types. The following table shows a subset of various types and data models that exist:

The Linux kernel uses the LP64 data model for 64-bit architectures (x86_64).

We briefly touched on the psABI topic (short for platform-specific Application Binary Interfaces (ABIs)). Each architecture (for example, x86_64) has a psABI specification that the OS adheres to. The GNU Compiler Collection (GCC) has to know these details as it has to know the sizes of the primitive types it compiles. The i386.h GCC header file contains the size of the primitive data types for that architecture:

root@453eb8a8d60a:~# uname -a
 Linux 453eb8a8d60a 4.9.125-linuxkit #1 SMP Fri Sep 7 08:20:28 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux

The program output shows that the current OS (actually, the Ubuntu image we're running) uses the LP64 data model as expected and that the machine's architecture is x86_64.

As we've seen, the C++ standard defines the following primitive data types:

• Integer: int
• Character: char
• Boolean: bool
• Floating point: float
• Double floating point: double
• Void: void
• Wide character: wchar_t
• Null pointer: nullptr_­t

Data types can have other information so that their types can be defined:

• Modifiers: signed, unsigned, long, and short
• Qualifiers: const and restrict
• Storage type: auto, static, extern, and mutable

Obviously, not all these additional attributes can be applied to all the types; for example, unsigned cannot be applied to the float and double types (their respective IEEE standards would not allow that).

Specifically for Linux, the Linux kernel documentation is generally a good place to start digging more into this: https://www.kernel.org/doc/html/latest. The GCC source code shows the sizes of the primitive data types for every supported architecture. Refer to the following link to find out more: https://github.com/gcc-mirror/gcc.