Fri. Sep 20th, 2024

# Variables and types

The usefulness of the “Hello World” programs shown in the previous chapter is rather questionable. We had to write several lines of code, compile them, and then execute the resulting program, just to obtain the result of a simple sentence written on the screen. It certainly would have been much faster to type the output sentence ourselves.However, programming is not limited only to printing simple texts on the screen. In order to go a little further on and to become able to write programs that perform useful tasks that really save us work, we need to introduce the concept of variable.

Let’s imagine that I ask you to remember the number 5, and then I ask you to also memorize the number 2 at the same time. You have just stored two different values in your memory (5 and 2). Now, if I ask you to add 1 to the first number I said, you should be retaining the numbers 6 (that is 5+1) and 2 in your memory. Then we could, for example, subtract these values and obtain 4 as result.

The whole process described above is a simile of what a computer can do with two variables. The same process can be expressed in C++ with the following set of statements:

 1 2 3 4 a = 5; b = 2; a = a + 1; result = a - b;

Obviously, this is a very simple example, since we have only used two small integer values, but consider that your computer can store millions of numbers like these at the same time and conduct sophisticated mathematical operations with them.

We can now define variable as a portion of memory to store a value.

Each variable needs a name that identifies it and distinguishes it from the others. For example, in the previous code the variable names were a, b, and result, but we could have called the variables any names we could have come up with, as long as they were valid C++ identifiers.

### Identifiers

A valid identifier is a sequence of one or more letters, digits, or underscore characters (_). Spaces, punctuation marks, and symbols cannot be part of an identifier. In addition, identifiers shall always begin with a letter. They can also begin with an underline character (_), but such identifiers are -on most cases- considered reserved for compiler-specific keywords or external identifiers, as well as identifiers containing two successive underscore characters anywhere. In no case can they begin with a digit.

C++ uses a number of keywords to identify operations and data descriptions; therefore, identifiers created by a programmer cannot match these keywords. The standard reserved keywords that cannot be used for programmer created identifiers are:

alignas, alignof, and, and_eq, asm, auto, bitand, bitor, bool, break, case, catch, char, char16_t, char32_t, class, compl, const, constexpr, const_cast, continue,

decltype, default, delete, do, double, dynamic_cast, else, enum, explicit,

export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, noexcept, not, not_eq, nullptr, operator, or, or_eq, private,

protected, public, register, reinterpret_cast, return, short, signed, sizeof,

static, static_assert, static_cast, struct, switch, template, this, thread_local, throw, true, try, typedef, typeid, typename, union, unsigned, using,

virtual, void, volatile, wchar_t, while, xor, xor_eq

Specific compilers may also have additional specific reserved keywords.

Very important: The C++ language is a “case sensitive” language. That means that an identifier written in capital letters is not equivalent to another one with the same name but written in small letters. Thus, for example, the RESULT variable is not the same as the result variable or the Result variable. These are three different identifiers identifiying three different variables.

 Character types char Exactly one byte in size. At least 8 bits. char16_t Not smaller than char. At least 16 bits. char32_t Not smaller than char16_t. At least 32 bits. wchar_t Can represent the largest supported character set. Integer types (signed) signed char Same size as char. At least 8 bits. signed short int Not smaller than char. At least 16 bits. signed int Not smaller than short. At least 16 bits. signed long int Not smaller than int. At least 32 bits. signed long long int Not smaller than long. At least 64 bits. Integer types (unsigned) unsigned char (same size as their signed counterparts) unsigned short int unsigned int unsigned long int unsigned long long int Floating-point types float double Precision not less than float long double Precision not less than double Boolean type bool Void type void no storage Null pointer decltype(nullptr)

6,025 total views, 1 views today