Learn C++ with Qt, Part 005: Definition of Variables

In this part of my C++ with Qt tutorial, I’d like to
expand upon the area of data definitions, more specific the definition of
variables. In the previous part about data input I already used some variable
definitions in order to store and use the data input by the user within the
program.

This is more of a background article, but it should
give you a better understanding of what is happening inside the computer when
your program is running. The additional knowledge can help you to avoid
problems or find the source of bugs in your programs later on.

So let’s have a closer look at the definition of some
commonly used types of variables…

Data definitions – a short introduction

In order for the computer to do anything with a value
that is either entered by a user, predefined in the program’s code or
calculated, we need to define a variable that can store the value.

While not all data has to be entered manually by the
user, programs need clearly defined memory regions in the RAM where data can be
stored accessed temporarily. The computer’s central processing unit (CPU) has
some memory registers, but not enough to store all data that is necessary for a
more complex application.

The technical view

On the technical side, the definition of a variable makes the computer reserve a part of its main memory and assigns a
fixed memory address to the name of the variable. The amount of reserved memory
depends upon the type of the variable – a single character needs less memory
than a whole string of characters, and a small integer number needs less space
than a long number, just to name two examples.

When the program accesses the variable – or more
exactly, tries to read or change the value that is stored in this variable –
the computer looks up the current value at the memory address that is
associated with this variable, and reads or changes it from there.

It is important to remember that the computer assigns
a memory address to the variable that marks the start of the memory area where
the value of the variable is stored when the program is running. The value of
the variable usually fills up a small block of successive memory addresses,
right up to its maximal length or up to a special end marker value (for
strings).

The memory address of a variable can be accessed by
using a pointer, which can be useful for converting values between variables of
different types. I’ll tell you more about pointers in a later part of this
tutorial.

How to define a variable

In the C++ programming language – like in a lot of other programming languages –
variables have to be properly defined before they can be used. A proper
variable definition includes the data type and the name of the variable. In C++
(and other variations of the C programming language), the data type is written
first, before the name of the variable, e.g.:

int x;

In the above example, the variable with the name “x”
is defined as an integer variable (identifier “int”). This means that “x” can
contain a positive number value where the numbers are integer values without
any decimal places.

This form – a single
data type identifier followed by the variable name and a semicolon – is the
shortest and easiest type of a data definition in C++.

In the C++ programming language, variables and constants are defined right at the beginning of a function, method or object class, before any further instructions.

If you try to use a variable or constant before having defined it, you get an error when you try to compile the program.

Assigning values to variables

Once a variable is defined, it can be used in the
program. If you want to assign a specific value to the variable, this can be
done in a way that is similar to a mathematical equation. The following line of
code stores the value “5” in the variable “x”:

x = 5;

It is also possible to combine the variable definition with the
assignment of an initial value:

int x = 5;

The memory reservation and storing the value in the
newly reserved memory area are combined into one line of code, although the
computer will execute both steps one after the other (just like it would be
when you split up the variable definition and the value assignment into two
separate lines of code).

In the same way, a computed value can be assigned to
the variable:

x = x + 4;

The statement above would instruct the computer to
first add 4 to the current value of x (right side of the assignment) and then
store the new value in x. The new, computed value overwrites the old value as
it is stored in the same memory location as the old value for x.

Functions and methods
can also be a source for a new value that can be assigned to a variable. Some
functions return a value just like a direct computation:

y = max(a,b);

In this example, the variable “y” is assigned the
return value of the function “max” which determines the maximum of the values
stored in the variables “a” and “b”. So in the end, “y” contains the maximum of
“a” and “b”.

Some functions and
methods also use reference variables as part of their input, so that more than
one value can be returned. So in a function call like

y = MyComputation(a,b,c);

the Function “MyComputation” not only returns a value
which is then stored in the variable “y”, but it also can change the values for
the input variables “a”, “b” and “c”, if these have been defined as reference
variables or pointers. More on that later…

Initial values for variables

In the C and C++ programming language, you can combine the definition of a variable that uses one of the standard data types with the assignment of an initial value for that variable, e.g.:

int x = 5;
char bval = 'X';

If your code gets longer and more complicated, you can use this to make sure that certain variables have useful values when they are used the first time. Alternatively, you can put in a special code section, function or method with the assignment of initial values for these variables and use this at the start of your program.

Using variables without inital or assigned values can cause problems. For character-based variables, this is usually no big problem, but for integer or floating point values an "empty" variable without a value can lead to wrong computations or even a breakdown of your program during runtime.

Value limits

Due to the reservation of a fixed amount of memory for
a defined variable, the variable itself can only contain a certain range of
possible values. These values also depend on the basic binary nature of the
inner workings of the computer.

This means that an
integer variable like the one defined by

int x;

cannot be as big as you like, only as big as what can
be stored inside the reserved part of the memory.

In the case of an integer variable defined with the
identifier “int”, this typically means a 16-bit (2-byte) value (at least right
now, in autumn of 2014). Each bit can only have one of two values, namely “0”
(zero) or “1” (one). With 16 bits, the amount of possible values is 2 to the
power of 16 (2^16), which is equal to 65536 different values. As the values
start with zero (in the form of 16 single zeroes), the highest possible value
is 65535.

Bigger values can be stored and used by using
different data types like “long int” (which uses double the amount of memory
than a normal “int”).

Here is a short
overview for typical value ranges depending on the amount of memory that
different data types use:

Numberof bits

Amount of possible values

Remarks

8

256

equal to 2 to the power of 8

16

65 535

32

4 294 967 296

more than 4 billion values

64

18 446 744 073 709 551 616

that's around 18 billion billion possible values!

Wrap-up

That’s all for now concerning the basics of data
definitions. In the next part of this tutorial, we take a closer look at the
different standard data types that you can use when defining variables or
constants.