Compilers

The essential tools needed to follow these tutorials are a computer

and a compiler tool chain able to compile C++ code and build the
programs to run on it.

C++ is a language that has evolved much over the years, and these
tutorials explain many features added recently to the language.
Therefore, in order to properly follow the tutorials, a recent
compiler is needed. It shall support (even if only partially) the
features introduced by the 2011 standard.

Many compiler vendors support the new features at different degrees.

See the bottom of this page for some compilers that are known to
support the features needed. Some of them are free!

If for some reason, you need to use some older compiler, you can
access an older version.

What is a compiler?
Computers understand only one language and that language consists of
sets of instructions made of ones and zeros. This computer language
is appropriately called machine language.

A single instruction to a computer could look like this:

00000 10011110

A particular computer's machine language program that allows a user

to input two numbers, adds the two numbers together, and displays the
total could include these machine code instructions:

00000 10011110
00001 11110100
00010 10011110
00011 11010100
00100 10111111
00101 00000000

As you can imagine, programming a computer directly in machine

language using only ones and zeros is very tedious and error prone.
To make programming easier, high level languages have been developed.
High level programs also make it easier for programmers to inspect
and understand each other's programs easier.

This is a portion of code written in C++ that accomplishes the exact

same purpose:
1 int a, b, sum;
2
3
cin >> a;
4
5 cin >> b;
6
7 sum = a + b;
cout << sum << endl;

Even if you cannot really understand the code above, you should be
able to appreciate how much easier it will be to program in the C++
language as opposed to machine language.

Because a computer can only understand machine language and humans

wish to write in high level languages high level languages have to be
re-written (translated) into machine language at some point. This is
done by special programs called compilers, interpreters, or
assemblers that are built into the various programming applications.

C++ is designed to be a compiled language, meaning that it is

generally translated into machine language that can be understood
directly by the system, making the generated program highly
efficient. For that, a set of tools are needed, known as the
development toolchain, whose core are a compiler and its linker.

Console programs
Console programs are programs that use text to communicate with the
user and the environment, such as printing text to the screen or
reading input from a keyboard.

Console programs are easy to interact with, and generally have a

predictable behavior that is identical across all platforms. They are
also simple to implement and thus are very useful to learn the basics
of a programming language: The examples in these tutorials are all
console programs.

The way to compile console programs depends on the particular tool

you are using.

The easiest way for beginners to compile C++ programs is by using an

Integrated Development Environment (IDE). An IDE generally integrates
several development tools, including a text editor and tools to
compile programs directly from it.

Here you have instructions on how to compile and run console programs
using different free Integrated Development Interfaces (IDEs):

IDE Platform Console programs

Compile console programs using
Code::blocks Windows/Linux/MacOS
Code::blocks
Visual Studio Compile console programs using VS Express
Windows
Express 2013
Dev-C++ Windows Compile console programs using Dev-C++
If you happen to have a Linux or Mac environment with development
features, you should be able to compile any of the examples directly
from a terminal just by including C++11 flags in the command for the
compiler:

Compiler Platform Command

Linux, among
GCC g++ -std=c++0x example.cpp -o example_program
others...
OS X, among clang++ -std=c++11 -stdlib=libc++ example.cpp -o
Clang
others... example_program

Structure of a program
The best way to learn a programming language is by writing programs.
Typically, the first program beginners write is a program called
"Hello World", which simply prints "Hello World" to your computer
screen. Although it is very simple, it contains all the fundamental
components C++ programs have:
1 // my first program in C++ Hello World!
2
3
4 #include <iostream>
5
6 int main()
7{
std::cout << "Hello World!";
}

The left panel above shows the C++ code for this program. The right
panel shows the result when the program is executed by a computer.
The grey numbers to the left of the panels are line numbers to make
discussing programs and researching errors easier. They are not part
of the program.

Let's examine this program line by line:

Line 1: // my first program in C++

Two slash signs indicate that the rest of the line is a comment
inserted by the programmer but which has no effect on the
behavior of the program. Programmers use them to include short
explanations or observations concerning the code or program. In
this case, it is a brief introductory description of the
program.

Line 2: #include <iostream>

Lines beginning with a hash sign (#) are directives read and
interpreted by what is known as the preprocessor. They are
special lines interpreted before the compilation of the program
 itself begins. In this case, the directive #include
<iostream>, instructs the preprocessor to include a section of
standard C++ code, known as header iostream, that allows to
perform standard input and output operations, such as writing
the output of this program (Hello World) to the screen.

Line 3: A blank line.

Blank lines have no effect on a program. They simply improve
readability of the code.

Line 4: int main ()

This line initiates the declaration of a function. Essentially,
a function is a group of code statements which are given a
name: in this case, this gives the name "main" to the group of
code statements that follow. Functions will be discussed in
detail in a later chapter, but essentially, their definition is
introduced with a succession of a type (int), a name (main) and
a pair of parentheses (()), optionally including parameters.

The function named main is a special function in all C++

programs; it is the function called when the program is run.
The execution of all C++ programs begins with
the main function, regardless of where the function is
actually located within the code.

Lines 5 and 7: { and }

The open brace ({) at line 5 indicates the beginning of main's
function definition, and the closing brace (}) at line 7,
indicates its end. Everything between these braces is the
function's body that defines what happens when main is
called. All functions use braces to indicate the beginning and
end of their definitions.

Line 6: std::cout << "Hello World!";

This line is a C++ statement. A statement is an expression that
can actually produce some effect. It is the meat of a program,
specifying its actual behavior. Statements are executed in the
same order that they appear within a function's body.

This statement has three parts: First, std::cout, which

identifies the standard character output device (usually,
this is the computer screen). Second, the insertion operator
(<<), which indicates that what follows is inserted
into std::cout. Finally, a sentence within quotes ("Hello
world!"), is the content inserted into the standard output.

Notice that the statement ends with a semicolon (;). This

character marks the end of the statement, just as the period
ends a sentence in English. All C++ statements must end with a
 semicolon character. One of the most common syntax errors in C+
+ is forgetting to end a statement with a semicolon.

You may have noticed that not all the lines of this program perform
actions when the code is executed. There is a line containing a
comment (beginning with //). There is a line with a directive for
the preprocessor (beginning with #). There is a line that defines a
function (in this case, the main function). And, finally, a line
with a statements ending with a semicolon (the insertion into cout),
which was within the block delimited by the braces ( { } ) of
the main function.

The program has been structured in different lines and properly

indented, in order to make it easier to understand for the humans
reading it. But C++ does not have strict rules on indentation or on
how to split instructions in different lines. For example, instead of
1 int main ()
2{
3 std::cout << " Hello World!";   Edit & Run
4}

We could have written:

  int main () { std::cout << "Hello World!"; }   Edit & Run

all in a single line, and this would have had exactly the same
meaning as the preceding code.

In C++, the separation between statements is specified with an ending

semicolon (;), with the separation into different lines not mattering
at all for this purpose. Many statements can be written in a single
line, or each statement can be in its own line. The division of code
in different lines serves only to make it more legible and schematic
for the humans that may read it, but has no effect on the actual
behavior of the program.

Now, let's add an additional statement to our first program:

1 // my second program in C++ Hello World! I'm a C++ program
2
3
#include <iostream>
4 int main ()
5{
6 std::cout << "Hello World! ";
7 std::cout << "I'm a C++ program";
8}

In this case, the program performed two insertions

into std::cout in two different statements. Once again, the
separation in different lines of code simply gives greater
readability to the program, since main could have been perfectly
valid defined in this way:
  int main () { std::cout << " Hello World! "; std::cout << "   Edit &
I'm a C++ program "; } Run

The source code could have also been divided into more code lines
instead:
1 int main ()
2{
3 std::cout <<
4 "Hello World!";   Edit & Run
5 std::cout
6 << "I'm a C++ program";
7}

And the result would again have been exactly the same as in the
previous examples.

Preprocessor directives (those that begin by #) are out of this

general rule since they are not statements. They are lines read and
processed by the preprocessor before proper compilation begins.
Preprocessor directives must be specified in their own line and,
because they are not statements, do not have to end with a semicolon
(;).

Comments
As noted above, comments do not affect the operation of the program;
however, they provide an important tool to document directly within
the source code what the program does and how it operates.

C++ supports two ways of commenting code:

1 // line comment/* block comment */
2

The first of them, known as line comment, discards everything from

where the pair of slash signs (//) are found up to the end of that
same line. The second one, known as block comment, discards
everything between the /* characters and the first appearance of
the */ characters, with the possibility of including multiple
lines.

Let's add comments to our second program:

1 /* my second program in C++ Hello World! I'm a C++
 2 with more comments */ program
3
4
#include <iostream>
5 int main ()
6{
7 std::cout << "Hello World! "; // prints Hello
8 World!
9
10 std::cout << "I'm a C++ program"; // prints I'm a
C++ program
}

If comments are included within the source code of a program without

using the comment characters combinations //, /* or */, the
compiler takes them as if they were C++ expressions, most likely
causing the compilation to fail with one, or several, error messages.

Using namespace std

If you have seen C++ code before, you may have seen cout being used
instead of std::cout. Both name the same object: the first one uses
its unqualified name (cout), while the second qualifies it directly
within the namespace std (as std::cout).

cout is part of the standard library, and all the elements in the
standard C++ library are declared within what is called a namespace:
the namespace std.

In order to refer to the elements in the std namespace a program

shall either qualify each and every use of elements of the library
(as we have done by prefixing cout with std::), or introduce
visibility of its components. The most typical way to introduce
visibility of these components is by means of using declarations:
  using namespace std;

The above declaration allows all elements in the std namespace to

be accessed in an unqualified manner (without the std:: prefix).

With this in mind, the last example can be rewritten to make

unqualified uses of cout as:
1 // my second program in C++ Hello World! I'm a C++ program
2
3
#include <iostream>
4 using namespace std;
5 int main ()
6{
7 cout << "Hello World! ";
8 cout << "I'm a C++ program";
9}
Both ways of accessing the elements of the std namespace (explicit
qualification and using declarations) are valid in C++ and produce
the exact same behavior. For simplicity, and to improve readability,
the examples in these tutorials will more often use this latter
approach with using declarations, although note that explicit
qualification is the only way to guarantee that name collisions
never happen.

Namespaces are explained in more detail in a later chapter.