Variables - are used to store up some kind of data for later use.

Data types
 String (Sentence, Phrases)- One of the most useful data types
supplied in the C++ libraries is the string. A string is a variable that
stores a sequence of letters or other characters, such as "Hello" or
"May 10th is my birthday!". Just like the other data types, to create a string
we first declare it, then we can store a value in it.

 Char - (One Letter)-Char is a C++ data type designed for the storage of
letters. Char is an abbreviation for an alphanumeric character. It is an
integral data type, meaning the value is stored as an integer. A char takes
a memory size of 1 byte.

 Boolean - (True or False) -The Boolean data type is used to declare a

variable whose value will be set as true (1) or false (0). To declare
such a value, you use the bool keyword. ... A Boolean constant is used to
check the state of a variable, an expression, or a function, as true or false.

Int (Positive & Negative Numbers) - n int variable contains only whole
numbers
 Int, short for "integer," is a fundamental variable type built into the
compiler and used to define numeric variables holding whole numbers.
Other data types include float and double. C, C++, C# and many other
programming languages recognize int as a data type

 Float (less precise decimals) is a shortened term for "floating point." By definition,
it's a fundamental data type built into the compiler that's used to define numeric
values with floating decimal points. C, C++, C# and many other programming
languages recognize float as a data type.

 The double (more precise decimals) is a fundamental data type built
into the compiler and used to define numeric variables holding
numbers with decimal points. ... A double type can represent fractional
as well as whole values. It can contain up to 15 digits in total, including
those before and after the decimal point.
 #include <stdlib.h>
What is stdlib used for in C++?
h is the header of the general purpose standard library of C programming
language which includes functions involving memory allocation, process
control, conversions and others. It is compatible with C++ and is known as
cstdlib in C++.

Standard Library
The header file stdlib. ... h stands for Standard Library. It has the information of memory
allocation/freeing functions

#include <conio.h>

Conio. h is a header file used to include some functions like clrscr(), getch()
etc. You can include these function by simply #include<conio.
...
h> can be broken & simply explained as :
1. In C/C++ Language Symbol # is know as preprocessor,
2. include is a directory and all the header files like stdio. h, conio. .

Preprocessor directives
Preprocessor directives are lines included in the code of programs
preceded by a hash sign (#). These lines are not program statements but
directives for the preprocessor. The preprocessor examines the code
before actual compilation of code begins and resolves all these
directives before any code is actually generated by regular statements.

These preprocessor directives extend only across a single line of

code. As soon as a newline character is found, the preprocessor
directive is ends. No semicolon (;) is expected at the end of a
preprocessor directive. The only way a preprocessor directive can extend
through more than one line is by preceding the newline character at the
end of the line by a backslash (\).

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 variables.

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 a = 5;
2 b = 2;
3 a = a + 1;
4 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 identifying three different variables.

Fundamental data types

The values of variables are stored somewhere in an unspecified location in the computer
memory as zeros and ones. Our program does not need to know the exact location where
a variable is stored; it can simply refer to it by its name. What the program needs to be
aware of is the kind of data stored in the variable. It's not the same to store a simple
integer as it is to store a letter or a large floating-point number; even though they are all
represented using zeros and ones, they are not interpreted in the same way, and in many
cases, they don't occupy the same amount of memory.

Fundamental data types are basic types implemented directly by the language that
represent the basic storage units supported natively by most systems. They can mainly be
classified into:
 Character types: They can represent a single character, such as 'A' or '$'. The
most basic type is char, which is a one-byte character. Other types are also
provided for wider characters.
 Numerical integer types: They can store a whole number value, such
as 7 or 1024. They exist in a variety of sizes, and can either
be signed or unsigned, depending on whether they support negative values or not.
 Floating-point types: They can represent real values, such as 3.14 or 0.01, with
different levels of precision, depending on which of the three floating-point types is
used.
 Boolean type: The boolean type, known in C++ as bool, can only represent one
of two states, true or false.

Here is the complete list of fundamental types in C++:

Group Type names* Notes on size / precision
char Exactly one byte in size. At least 8 bits.
char16_t Not smaller than char. At least 16 bits.
Character types char32_t Not smaller than char16_t. At least 32 bits.
Can represent the largest supported
wchar_t
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.
unsigned char
unsigned short int
Integer types unsigned int
(same size as their signed counterparts)
(unsigned) unsigned long int
unsigned long
long int
float
Floating-point types 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)

 The names of certain integer types can be abbreviated without

their signed and int components - only the part not in italics is required to identify the
type, the part in italics is optional. I.e., signed short int can be abbreviated as signed
short, short int, or simply short; they all identify the same fundamental type.

Within each of the groups above, the difference between types is only their size (i.e., how
much they occupy in memory): the first type in each group is the smallest, and the last is
the largest, with each type being at least as large as the one preceding it in the same
group. Other than that, the types in a group have the same properties.

Note in the panel above that other than char (which has a size of exactly one byte), none
of the fundamental types has a standard size specified (but a minimum size, at most).
Therefore, the type is not required (and in many cases is not) exactly this minimum size.
This does not mean that these types are of an undetermined size, but that there is no
standard size across all compilers and machines; each compiler implementation may
specify the sizes for these types that fit the best the architecture where the program is
going to run. This rather generic size specification for types gives the C++ language a lot
of flexibility to be adapted to work optimally in all kinds of platforms, both present and
future.

Type sizes above are expressed in bits; the more bits a type has, the more distinct values
it can represent, but at the same time, also consumes more space in memory:

Size Unique representable values Notes

8
8-bit 256 = 2
16-bit 65 536 = 216
32-bit 4 294 967 296 = 232 (~4 billion)
64-bit 18 446 744 073 709 551 616 = 264 (~18 billion billion)

For integer types, having more representable values means that the range of values they
can represent is greater; for example, a 16-bit unsigned integer would be able to
represent 65536 distinct values in the range 0 to 65535, while its signed counterpart
would be able to represent, on most cases, values between -32768 and 32767. Note that
the range of positive values is approximately halved in signed types compared to unsigned
types, due to the fact that one of the 16 bits is used for the sign; this is a relatively
modest difference in range, and seldom justifies the use of unsigned types based purely on
the range of positive values they can represent.

For floating-point types, the size affects their precision, by having more or less bits for
their significant and exponent.

If the size or precision of the type is not a concern, then char, int, and double are typically
selected to represent characters, integers, and floating-point values, respectively. The
other types in their respective groups are only used in very particular cases.

The properties of fundamental types in a particular system and compiler implementation

can be obtained by using the numeric_limits classes (see standard header <limits>). If for
some reason, types of specific sizes are needed, the library defines certain fixed-size type
aliases in header <cstdint>.

The types described above (characters, integers, floating-point, and boolean) are
collectively known as arithmetic types. But two additional fundamental types exist: void,
which identifies the lack of type; and the type nullptr, which is a special type of pointer.
Both types will be discussed further in a coming chapter about pointers.

C++ supports a wide variety of types based on the fundamental types discussed above;
these other types are known as compound data types, and are one of the main strengths
of the C++ language. We will also see them in more detail in future chapters.

Declaration of variables
C++ is a strongly-typed language, and requires every variable to be
declared with its type before its first use. This informs the
compiler the size to reserve in memory for the variable and how to
interpret its value. The syntax to declare a new variable in C++ is
straightforward: we simply write the type followed by the variable
name (i.e., its identifier). For example:
1 int a;
2
float mynumber;

These are two valid declarations of variables. The first one declares
a variable of type int with the identifier a. The second one
declares a variable of type float with the identifier mynumber.
Once declared, the variables a and mynumber can be used within
the rest of their scope in the program.
If declaring more than one variable of the same type, they can all be
declared in a single statement by separating their identifiers with
commas. For example:
  int a, b, c;

This declares three variables (a, b and c), all of them of

type int, and has exactly the same meaning as:
1 int a;
2
3 int b;
 int c;

To see what variable declarations look like in action within a program, let's have a look at
the entire C++ code of the example about your mental memory proposed at the beginning
of this chapter:

1 // operating with variables

2
3
#include <iostream>
4 using namespace std;
5 int main ()
6{
7 // declaring variables:
8
9 int a, b;
1 int result;
0
1 // process:
1 a = 5;
1 b = 2;
2 a = a + 1;
1 result = a - b;
3
1
4 // print out the result:
1 cout << result;
5
1 // terminate the program:
6
return 0;
1
}
7
1
8
1
9
2
0
2
1
2
2
2
3

Initialization of variables
When the variables in the example above are declared, they have an undetermined value
until they are assigned a value for the first time. But it is possible for a variable to have a
specific value from the moment it is declared. This is called the initialization of the
variable.

In C++, there are three ways to initialize variables. They are all equivalent and are
reminiscent of the evolution of the language over the years:

The first one, known as c-like initialization (because it is inherited from the C language),
consists of appending an equal sign followed by the value to which the variable is
initialized:
type identifier = initial_value;
For example, to declare a variable of type int called x and initialize it to a value of zero
from the same moment it is declared, we can write:

  int x = 0;

A second method, known as constructor initialization (introduced by the C++ language),

encloses the initial value between parentheses (()):

type identifier (initial_value);

For example:

  int x (0);

Finally, a third method, known as uniform initialization, similar to the above, but using
curly braces ({}) instead of parentheses (this was introduced by the revision of the C++
standard, in 2011):

type identifier {initial_value};

For example:

  int x {0};

All three ways of initializing variables are valid and equivalent in C++.

1 // initialization of variables
2
3
#include <iostream>
4 using namespace std;
5 int main ()
6{
7 int a=5; // initial value: 5
8
9 int b(3); // initial value: 3
1 int c{2}; // initial value: 2
0 int result; // initial value undetermined
1
1
a = a + b;
1
result = a - c;
2
cout << result;
1
3
1 return 0;
4}
1
5
1
6
1
7
1
8

Introduction to strings
Fundamental types represent the most basic types handled by the machines where the
code may run. But one of the major strengths of the C++ language is its rich set of
compound types, of which the fundamental types are mere building blocks.

An example of compound type is the string class. Variables of this type are able to store
sequences of characters, such as words or sentences. A very useful feature!

A first difference with fundamental data types is that in order to declare and use objects
(variables) of this type, the program needs to include the header where the type is defined
within the standard library (header <string>):

1 // my first string This is a string

2
3
#include <iostream>
4 #include <string>
5 using namespace std;
6 int main ()
7{
8 string mystring;
9 mystring = "This is a string";
10 cout << mystring;
11
12 return 0;
}

As you can see in the previous example, strings can be initialized with any valid string
literal, just like numerical type variables can be initialized to any valid numerical literal. As
with fundamental types, all initialization formats are valid with strings:

1 string mystring = "This is a string";

2 string mystring ("This is a string");
3 string mystring {"This is a string"};

Note: inserting the endl manipulator ends the line (printing a newline character and

flushing the stream).

The string class is a compound type. As you can see in the example above, compound

types are used in the same way as fundamental types: the same syntax is used to declare
variables and to initialize them.

Constants
Constants are expressions with a fixed value.

Literals
Literals are the most obvious kind of constants. They are used to
express particular values within the source code of a program. We
have already used some in previous chapters to give specific values
to variables or to express messages we wanted our programs to print
out, for example, when we wrote:
  a = 5;

The 5 in this piece of code was a literal constant.

Literal constants can be classified into: integer, floating-point,
characters, strings, Boolean, pointers, and user-defined literals.
Integer Numerals

1 1776
2 707
3 -273

These are numerical constants that identify integer values. Notice

that they are not enclosed in quotes or any other special character;
they are a simple succession of digits representing a whole number in
decimal base; for example, 1776 always represents the value one
thousand seven hundred seventy-six.

In addition to decimal numbers (those that most of us use every day),

C++ allows the use of octal numbers (base 8) and hexadecimal numbers
(base 16) as literal constants. For octal literals, the digits are
preceded with a 0 (zero) character. And for hexadecimal, they are
preceded by the characters 0x (zero, x). For example, the following
literal constants are all equivalent to each other:
1 75 // decimal
2
3 0113 // octal
0x4b // hexadecimal

All of these represent the same number: 75 (seventy-five) expressed

as a base-10 numeral, octal numeral and hexadecimal numeral,
respectively.

These literal constants have a type, just like variables. By default,

integer literals are of type int. However, certain suffixes may be
appended to an integer literal to specify a different integer type:

Suffix Type modifier

u or U unsigned
l or L long
ll or LL long long

Unsigned may be combined with any of the other two in any order to
form unsigned long or unsigned long long.

For example:
1 75 // int
2
3 75u // unsigned int
4 75l // long
5
 75ul // unsigned long
75lu // unsigned long

In all the cases above, the suffix can be specified using either
upper or lowercase letters.

Floating Point Numerals

They express real values, with decimals and/or exponents. They can
include either a decimal point, an e character (that expresses "by
ten at the Xth height", where X is an integer value that follows
the e character), or both a decimal point and an e character:
1 3.14159 // 3.14159
2
3 6.02e23 // 6.02 x 10^23
4 1.6e-19 // 1.6 x 10^-19
3.0 // 3.0

These are four valid numbers with decimals expressed in C++. The
first number is PI, the second one is the number of Avogadro, the
third is the electric charge of an electron (an extremely small
number) -all of them approximated-, and the last one is the
number three expressed as a floating-point numeric literal.

The default type for floating-point literals is double. Floating-

point literals of type float or long double can be specified by
adding one of the following suffixes:

Suffix Type
f or F float
l or L long double

For example:
1 3.14159L // long double
2
6.02e23f // float

Any of the letters that can be part of a floating-point numerical

constant (e, f, l) can be written using either lower or uppercase
letters with no difference in meaning.
Character and string literals
Character and string literals are enclosed in quotes:
1 'z''p'"Hello world""How do you do?"
2
3
4

The first two expressions represent single-character literals, and

the following two represent string literals composed of several
characters. Notice that to represent a single character, we enclose
it between single quotes ('), and to express a string (which
generally consists of more than one character), we enclose the
characters between double quotes (").

Both single-character and string literals require quotation marks

surrounding them to distinguish them from possible variable
identifiers or reserved keywords. Notice the difference between these
two expressions:

x
'x'

Here, x alone would refer to an identifier, such as the name of a

variable or a compound type, whereas 'x' (enclosed within single
quotation marks) would refer to the character literal 'x' (the
character that represents a lowercase x letter).

Character and string literals can also represent special characters

that are difficult or impossible to express otherwise in the source
code of a program, like newline (\n) or tab (\t). These special
characters are all of them preceded by a backslash character (\).

Here you have a list of the single character escape codes:

Escape code Description

\n newline
\r carriage return
\t tab
\v vertical tab
\b backspace
\f form feed (page feed)
\a alert (beep)
\' single quote (')
\" double quote (")
\? question mark (?)
\\ backslash (\)

For example:

'\n'
'\t'
"Left \t Right"
"one\ntwo\nthree"
Internally, computers represent characters as numerical codes: most
typically, they use one extension of the ASCII character encoding
system (see ASCII code for more info). Characters can also be
represented in literals using its numerical code by writing a
backslash character (\) followed by the code expressed as an octal
(base-8) or hexadecimal (base-16) number. For an octal value, the
backslash is followed directly by the digits; while for hexadecimal,
an x character is inserted between the backslash and the
hexadecimal digits themselves (for example: \x20 or \x4A).

Several string literals can be concatenated to form a single string

literal simply by separating them by one or more blank spaces,
including tabs, newlines, and other valid blank characters. For
example:
1 "this forms" "a single" " string ""of characters"
2

The above is a string literal equivalent to:

  "this formsa single string of characters"

Note how spaces within the quotes are part of the literal, while
those outside them are not.

Some programmers also use a trick to include long string literals in

multiple lines: In C++, a backslash (\) at the end of line is
considered a line-continuation character that merges both that line
and the next into a single line. Therefore the following code:
1 x = "string expressed in \
2 two lines"

is equivalent to:
  x = "string expressed in two lines"

All the character literals and string literals described above are
made of characters of type char. A different character type can be
specified by using one of the following prefixes:

Prefix Character type

u char16_t
U char32_t
L wchar_t

Note that, unlike type suffixes for integer literals, these prefixes
are case sensitive: lowercase for char16_t and uppercase
for char32_t and wchar_t.

For string literals, apart from the above u, U, and L, two

additional prefixes exist:

Prefix Description
u8 The string literal is encoded in the executable using UTF-8
R The string literal is a raw string

In raw strings, backslashes and single and double quotes are all
valid characters; the content of the literal is delimited by an
initial R"sequence( and a final )sequence", where sequence is
any sequence of characters (including an empty sequence). The content
of the string is what lies inside the parenthesis, ignoring the
delimiting sequence itself. For example:
1 R"(string with \backslash)"
2 R"&%$(string with \backslash)&%$"

Both strings above are equivalent to "string with \\backslash".

The R prefix can be combined with any other prefixes, such
as u, L or u8.
Other literals
Three keyword literals exist in C++: true, false and nullptr:
 true and false are the two possible values for variables of type bool.
 nullptr is the null pointer value.

1 bool foo = true;

2
3 bool bar = false;
int* p = nullptr;

Typed constant expressions

Sometimes, it is just convenient to give a name to a constant value:
1 constdouble pi = 3.1415926;
2
const char tab = '\t';

We can then use these names instead of the literals they were defined
to:
1 #include <iostream> 31.4159
2
3
using namespace std;
4 const double pi = 3.14159;const char
5 newline = '\n';
 6 int main ()
7{
8
9 double r=5.0; // radius
10 double circle;
11
12 circle = 2 * pi * r;
13 cout << circle;
14 cout << newline;
15 }

Preprocessor definitions (#define)

Another mechanism to name constant values is the use of preprocessor definitions. They
have the following form:

#define identifier replacement

After this directive, any occurrence of identifier in the code is interpreted as replacement,
where replacement is any sequence of characters (until the end of the line). This
replacement is performed by the preprocessor, and happens before the program is
compiled, thus causing a sort of blind replacement: the validity of the types or syntax
involved is not checked in any way.

For example:
1 #include <iostream> 31.4159
2
3
using namespace std;
4 #define PI 3.14159
5 #define NEWLINE '\n'
6 int main ()
7{
8
9 double r=5.0; // radius
10 double circle;
11
12 circle = 2 * PI * r;
13 cout << circle;
14 cout << NEWLINE;
15
16 }

Note that the #define lines are preprocessor directives, and as such are single-line
instructions that -unlike C++ statements- do not require semicolons (;) at the end; the
directive extends automatically until the end of the line. If a semicolon is included in the
line, it is part of the replacement sequence and is also included in all replaced occurrences.
Operators
Once introduced to variables and constants, we can begin to operate
with them by using operators. What follows is a complete list of
operators. At this point, it is likely not necessary to know all of
them, but they are all listed here to also serve as reference.

Assignment operator (=)

The assignment operator assigns a value to a variable.
  x = 5;
This statement assigns the integer value 5 to the variable x. The
assignment operation always takes place from right to left, and never
the other way around:
  x = y;

This statement assigns to variable x the value contained in

variable y. The value of x at the moment this statement is
executed is lost and replaced by the value of y.

Consider also that we are only assigning the value of y to x at

the moment of the assignment operation. Therefore, if y changes at
a later moment, it will not affect the new value taken by x.

For example, let's have a look at the following code - I have

included the evolution of the content stored in the variables as
comments:
1 // assignment operator a:4 b:7
2
3
#include <iostream>
4 using namespace std;
5 int main ()
6{
7 int a, b; // a:?, b:?
8
9 a = 10; // a:10, b:?
10 b = 4; // a:10, b:4
11 a = b; // a:4, b:4
12
13 b = 7; // a:4, b:7
14
15 cout << "a:";
16 cout << a;
17 cout << " b:";
cout << b;
}

This program prints on screen the final values of a and b (4 and

7, respectively). Notice how a was not affected by the final
modification of b, even though we declared a = b earlier.

Assignment operations are expressions that can be evaluated. That

means that the assignment itself has a value, and -for fundamental
types- this value is the one assigned in the operation. For example:
  y = 2 + (x = 5);

In this expression, y is assigned the result of adding 2 and the

value of another assignment expression (which has itself a value of
5). It is roughly equivalent to:
1 x = 5;
2 y = 2 + x;

With the final result of assigning 7 to y.

The following expression is also valid in C++:

  x = y = z = 5;

It assigns 5 to the all three variables: x, y and z; always from

right-to-left.

Arithmetic operators ( +, -, *, /, % )
The five arithmetical operations supported by C++ are:

operator description
+ addition
- subtraction
* multiplication
/ division
% modulo

Operations of addition, subtraction, multiplication and division

correspond literally to their respective mathematical operators. The
last one, modulo operator, represented by a percentage sign (%),
gives the remainder of a division of two values. For example:
  x = 11 % 3;

results in variable x containing the value 2, since dividing 11 by

3 results in 3, with a remainder of 2.

Compound assignment (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |
=)
Compound assignment operators modify the current value of a variable
by performing an operation on it. They are equivalent to assigning
the result of an operation to the first operand:

expression equivalent to...

y += x; y = y + x;
x -= 5; x = x - 5;
x /= y; x = x / y;
price *= units + 1; price = price * (units+1);
and the same for all other compound assignment operators. For
example:
1 // compound assignment operators 5
2
3
#include <iostream>
4 using namespace std;
5 int main ()
6{
7 int a, b=3;
8 a = b;
9
10 a+=2; // equivalent to a=a+2
11 cout << a;
}

Increment and decrement (++, --)

Some expression can be shortened even more: the increase operator (+
+) and the decrease operator (--) increase or reduce by one the value
stored in a variable. They are equivalent to +=1 and to -=1,
respectively. Thus:
1 ++x;
2 x+=1;
3 x=x+1;

are all equivalent in its functionality; the three of them increase

by one the value of x.

In the early C compilers, the three previous expressions may have

produced different executable code depending on which one was used.
Nowadays, this type of code optimization is generally performed
automatically by the compiler, thus the three expressions should
produce exactly the same executable code.

A peculiarity of this operator is that it can be used both as a

prefix and as a suffix. That means that it can be written either
before the variable name (++x) or after it (x++). Although in simple
expressions like x++ or ++x, both have exactly the same meaning;
in other expressions in which the result of the increment or
decrement operation is evaluated, they may have an important
difference in their meaning: In the case that the increase operator
is used as a prefix (++x) of the value, the expression evaluates to
the final value of x, once it is already increased. On the other
hand, in case that it is used as a suffix (x++), the value is also
increased, but the expression evaluates to the value that x had
before being increased. Notice the difference:

Example 1 Example 2
x = 3; x = 3;
y = ++x; y = x++;
// x contains 4, y contains 4 // x contains 4, y contains 3

In Example 1, the value assigned to y is the value of x after

being increased. While in Example 2, it is the value x had before
being increased.

Relational and comparison operators ( ==, !=, >, <, >=, <= )
Two expressions can be compared using relational and equality
operators. For example, to know if two values are equal or if one is
greater than the other.

The result of such an operation is either true or false (i.e., a

Boolean value).

The relational operators in C++ are:

operator description
== Equal to
!= Not equal to
< Less than
> Greater than
<= Less than or equal to
>= Greater than or equal to

Here there are some examples:

1 (7 == 5) // evaluates to false
2
3 (5 > 4) // evaluates to true
4 (3 != 2) // evaluates to true
5 (6 >= 6) // evaluates to true
(5 < 5) // evaluates to false

Of course, it's not just numeric constants that can be compared, but
just any value, including, of course, variables. Suppose
that a=2, b=3 and c=6, then:
1 (a == 5) // evaluates to false, since a is not equal to 5
2
3 (a*b >= c) // evaluates to true, since (2*3 >= 6) is true
4 (b+4 > a*c) // evaluates to false, since (3+4 > 2*6) is false
((b=2) == a) // evaluates to true

Be careful! The assignment operator (operator =, with one equal

sign) is not the same as the equality comparison operator
(operator ==, with two equal signs); the first one (=) assigns the
value on the right-hand to the variable on its left, while the other
(==) compares whether the values on both sides of the operator are
equal. Therefore, in the last expression ((b=2) == a), we first
assigned the value 2 to b and then we compared it to a (that
also stores the value 2), yielding true.

Logical operators ( !, &&, || )

The operator ! is the C++ operator for the Boolean operation NOT.
It has only one operand, to its right, and inverts it,
producing false if its operand is true, and true if its operand
is false. Basically, it returns the opposite Boolean value of
evaluating its operand. For example:
1 !(5 == 5) // evaluates to false because the expression at its
2
3 right (5 == 5) is true
4 !(6 <= 4) // evaluates to true because (6 <= 4) would be false
!true // evaluates to false
!false // evaluates to true

The logical operators && and || are used when evaluating two

expressions to obtain a single relational result. The
operator && corresponds to the Boolean logical operation AND, which
yields true if both its operands are true, and false otherwise.
The following panel shows the result of operator && evaluating the
expression a&&b:

&& OPERATOR (and)

a b a && b
true true true
true false false
false true false
false false false

The operator || corresponds to the Boolean logical operation OR,

which yields true if either of its operands is true, thus being
false only when both operands are false. Here are the possible
results of a||b:

|| OPERATOR (or)
a b a || b
true true true
true false true
false true true
false false false

For example:
1 ( (5 == 5) && (3 > 6) ) // evaluates to false ( true && false )
2
( (5 == 5) || (3 > 6) ) // evaluates to true ( true || false )

When using the logical operators, C++ only evaluates what is

necessary from left to right to come up with the combined relational
result, ignoring the rest. Therefore, in the last example ((5==5)||
(3>6)), C++ evaluates first whether 5==5 is true, and if so, it
never checks whether 3>6 is true or not. This is known as short-
circuit evaluation, and works like this for these operators:
operator short-circuit
if the left-hand side expression is false, the combined result is false (the right-
&&
hand side expression is never evaluated).
if the left-hand side expression is true, the combined result is true (the right-
||
hand side expression is never evaluated).

This is mostly important when the right-hand expression has side

effects, such as altering values:
  if ( (i<10) && (++i<n) ) { /*...*/ } // note that the condition
increments i

Here, the combined conditional expression would increase i by one,

but only if the condition on the left of && is true, because
otherwise, the condition on the right-hand side (++i<n) is never
evaluated.

Conditional ternary operator ( ? )

The conditional operator evaluates an expression, returning one value
if that expression evaluates to true, and a different one if the
expression evaluates as false. Its syntax is:

condition ? result1 : result2

If condition is true, the entire expression evaluates to result1,

and otherwise to result2.
1 7==5 ? 4 : 3 // evaluates to 3, since 7 is not equal to 5.
2
3 7==5+2 ? 4 : 3 // evaluates to 4, since 7 is equal to 5+2.
4 5>3 ? a : b // evaluates to the value of a, since 5 is greater
than 3.
a>b ? a : b // evaluates to whichever is greater, a or b.

For example:
1 // conditional operator 7
2
3
#include <iostream>
4 using namespace std;
5 int main ()
6{
7 int a,b,c;
8
9
10 a=2;
11 b=7;
12 c = (a>b) ? a : b;
13
14 cout << c << '\n';
}

In this example, a was 2, and b was 7, so the expression being

evaluated (a>b) was not true, thus the first value specified after
the question mark was discarded in favor of the second value (the one
after the colon) which was b (with a value of 7).

Comma operator ( , )
The comma operator (,) is used to separate two or more expressions
that are included where only one expression is expected. When the set
of expressions has to be evaluated for a value, only the right-most
expression is considered.

For example, the following code:

  a = (b=3, b+2);

would first assign the value 3 to b, and then assign b+2 to

variable a. So, at the end, variable a would contain the value 5
while variable b would contain value 3.

Bitwise operators ( &, |, ^, ~, <<, >> )

Bitwise operators modify variables considering the bit patterns that
represent the values they store.

operator asm equivalent description

& AND Bitwise AND
| OR Bitwise inclusive OR
^ XOR Bitwise exclusive OR
~ NOT Unary complement (bit inversion)
<< SHL Shift bits left
>> SHR Shift bits right

Explicit type casting operator

Type casting operators allow to convert a value of a given type to
another type. There are several ways to do this in C++. The simplest
one, which has been inherited from the C language, is to precede the
expression to be converted by the new type enclosed between
parentheses (()):
1 int i;float f = 3.14;
2
3 i = (int) f;
The previous code converts the floating-point number 3.14 to an
integer value (3); the remainder is lost. Here, the typecasting
operator was (int). Another way to do the same thing in C++ is to
use the functional notation preceding the expression to be converted
by the type and enclosing the expression between parentheses:
 i = int (f);

Both ways of casting types are valid in C++.

sizeof
This operator accepts one parameter, which can be either a type or a
variable, and returns the size in bytes of that type or object:
 x = sizeof (char);

Here, x is assigned the value 1, because char is a type with a

size of one byte.

The value returned by sizeof is a compile-time constant, so it is

always determined before program execution.

Other operators
Later in these tutorials, we will see a few more operators, like the
ones referring to pointers or the specifics for object-oriented
programming.

Precedence of operators
A single expression may have multiple operators. For example:
  x = 5 + 7 % 2;

In C++, the above expression always assigns 6 to variable x, because

the % operator has a higher precedence than the + operator, and
is always evaluated before. Parts of the expressions can be enclosed
in parenthesis to override this precedence order, or to make
explicitly clear the intended effect. Notice the difference:
1 x = 5 + (7 % 2); // x = 6 (same as without parenthesis)
2
x = (5 + 7) % 2; // x = 0

From greatest to smallest priority, C++ operators are evaluated in

the following order:
Level Precedence group Operator Description Grouping
1 Scope :: scope qualifier Left-to-
 right
postfix increment /
++ --
decrement
() functional forms Left-to-
2 Postfix (unary)
right
[] subscript
. -> member access
++ -- prefix increment / decrement
~! bitwise NOT / logical NOT
+- unary prefix
Right-to-
3 Prefix (unary) &* reference / dereference
left
new delete allocation / deallocation
sizeof parameter pack
(type) C-style type-casting
Left-to-
4 Pointer-to-member .* ->* access pointer
right
Left-to-
5 Arithmetic: scaling */% multiply, divide, modulo
right
Left-to-
6 Arithmetic: addition +- addition, subtraction
right
Left-to-
7 Bitwise shift << >> shift left, shift right
right
Left-to-
8 Relational < > <= >= comparison operators
right
Left-to-
9 Equality == != equality / inequality
right
Left-to-
10 And & bitwise AND
right
Left-to-
11 Exclusive or ^ bitwise XOR
right
Left-to-
12 Inclusive or | bitwise OR
right
Left-to-
13 Conjunction && logical AND
right
Left-to-
14 Disjunction || logical OR
right
= *= /= %= +=
-= assignment / compound
Assignment-level >>= <<= &= ^= assignment Right-to-
15
expressions |= left
?: conditional operator
Left-to-
16 Sequencing , comma separator
right

When an expression has two operators with the same precedence

level, grouping determines which one is evaluated first: either
left-to-right or right-to-left.

Enclosing all sub-statements in parentheses (even those unnecessary

because of their precedence) improves code readability.
Functions
Functions allow to structure programs in segments of code to perform
individual tasks.

In C++, a function is a group of statements that is given a name, and

which can be called from some point of the program. The most common
syntax to define a function is:

type name ( parameter1, parameter2, ...) { statements }

Where:
- type is the type of the value returned by the function.
- name is the identifier by which the function can be called.
- parameters (as many as needed): Each parameter consists of a type
followed by an identifier, with each parameter being separated from
the next by a comma. Each parameter looks very much like a regular
variable declaration (for example: int x), and in fact acts within
the function as a regular variable which is local to the function.
The purpose of parameters is to allow passing arguments to the
function from the location where it is called from.
- statements is the function's body. It is a block of statements
surrounded by braces { } that specify what the function actually
does.

Let's have a look at an example:

1 // function example The result is 8
2
3
#include <iostream>
4 using namespace std;
5 int addition (int a, int b)
6{
7 int r;
8 r=a+b;
9
10 return r;
11 }
12 int main ()
13 {
14 int z;
15 z = addition (5,3);
16 cout << "The result is " << z;
17 }

This program is divided in two functions: addition and main.

Remember that no matter the order in which they are defined, a C++
program always starts by calling main. In fact, main is the only
function called automatically, and the code in any other function is
only executed if its function is called from main (directly or
indirectly).
In the example above, main begins by declaring the variable z of
type int, and right after that, it performs the first function call:
it calls addition. The call to a function follows a structure very
similar to its declaration. In the example above, the call
to addition can be compared to its definition just a few lines
earlier:

The parameters in the function declaration have a clear

correspondence to the arguments passed in the function call. The call
passes two values, 5 and 3, to the function; these correspond to
the parameters a and b, declared for function addition.

At the point at which the function is called from within main, the
control is passed to function addition: here, execution of main is
stopped, and will only resume once the addition function ends. At
the moment of the function call, the value of both arguments
(5 and 3) are copied to the local variables int a and int
b within the function.

Then, inside addition, another local variable is declared (int r),

and by means of the expression r=a+b, the result of a plus b is
assigned to r; which, for this case, where a is 5 and b is 3,
means that 8 is assigned to r.

The final statement within the function:

  return r;

Ends function addition, and returns the control back to the point

where the function was called; in this case: to function main. At
this precise moment, the program resumes its course
on main returning exactly at the same point at which it was
interrupted by the call to addition. But additionally,
because addition has a return type, the call is evaluated as having
a value, and this value is the value specified in the return
statement that ended addition: in this particular case, the value of
the local variable r, which at the moment of the return statement
had a value of 8.

Therefore, the call to addition is an expression with the value

returned by the function, and in this case, that value, 8, is
assigned to z. It is as if the entire function call (addition(5,3))
was replaced by the value it returns (i.e., 8).

Then main simply prints this value by calling:

  cout << "The result is " << z;

A function can actually be called multiple times within a program,

and its argument is naturally not limited just to literals:
1 // function example The first result is 5
2 The second result is 5
3
#include <iostream>
4 using namespace std;
The third result is 2
5 int subtraction (int a, int b) The fourth result is 6
6{
7 int r;
8 r=a-b;
9
10 return r;
11 }
12 int main ()
13 {
14 int x=5, y=3, z;
15 z = subtraction (7,2);
16 cout << "The first result is " << z << '\n';
17 cout << "The second result is " << subtraction
18 (7,2) << '\n';
19 cout << "The third result is " << subtraction
20 (x,y) << '\n';
21 z= 4 + subtraction (x,y);
cout << "The fourth result is " << z << '\n';
}

Similar to the addition function in the previous example, this

example defines a subtract function, that simply returns the
difference between its two parameters. This time, main calls this
function several times, demonstrating more possible ways in which a
function can be called.

Let's examine each of these calls, bearing in mind that each function
call is itself an expression that is evaluated as the value it
returns. Again, you can think of it as if the function call was
itself replaced by the returned value:
1 z = subtraction (7,2);
2 cout << "The first result is " << z;

If we replace the function call by the value it returns (i.e., 5), we

would have:
1 z = 5;
2 cout << "The first result is " << z;
With the same procedure, we could interpret:
  cout << "The second result is " << subtraction (7,2);

as:
  cout << "The second result is " << 5;

since 5 is the value returned by subtraction (7,2).

In the case of:

  cout << "The third result is " << subtraction (x,y);

The arguments passed to subtraction are variables instead of

literals. That is also valid, and works fine. The function is called
with the values x and y have at the moment of the call: 5 and 3
respectively, returning 2 as result.

The fourth call is again similar:

  z = 4 + subtraction (x,y);

The only addition being that now the function call is also an operand
of an addition operation. Again, the result is the same as if the
function call was replaced by its result: 6. Note, that thanks to the
commutative property of additions, the above can also be written as:
  z = subtraction (x,y) + 4;

With exactly the same result. Note also that the semicolon does not
necessarily go after the function call, but, as always, at the end of
the whole statement. Again, the logic behind may be easily seen again
by replacing the function calls by their returned value:
1 z = 4 + 2; // same as z = 4 + subtraction (x,y);
2
z = 2 + 4; // same as z = subtraction (x,y) + 4;

Functions with no type. The use of void

The syntax shown above for functions:

type name ( argument1, argument2 ...) { statements }

Requires the declaration to begin with a type. This is the type of

the value returned by the function. But what if the function does not
need to return a value? In this case, the type to be used is void,
which is a special type to represent the absence of value. For
example, a function that simply prints a message may not need to
return any value:
1 // void function example#include I'm a function!
2
3
<iostream>using namespace std;
4 void printmessage ()
5{
6 cout << "I'm a function!";
7}
8 int main ()
9{
10 printmessage ();
11 }
12
13

void can also be used in the function's parameter list to explicitly

specify that the function takes no actual parameters when called. For
example, printmessage could have been declared as:
1 void printmessage (void)
2{
3 cout << "I'm a function!";
4}

In C++, an empty parameter list can be used instead of void with

same meaning, but the use of void in the argument list was
popularized by the C language, where this is a requirement.

Something that in no case is optional are the parentheses that follow

the function name, neither in its declaration nor when calling it.
And even when the function takes no parameters, at least an empty
pair of parentheses shall always be appended to the function name.
See how printmessage was called in an earlier example:
  printmessage ();

The parentheses are what differentiate functions from other kinds of

declarations or statements. The following would not call the
function:
  printmessage;

The return value of main

You may have noticed that the return type of main is int, but most
examples in this and earlier chapters did not actually return any
value from main.

Well, there is a catch: If the execution of main ends normally

without encountering a return statement the compiler assumes the
function ends with an implicit return statement:
  return 0;

Note that this only applies to function main for historical

reasons. All other functions with a return type shall end with a
proper return statement that includes a return value, even if this
is never used.

When main returns zero (either implicitly or explicitly), it is

interpreted by the environment as that the program ended
successfully. Other values may be returned by main, and some
environments give access to that value to the caller in some way,
although this behavior is not required nor necessarily portable
between platforms. The values for main that are guaranteed to be
interpreted in the same way on all platforms are:

value description
0 The program was successful
The program was successful (same as above).
EXIT_SUCCESS
This value is defined in header <cstdlib>.
The program failed.
EXIT_FAILURE
This value is defined in header <cstdlib>.

Because the implicit return 0; statement for main is a tricky

exception, some authors consider it good practice to explicitly write
the statement.

Arguments passed by value and by reference

In the functions seen earlier, arguments have always been passed by
value. This means that, when calling a function, what is passed to
the function are the values of these arguments on the moment of the
call, which are copied into the variables represented by the function
parameters. For example, take:
1 int x=5, y=3, z;
2 z = addition ( x, y );

In this case, function addition is passed 5 and 3, which are copies

of the values of x and y, respectively. These values (5 and 3) are
used to initialize the variables set as parameters in the function's
definition, but any modification of these variables within the
function has no effect on the values of the variables x and y outside
it, because x and y were themselves not passed to the function on the
call, but only copies of their values at that moment.

In certain cases, though, it may be useful to access an external

variable from within a function. To do that, arguments can be
passed by reference, instead of by value. For example, the
function duplicate in this code duplicates the value of its three
arguments, causing the variables used as arguments to actually be
modified by the call:
1 // passing parameters by reference#include x=2, y=6, z=14
2
3
<iostream>using namespace std;
4 void duplicate (int& a, int& b, int& c)
5{
6 a*=2;
7 b*=2;
8 c*=2;
9}
10 int main ()
11 {
12
13
int x=1, y=3, z=7;
duplicate (x, y, z);
14
cout << "x=" << x << ", y=" << y << ",
15
z=" << z;
16
17 return 0;
18 }

To gain access to its arguments, the function declares its parameters

as references. In C++, references are indicated with an ampersand
(&) following the parameter type, as in the parameters taken
by duplicate in the example above.

When a variable is passed by reference, what is passed is no longer

a copy, but the variable itself, the variable identified by the
function parameter, becomes somehow associated with the argument
passed to the function, and any modification on their corresponding
local variables within the function are reflected in the variables
passed as arguments in the call.

In fact, a, b, and c become aliases of the arguments passed on

the function call (x, y, and z) and any change on a within the
function is actually modifying variable x outside the function. Any
change on b modifies y, and any change on c modifies z. That is
why when, in the example, function duplicate modifies the values of
variables a, b, and c, the values of x, y, and z are affected.

If instead of defining duplicate as:

  void duplicate (int& a, int& b, int& c)

Was it to be defined without the ampersand signs as:

  void duplicate (int a, int b, int c)

The variables would not be passed by reference, but by value,

creating instead copies of their values. In this case, the output of
the program would have been the values of x, y, and z without
being modified (i.e., 1, 3, and 7).

Efficiency considerations and const references

Calling a function with parameters taken by value causes copies of
the values to be made. This is a relatively inexpensive operation for
fundamental types such as int, but if the parameter is of a large
compound type, it may result on certain overhead. For example,
consider the following function:
1 string concatenate (string a, string b)
2{
3 return a+b;
4}

This function takes two strings as parameters (by value), and returns
the result of concatenating them. By passing the arguments by value,
the function forces a and b to be copies of the arguments passed
to the function when it is called. And if these are long strings, it
may mean copying large quantities of data just for the function call.

But this copy can be avoided altogether if both parameters are

made references:
1 string concatenate (string& a, string& b)
2{
3 return a+b;
4}

Arguments by reference do not require a copy. The function operates

directly on (aliases of) the strings passed as arguments, and, at
most, it might mean the transfer of certain pointers to the function.
In this regard, the version of concatenate taking references is
more efficient than the version taking values, since it does not need
to copy expensive-to-copy strings.

On the flip side, functions with reference parameters are generally

perceived as functions that modify the arguments passed, because that
is why reference parameters are actually for.

The solution is for the function to guarantee that its reference

parameters are not going to be modified by this function. This can be
done by qualifying the parameters as constant:
1 string concatenate (const string& a, const string& b)
2{
3
4 return a+b;
}

By qualifying them as const, the function is forbidden to modify the

values of neither a nor b, but can actually access their values as
references (aliases of the arguments), without having to make actual
copies of the strings.

Therefore, const references provide functionality similar to

passing arguments by value, but with an increased efficiency for
parameters of large types. That is why they are extremely popular in
C++ for arguments of compound types. Note though, that for most
fundamental types, there is no noticeable difference in efficiency,
and in some cases, const references may even be less efficient!

Inline functions
Calling a function generally causes a certain overhead (stacking
arguments, jumps, etc...), and thus for very short functions, it may
be more efficient to simply insert the code of the function where it
is called, instead of performing the process of formally calling a
function.

Preceding a function declaration with the inline specifier informs

the compiler that inline expansion is preferred over the usual
function call mechanism for a specific function. This does not change
at all the behavior of a function, but is merely used to suggest the
compiler that the code generated by the function body shall be
inserted at each point the function is called, instead of being
invoked with a regular function call.

For example, the concatenate function above may be declared inline

as:
1 inline string concatenate (const string& a, const string& b)
2{
3
4 return a+b;
}

This informs the compiler that when concatenate is called, the

program prefers the function to be expanded inline, instead of
performing a regular call. inline is only specified in the function
declaration, not when it is called.

Note that most compilers already optimize code to generate inline

functions when they see an opportunity to improve efficiency, even if
not explicitly marked with the inline specifier. Therefore, this
specifier merely indicates the compiler that inline is preferred for
this function, although the compiler is free to not inline it, and
optimize otherwise. In C++, optimization is a task delegated to the
compiler, which is free to generate any code for as long as the
resulting behavior is the one specified by the code.

Default values in parameters

In C++, functions can also have optional parameters, for which no
arguments are required in the call, in such a way that, for example,
a function with three parameters may be called with only two. For
this, the function shall include a default value for its last
parameter, which is used by the function when called with fewer
arguments. For example:
1 // default values in functions#include 6
2 5
3
<iostream>using namespace std;
4 int divide (int a, int b=2)
5{
6 int r;
7 r=a/b;
8
9
return (r);
}
10
11 int main ()
12 {
13 cout << divide (12) << '\n';
14 cout << divide (20,4) << '\n';
15 return 0;
16 }
17

In this example, there are two calls to function divide. In the

first one:
  divide (12)

The call only passes one argument to the function, even though the
function has two parameters. In this case, the function assumes the
second parameter to be 2 (notice the function definition, which
declares its second parameter as int b=2). Therefore, the result is
6.

In the second call:

  divide (20,4)

The call passes two arguments to the function. Therefore, the default
value for b (int b=2) is ignored, and b takes the value passed as
argument, that is 4, yielding a result of 5.

Declaring functions
In C++, identifiers can only be used in expressions once they have
been declared. For example, some variable x cannot be used before
being declared with a statement, such as:
  int x;

The same applies to functions. Functions cannot be called before they

are declared. That is why, in all the previous examples of functions,
the functions were always defined before the main function, which
is the function from where the other functions were called.
If main were defined before the other functions, this would break
the rule that functions shall be declared before being used, and thus
would not compile.

The prototype of a function can be declared without actually defining

the function completely, giving just enough details to allow the
types involved in a function call to be known. Naturally, the
function shall be defined somewhere else, like later in the code. But
at least, once declared like this, it can already be called.

The declaration shall include all types involved (the return type and
the type of its arguments), using the same syntax as used in the
definition of the function, but replacing the body of the function
(the block of statements) with an ending semicolon.

The parameter list does not need to include the parameter names, but
only their types. Parameter names can nevertheless be specified, but
they are optional, and do not need to necessarily match those in the
function definition. For example, a function
called protofunction with two int parameters can be declared with
either of these statements:
1 int protofunction (int first, int second);int protofunction (int,
2
int);
Anyway, including a name for each parameter always improves
legibility of the declaration.
1 // declaring functions prototypes#include Please, enter number (0 to exit):
2 9
3
<iostream>using namespace std;
4 void odd (int x);void even (int x);
It is odd.
5 int main() Please, enter number (0 to exit):
6{ 6
7
int i; It is even.
8 Please, enter number (0 to exit):
9 do {
10 cout << "Please, enter number (0 to 1030
11 exit): "; It is even.
12 cin >> i; Please, enter number (0 to exit):
13 odd (i); 0
14 } while (i!=0); It is even.
15
return 0;
16
}
17
18 void odd (int x)
19 {
20 if ((x%2)!=0) cout << "It is odd.\n";
21 else even (x);
22 }
23
24 void even (int x)
25 {
26 if ((x%2)==0) cout << "It is even.\n";
27 else odd (x);
28 }
29

This example is indeed not an example of efficiency. You can probably

write yourself a version of this program with half the lines of code.
Anyway, this example illustrates how functions can be declared before
its definition:

The following lines:

1 void odd (int a);void even (int a);
2

Declare the prototype of the functions. They already contain all what
is necessary to call them, their name, the types of their argument,
and their return type (void in this case). With these prototype
declarations in place, they can be called before they are entirely
defined, allowing for example, to place the function from where they
are called (main) before the actual definition of these functions.

But declaring functions before being defined is not only useful to

reorganize the order of functions within the code. In some cases,
such as in this particular case, at least one of the declarations is
required, because odd and even are mutually called; there is a
call to even in odd and a call to odd in even. And, therefore,
there is no way to structure the code so that odd is defined
before even, and even before odd.

Recursivity
Recursivity is the property that functions have to be called by
themselves. It is useful for some tasks, such as sorting elements, or
calculating the factorial of numbers. For example, in order to obtain
the factorial of a number (n!) the mathematical formula would be:

n! = n * (n-1) * (n-2) * (n-3) ... * 1

More concretely, 5! (factorial of 5) would be:

5! = 5 * 4 * 3 * 2 * 1 = 120
And a recursive function to calculate this in C++ could be:
1 // factorial calculator#include 9! = 362880
2
3
<iostream>using namespace std;
4 long factorial (long a)
5{
6 if (a > 1)
7
8
return (a * factorial (a-1));
9 else
10 return 1;
11 }
12 int main ()
13 {
14
15 long number = 9;
16 cout << number << "! = " << factorial
17 (number);
18 return 0;
}

Notice how in function factorial we included a call to itself, but

only if the argument passed was greater than 1, since, otherwise, the
function would perform an infinite recursive loop, in which once it
arrived to 0, it would continue multiplying by all the negative
numbers (probably provoking a stack overflow at some point during
runtime