C++ provides integer, floating point, and Boolean types. The char type is an integer but it can be used to hold individual characters and so its data can be viewed as a number or as a character. The C++ Standard Library provides the string class to allow you to use and manipulate strings of characters. Strings will be covered in depth in Chapter 9, Using Strings.
As the name suggests, integer types contain integral values where there are no fractional parts. If you perform calculations with integers you should expect that any fractional parts will be discarded unless you take steps to retain them (for example, through the remainder operator %). Floating point types hold numbers that may have a fractional part; because floating point types can hold numbers in a mantissa exponent format, they can hold exceptionally large or exceptionally small numbers.
A variable is an instance of a type; it is the memory allocated to hold the data that the type can hold. Integer and floating point variable declarations can be modified to tell the compiler how much memory to allocate, and thus the limits of the data that the variable can hold and the precision of the calculations performed on the variable. In addition, you can also indicate if the variable will hold a number where the sign is important. If the number is being used to hold bitmaps (where the bits do not make up a number, but have a separate meaning of their own) then it usually makes no sense to use a signed type.
In some cases, you will be using C++ to unpack data from a file or a network stream so that you can manipulate it. In this case, you will need to know whether the data is a floating point or integral, signed or unsigned, how many bytes are used and what order those bytes will be in. The order of the bytes (whether the first byte in a multi-byte number is the low or high part of the number) is determined by the processor which you are compiling for, and in most cases, you will not need to worry about it.
Similarly, sometimes you may need to know about the size of a variable and how it is aligned in memory; in particular, when you are using records of data, known in C++ as structs. C++ provides the sizeof operator to give the number of bytes used to hold a variable and the alignof operator to determine the alignment of the type in memory. For basic types, the sizeof and alignof operators return the same value; it is only necessary to call the alignof operator on custom types where it will return the alignment of the largest data member in the type.
As the name suggests, an integer holds integral data, numbers that have no fractional part. For this reason, it makes little sense to do any arithmetic with an integer where the fractional part is important; in this case, you should use floating point numbers. An example of this was shown in the last chapter:
int height = 480;
int width = 640;
int aspect_ratio = width / height;
This gives an aspect ratio of 1, which is clearly untrue and serves no purpose. Even if you assign the result to a floating-point number, you will get the same result:
float aspect_ratio = width / height;
The reason is that the arithmetic is performed in the expression width / height, which will use the division operator for integers that will throw away any fractional part of the result. To use the floating-point division operator you will have to cast one or other of the operands to a floating-point number so the floating-point operator is used:
float aspect_ratio = width / (float)height;
This will assign a value of 1.3333 (or 4 : 3) to the aspect_ratio variable. The cast operator used here is the C cast operator, which forces data of one type to be used as data of another type. (It is used because we have not yet introduced the C++ cast operators, and the syntax of C cast operators is clear.) There is no type safety in this cast. C++ provides cast operators, which are discussed in the following text, some of which will cast in a type-safe way, which becomes important when you use pointers to objects of custom types.
C++ provides integer types of various sizes, as summarized in the following table. These are the five standard integer types. The standard says that an int is the natural size of the processor and will have a value between (and including) INT_MIN and INT_MAX (defined in the <climits> header file). The size of the integer type has at least as much storage as those preceding it in the list, so an int is, at least, as big as a short int and a long long int types, which is at least as big as a long int type. The phrase at least as big as is not much use if the types are all the same size, so the <climits> header file defines ranges for the other fundamental integer types too. It is implementation-specific how many bytes are needed to store these integer ranges. This table gives the ranges of the fundamental types and the sizes on x86, 32-bit processors:
| Type | Range | Size in bytes |
| signed char | -128 to 127 | 1 |
| short int | -32768 to 32767 | 2 |
| int | -2147483648 to 2147483647 | 4 |
| long int | -2147483648 to 2147483647 | 4 |
| long long int | -9223372036854775808 to 9223372036854775807 | 8 |
In practice, rather than the short int type, you will use short; for long int, you will use long; and for long long int, you will typically use long long. As you can see from this table, the int and long int types are the same size, but they are still two different types.
Other than the char type, by default integer types are signed, that is, they can hold negative as well as positive numbers (for example, a variable of type short can have a value between -32,768 and 32,767). You can use the signed keyword to explicitly indicate that the type is signed. You can also have unsigned equivalents by using the unsigned keyword, which will give you an extra bit, but will also mean that bitwise operators and shift operators will work as you expect. You may find unsigned used without a type, in which case it refers to unsigned int. Similarly, signed used without a type refers to signed int.
The char type is a separate type to both unsigned char and signed char. The standard says that every bit in a char is used to hold character information, and so it is implementation-dependent as to whether a char can be treated as being able to hold negative numbers. If you want a char to hold a signed number, you should specifically use signed char.
The standard is imprecise about the size of the standard integer types and this may be an issue if you are writing code (for example, accessing data in a file, or a network stream) that contains a stream of bytes. The <cstdlib> header file defines named types that will hold specific ranges of data. These types have names which have the number of bits used in the range (although the actual type may require more bits). So, there are types with names such as int16_t and uint16_t, where the first type is a signed integer that will hold a range of 16-bit values and the second type is an unsigned integer. There are also types declared for 8-, 32-, and 64-bit values.
The following shows the actual sizes of these types determined by the sizeof operator on an x86 machine:
// #include <cstdint>
using namespace std; // Values for x86
cout << sizeof(int8_t) << endl; // 1
cout << sizeof(int16_t) << endl; // 2
cout << sizeof(int32_t) << endl; // 4
cout << sizeof(int64_t) << endl; // 8
In addition, the <cstdlib> header file defines types with names such as int_least16_t and uint_least16_t using the same naming scheme as before, and with versions for 8-, 16-,32-, and 64-bits. The least part of the name means that the type will hold values with at least the specified number of bits, but there could be more. There are also types with names such as int_fast16_t and uint_fast16_t with versions for 8-, 16-, 32-, and 64-bits which are regarded as the fastest types that can hold that number of bits.
![]()
To assign a value to an integer variable you provide a number that has no fractional part. The compiler will identify the type with the ne...
