What is a data type?

When we wish to store data in a C++ program, such as a whole number or a character, we
have to tell the compiler which type of data we want to store. The data type will have
characteristics such as the range of values that can be stored and the operations that can
be performed on variables of that type.

Fundamental types

C++ provides the following fundamental built-in data types: Boolean, character, integer
and floating-point. It also enables us to create our own user-defined data types using
enumerations and classes.

For each of the fundamental data types the range of values and the operations that can be
performed on variables of that data type are determined by the compiler. Each compiler
should provide the same operations for a particular data type but the range of values may
vary between different compilers.

Boolean Type

The Boolean type can have the value true or false. For example:

bool isEven = false;

bool keyFound = true;

If a Boolean value is converted to an integer value true becomes 1 and false becomes 0.

If an integer value is converted to a Boolean value 0 becomes false and non-zero becomes
true.

Character Type

The character type is used to store characters - typically ASCII characters but not always.
For example:

char menuSelection = 'q';

char userInput = '3';
Note how a character is enclosed within single quotes. We can also assign numeric values to
variables of character type:

char chNumber = 26;

We can declare signed and unsigned characters, where signed characters can have positive
and negative values, and unsigned characters can only contain positive values.

signed char myChar = 100;

signed char newChar = -43;
unsigned char yourChar = 200;

Note that if we use a plain char, neither signed nor unsigned:

char dataValue = 27;

it may differ between compilers as to whether it behaves as a signed or unsigned character

type. On some compilers it may accept positive and negative values, on others it may only
accept positive values. Refer to your compiler documentation to see which applies.

A char is guaranteed to be at least 8 bits in size. C++ also provides the data type wchar_t,
a wide character type typically used for large character sets.

An array of characters can be used to contain a C-style string in C++. For example:

char aString[] = "This is a C-style string";

Note that C++ also provides a string class that has advantages over the use of character
arrays.

Integer Types

The integer type is used for storing whole numbers. We can use signed, unsigned or plain
integer values as follows:

signed int index = 41982;

signed int temperature = -32;
unsigned int count = 0;
int height = 100;
int balance = -67;

Like characters, signed integers can hold positive or negative values, and unsigned integers
can hold only positive values. However, plain integer can always hold positive or negative
values, they're always signed.

You can declare signed and unsigned integer values in a shortened form, without the int
keyword:

signed index = 41982;

unsigned count = 0;

Integer values come in three sizes, plain int, short int and long int.

int normal = 1000;

short int smallValue = 100;
long int bigValue = 10000;

The range of values for these types will be defined by your compiler. Typically a plain int
can hold a greater range than a short int, a long int can hold a greater range than a plain
int, although this may not always be true. What we can be sure of is that plain int will be at
least as big as short int and may be greater, and long int will be at least as big as plain int
and may be greater. A short integer is guaranteed to be at least 16 bits and a long integer
at least 32 bits.

You can declare short and long integer values in a shortened form, without the int
keyword:

short smallValue = 100;

long bigValue = 10000;

You can have long and short signed and unsigned integers, for example:

unsigned long bigPositiveValue = 12345;

signed short smallSignedValue= -7;

Floating-Point Types

Floating point types can contain decimal numbers, for example 1.23, -.087. There are
three sizes, float (single-precision), double (double-precision) and long double (extended-
precision). Some examples:

float celsius = 37.623;

double fahrenheit = 98.415;
long double accountBalance = 1897.23;

The range of values that can be stored in each of these is defined by your compiler.
Typically double will hold a greater range than float and long double will hold a greater
range than double but this may not always be true. However, we can be sure that double
will be at least as great as float and may be greater, and long double will be at least as
great as double and may be greater.

Enumeration Type

An enumeration type is a user defined type that enables the user to define the range of
values for the type. Named constants are used to represent the values of an enumeration,
for example:

enum weekday {monday, tuesday, wednesday, thursday, friday, saturday, sunday};

weekday currentDay = wednesday;
if(currentDay==tuesday){
// do something
}

The default values assigned to the enumeration constants are zero-based, so in our
example above monday == 0, tuesday == 1, and so on.

The user can assign a different value to one or more of the enumeration constants, and
subsequent values that are not assigned a value will be incremented. For example:

enum fruit {apple=3, banana=7, orange, kiwi};

Here, orange will have the value 8 and kiwi 9.

Class Type

The class type enables us to create sophisticated user defined types. We provide data
items for the class type and the operations that can be performed on the data. For
example, to create a square class that has a data item for size, and provides draw and
resize operations:

class square {
int size;
public:
square();
~square();
void draw();
bool resize(int newSize);
};