|
|
Hello World! |
// my first program in C++
#include <iostream>
#
) 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.int main ()
int
), a name (main
) and a pair of parentheses (()
), optionally including parameters.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.{
and }
{
) 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.std::cout << "Hello World!";
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.;
). 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.//
). 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.
|
|
|
|
;
), 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.
|
|
Hello World! I'm a C++ program |
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:
|
|
|
|
#
) 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 (;
).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
.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:
|
|
std
namespace to be accessed in an unqualified manner (without the std::
prefix).cout
as:
|
|
Hello World! I'm a C++ program |
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.Previous: Compilers | Index | Next: Variables and types |
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:
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:
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.