2.2. First Program in C++: Printing a Line of Text

C++ uses notations that may appear strange to nonprogrammers. We now consider a simple program that prints a line of text (Fig. 2.1).

 1   // Fig. 2.1: fig02_01.cpp
 2   // Text-printing program.
 3   #include <iostream> // allows program to output data to the screen
 4
 5   // function main begins program execution
 6   int main()
 7   {
 8      std::cout << "Welcome to C++!\n"; // display message
 9
10      return 0; // indicate that program ended successfully
11
12   } // end function main

Welcome to C++!

Lines 1 and 2

// Fig. 2.1: fig02_01.cpp
// Text-printing program.

each begin with //, indicating that the remainder of each line is a comment. A comment beginning with // is called a single-line comment because it terminates at the end of the current line. [Note: You also may use C's style in which a comment—possibly containing many lines—begins with /* and ends with */.]

Line 3

#include <iostream> // allows program to output data to the screen

is a preprocessor directive, which is a message to the C++ preprocessor (introduced in Section 1.5). Lines that begin with # are processed by the preprocessor before the program is compiled. This line notifies the preprocessor to include in the program the contents of the input/output stream header file <iostream>. This file must be included for any program that outputs data to the screen or inputs data from the keyboard using C++-style stream input/output. We discuss header files in more detail in Chapter 6, Functions and an Introduction to Recursion, and explain the contents of <iostream> in Chapter 15, Stream Input/Output.

Common Programming Error 2.1

Forgetting to include the <iostream> header file in a program that inputs data from the keyboard or outputs data to the screen causes the compiler to issue an error message, because it cannot recognize references to the stream components (e.g., cout).

Line 4 is simply a blank line. You use blank lines, space characters and tab characters (i.e., "tabs") to make programs easier to read. Together, these characters are known as white space. Whitespace characters are normally ignored by the compiler.

Line 5

// function main begins program execution

is another single-line comment.

Line 6

int main()

is a part of every C++ program. The parentheses after main indicate that main is a function. C++ programs typically consist of one or more functions and classes (as you'll see in Chapter 3). Exactly one function in every program must be main. Figure 2.1 contains only one function. C++ programs begin executing at function main, even if main is not the first function in the program. The keyword int to the left of main indicates that main returns an integer value. The complete list of C++ keywords can be found in Fig. 4.2. You'll see how to create your own functions in Section 3.5. We discuss functions in greater depth in Chapter 6. For now, simply include int to the left of main in each of your programs.

The left brace, {, (line 7) must begin the body of every function. A corresponding right brace, }, (line 12) must end each function's body. Line 8

std::cout << "Welcome to C++!\n"; // display message

prints the string of characters contained between the double quotation marks. White-space characters in strings are not ignored by the compiler.

The entire line 8, including std::cout, the << operator, the string "Welcome to C++!\n" and the semicolon (;), is called a statement. Every C++ statement must end with a semicolon (also known as the statement terminator). Preprocessor directives (like #include) do not end with a semicolon. Output and input in C++ are accomplished with streams of characters. Thus, when the preceding statement is executed, it sends the stream of characters Welcome to C++!\n to the standard output stream object—std::cout—which is normally "connected" to the screen. We discuss std::cout's many features in detail in Chapter 15.

Notice that we placed std:: before cout. This is required when we use names that we've brought into the program by the preprocessor directive #include <iostream>. The notation std::cout specifies that we are using a name, in this case cout, that belongs to "namespace" std. The names cin (the standard input stream) and cerr (the standard error stream)—introduced in Chapter 1—also belong to namespace std. Namespaces are an advanced C++ feature that we discuss in depth in Chapter 22, Other Topics. For now, you should simply remember to include std:: before each mention of cout, cin and cerr in a program. This can be cumbersome—in Fig. 2.9, we introduce the using declaration, which will enable us to omit std:: before each use of a name in the std namespace.

The << operator is referred to as the stream insertion operator. When this program executes, the value to the operator's right, the right operand, is inserted in the output stream. Notice that the operator points in the direction of where the data goes. The right operand's characters normally print exactly as they appear between the double quotes. However, the characters \n are not printed on the screen (Fig. 2.1). The backslash (\) is called an escape character. It indicates that a "special" character is to be output. When a backslash is encountered in a string of characters, the next character is combined with the backslash to form an escape sequence. The escape sequence \n means newline. It causes the cursor to move to the beginning of the next line on the screen. Some common escape sequences are listed in Fig. 2.2.

Common Programming Error 2.2

Omitting the semicolon at the end of a C++ statement is a syntax error. (Again, preprocessor directives do not end in a semicolon.)

Line 10

return 0; // indicate that program ended successfully

is one of several means we'll use to exit a function. When the return statement is used at the end of main, as shown here, the value 0 indicates that the program has terminated successfully. In Chapter 6 we discuss functions in detail, and the reasons for including this statement will become clear. For now, simply include this statement in each program, or the compiler may produce a warning on some systems. The right brace, }, (line 12) indicates the end of function main.

Good Programming Practice 2.1

Many programmers make the last character printed by a function a newline (\n). This ensures that the function will leave the screen cursor positioned at the beginning of a new line. Conventions of this nature encourage software reusability—a key goal in software development.

Good Programming Practice 2.2

Indent the entire body of each function one level within the braces that delimit the body of the function. This makes a program's functional structure stand out and makes the program easier to read.

Good Programming Practice 2.3

Set a convention for the size of indent you prefer, then apply it uniformly. The tab key may be used to create indents, but tab stops may vary. We recommend using either 1/4-inch tab stops or (preferably) three spaces to form a level of indent.