กก

Section 1.2 Variables. Data types. Constants.

The usefulness of the "Hello World" program shown in the previous section is more than questionable. Since we have had to write several lines of code, compile them, and then execute the resulting program to obtain just a phrase on the screen as result. It is true, but programming is not limited only to print texts on screen, whereupon would have been much faster to do it by ourselves. 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 think that I ask you to retain number 5 in your mental memory, and then I ask you to memorize also the number 2. You have just stored two values in your memory. Now, if I ask you to add 1 to the first number I said, you should be retaining numbers 6 (that is 5+1) and 2 in your memory. Values that now we could subtract and obtain 4 as result.

All this process that you have made is a simil of what a computer can do with two variables. This same process can be expressed in C++ with the following instruction set:

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 several million of numbers like these at the same time and conduct sophisticated mathematical operations with them.

Therefore, we can define a variable like a portion of memory to store a determined value.

Each variable needs an identifier that distinguishes it from the others, for example, in the previous code the variable identifiers were a, b and result, but we could have called the variables like we had wanted to invent, whenever they were valid identifiers.

Identifiers

Neither spaces nor marked letters can be part of an identifier. Only letters, digits and underline characters are valid. In addition, variable identifiers would always have to begin with a letter. They can also begin with an underline character ( _ ), but this is usually reserved for external links. In no case they can begin with a digit.

Another rule that you have to consider at the time of inventing your own identifiers is that they cannot match with any language's key word nor your compiler's ones since they could be confused with these, for example, the following expressions are always considered key words according to the ANSI-C++ standard and therefore they must not be used as identifiers:

asm, car, bool, break, marry, catch, to char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, to register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t

and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq

Important: The C++ language is "case sensitive", that means that a same identifier written in capital letters is not equivalent to another one with the same name but written in small letters. Thus, for example the variable RESULT is not the same one that the variable result nor variable Result.

Data types

Our computer's memory is organized in bytes. A byte is the minimum amount of memory which we can manage. A byte is able to store a relatively small data, like an integer between 0 and 255 or one single character. But in addition, the computer can manipulate more complex data types that come from grouping several bytes, like long numbers or numbers with decimals. Next you have a list of the existing fundamental data types in C++, as well as the range of values that can be represented with each of them:

Declaration of variables

int a;
float mynumber;

If you need to declare several variables of the same type and you want to save some writing work you can declare all of them in the same line separating the identifiers with commas. For example:

int a, b, c;

int a;
int b;
int c;

Integer data types (char, short, long and int) can be signed or unsigned according to the range of numbers that we need to represent. Thus to specify an integer data type we do it by putting the keyword signed or unsigned before the data type itself. For example:

unsigned short NumberOfSons;
signed int MyAccountBalance;

int MyAccountBalance

The only exception to this rule is the char type that exists by itself and is considered by ANSI-C++ a diferent type than signed char and unsigned char.

To see in action how looks like a declaration in a program, we are going to see the C++ code of the example about your mental memory proposed at the beginning of this section:

// operating with variables #include <iostream.h> main () { // declaring variables: int a, b; int result; // process: a = 5; b = 2; a = a + 1; result = a - b; // print out the result: cout << result; // terminate the program: return 0; }

4

Do not worry if something out of the varibale declarations sounds a bit strange to you. You will see the rest in detail in next sections.

Initialization of variables

type identifier = initial_value ;

int a = 0;

Additionally to this C-like way of initializating variables, C++ has added a new way to initialize them by enclosing the initial value between parenthesis ():

type identifier (initial_value) ;

int a (0);

Scope of variables

Even so it is recommendable to follow the indications of the C language when declaring variables, since it can be very useful at the time of correcting a program to have all the declarations grouped together. Therefore, the traditional way to declare C-like variables is to include their declaration at the beginning of each function (local variables) or directly in the body of the program outside any function (global variables).

Global variables can be referred anywhere in the code, even within functions, whenever it be after its declaration. The scope of local variables is limited to the code level in which they are declared. If they are declared at the beginning of a function (like in main) its scope is the whole main function. This means that if in the example above, moreover than the function main() another function existed, the local variables declared in main could not be used in the other function and vice versa. In addition to local and global scopes exists the external scope, that causes a variable to be visible not only in the same source file but in all other archives which will be linked with. In C++ the scope of a variable is given by the block in which it is declared (a block is a group of instructions grouped together within key brackets {} signs). If it is declared within a function it will be a variable with function scope, if it is declared in a loop its scope will be only the loop, etc...

Constants: Literals.

Integer Numbers

1776
707
-273

In addition to decimal numbers (those that all of us already know) C++ allows the use as literal constant of octal numbers (radix 8) and hexadecimal numbers (radix 16). In order to express an octal number we must precede it with a 0 character (zero character). And to express a hexadecimal number we have to precede it with the characters 0x. For example, the following literal constants are all equivalent to each other:

75         // decimal
0113       // octal
0x4b       // hexadecimal

[ Note: You can find more information on hexadecimal and octal representations in the document Numerical radixes]

Floating Point Numbers
They express numbers with decimals and/or exponent. They can include a decimal point, an e character (that expreses "by ten high to...") or both.

3.14159    // 3.14159
6.02e23    // 6.02 x 1023
1.6e-19    // 1.6 x 10-19
3.0        // 3.0

Characters and strings
There also exist non-numerical constants, like:

'z'
'p'
"Hello world"
"How do you do?"

When writing both single characters and strings of characters in a constant way, it is necessary to put the quotation marks to distinguish them from possible variable identifiers or reserved words. Notice this:

x
'x'

Character constants and string constants have certain peculiarities like the escape codes. These are special characters that cannot be expressed otherwise in the sourcecode of a program, like newline (\n) or tab (\t). All of them are preceded by an inverted slash (\). Here you have a list of such escape codes:

\n	newline
\r	carriage return
\t	tabulation
\v	vertical tabulation
\b	backspace
\f	page feed
\a	alert (beep)
\'	simple quotes (')
\"	double quotes (")
\	question (?)
\\	inverted slash (\)

'\n'
'\t'
"Left \t Right"
"one\ntwo\nthree"

String of characters constants can be extended by more than a single code line if each one ends with an inverted slash (\):

"string expressed in \
two lines"

"we form" "a unique" "string" "of characters"

Defined constants (#define)

#define identifier value

#define PI 3.14159265
#define NEWLINE '\n'
#define WIDTH 100

circle = 2 * PI * r;
cout << NEWLINE;

The #define directive is not an instruction of code, it is a directive for the preprocessor, reason why it assumes the whole line as the directive and does not require a semicolon (;) at the end of it. If you include a semicolon character (;) at the end, it will also be added when the preprocessor will substitute any occurence of the defined constant in the body of the program.

declared constants (const)

const int width = 100;
const to char tab = '\t';
const zip = 12440;

© The C++ Resources Network, 2000 - All rights reserved

Previous: 1-1. Structure of a C++ program.

index

Next: 1-3. Operators.