Chapter 2 of C++ How to Program, 10/e

 We now introduce C++ programming, which

facilitates a disciplined approach to program
development.
 Most of the C++ programs you’ll study in this book
process data and display results.
 Simple program that prints a line of text (Fig. 2.1).
 // indicates that the remainder of each line is a
comment.
◦ You insert comments to document your programs and to
help other people read and understand them.
◦ Comments are ignored by the C++ compiler and do not
cause any machine-language object code to be generated.
 A comment beginning with // is called a single-line
comment because it terminates at the end of the
current line.
 You also may use comments containing one or more
lines enclosed in /* and */.
 A preprocessing directive is a message to the C++
preprocessor.
 Lines that begin with # are processed by the
preprocessor before the program is compiled.
 #include <iostream> notifies the preprocessor to
include in the program the contents of the
input/output stream header file <iostream>.
◦ This header is a file containing information used by the
compiler when compiling any program that outputs data to
the screen or inputs data from the keyboard using C++-
style stream input/output.
 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.
◦ White-space characters are normally ignored by the
compiler.
 main is a part of every C++ program.
 The parentheses after main indicate that main is a program
building block called a function.
 C++ programs typically consist of one or more functions and
classes.
 Exactly one function in every program must be named main.
 C++ programs begin executing at function main, even if main
is not the first function defined in the program.
 The keyword int to the left of main indicates that main
“returns” an integer (whole number) value.
◦ A keyword is a word in code that is reserved by C++ for a specific
use.
◦ For now, simply include the keyword int to the left of main in each
of your programs.
 A left brace, {, must begin the body of every function.
 A corresponding right brace, }, must end each function’s
body.
 A statement instructs the computer to perform an
action.
 Together, the quotation marks and the characters
between them are called a string, a character string or a
string literal.
 We refer to characters between double quotation marks
simply as strings.
◦ White-space characters in strings are not ignored by the
compiler.
 Most C++ statements end with a semicolon (;), also
known as the statement terminator.
◦ Preprocessing directives (like #include) do not end with a
semicolon.
 Typically, output and input in C++ are accomplished with
streams of data.
 When a cout statement executes, it sends a stream of
characters to the standard output stream object—
std::cout—which is normally “connected” to the screen.
 The std:: before cout is required when we use names that
we’ve brought into the program by the preprocessing
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) also belong to namespace std.
 In the context of an output statement, the <<
operator is referred to as the stream insertion
operator.
◦ The value to the operator’s right, the right
operand, is inserted in the output stream.
 The characters \n are not printed on the screen.
 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.
◦ Causes the cursor to move to the beginning of the next
line on the screen.
 When the return statement is used at the end of
main the value 0 indicates that the program has
terminated successfully.
 According to the C++ standard, if program
execution reaches the end of main without
encountering a return statement, it’s assumed
that the program terminated successfully—exactly
as when the last statement in main is a return
statement with the value 0.
 Welcome to C++! can be printed several ways.
 A single statement can print multiple lines by using
newline characters.
 Each time the \n (newline) escape sequence is
encountered in the output stream, the screen cursor
is positioned to the beginning of the next line.
 To get a blank line in your output, place two newline
characters back to back.
 The next program obtains two integers typed by a
user at the keyboard, computes their sum and
outputs the result using std::cout.
 Figure 2.5 shows the program and sample inputs
and outputs.
 Declarations introduce identifiers into programs.
 The identifiers number1, number2 and sum are the
names of variables.
 A variable is a location in the computer’s memory where
a value can be stored for use by a program.
 Variables number1, number2 and sum are data of type
int, meaning that these variables will hold integers
(whole numbers such as 7, –11, 0 and 31914).
 Lines 8–10 initialize each variable to 0 by placing a value
in braces ({ and }) immediately following the variable’s
name
◦ Known as list initialization
◦ Introduced in C++11
 Previously, these declarations would have been written
as:
◦ int number1 = 0;
◦ int number2 = 0;
◦ int sum = 0;
 All variables must be declared with a name and a data
type before they can be used in a program.
 If more than one name is declared in a declaration (as
shown here), the names are separated by commas (,);
this is referred to as a comma-separated list.
 Data type double is for specifying real numbers, and
data type char for specifying character data.
 Real numbers are numbers with decimal points, such as
3.4, 0.0 and –11.19.
 A char variable may hold only a single lowercase letter,
a single uppercase letter, a single digit or a single special
character (e.g., $ or *).
 Types such as int, double and char are called
fundamental types.
 Fundamental-type names are keywords and therefore
must appear in all lowercase letters.
 Appendix C contains the complete list of fundamental
types.
 A variable name is any valid identifier that is not a
keyword.
 An identifier is a series of characters consisting of
letters, digits and underscores ( _ ) that does not
begin with a digit.
 C++ is case sensitive—uppercase and lowercase
letters are different, so a1 and A1 are different
identifiers.
 Declarations of variables can be placed almost
anywhere in a program, but they must appear before
their corresponding variables are used in the
program.
 A prompt it directs the user to take a specific action.
 A cin statement uses the input stream object cin
(of namespace std) and the stream extraction
operator, >>, to obtain a value from the keyboard.
 Using the stream extraction operator with
std::cin takes character input from the standard
input stream, which is usually the keyboard.
 When the computer executes an input statement that
places a value in an int variable, it waits for the user to
enter a value for variable number1.
 The user responds by typing the number (as characters)
then pressing the Enter key (sometimes called the Return
key) to send the characters to the computer.
 The computer converts the character representation of the
number to an integer and assigns (i.e., copies) this number
(or value) to the variable number1.
 Any subsequent references to number1 in this program
will use this same value.
 Pressing Enter also causes the cursor to move to the
beginning of the next line on the screen.
 In this program, an assignment statement adds the
values of variables number1 and number2 and
assigns the result to variable sum using the
assignment operator =.
◦ Most calculations are performed in assignment
statements.
 The = operator and the + operator are called binary
operators because each has two operands.
 std::endl is a so-called stream manipulator.
 The name endl is an abbreviation for “end line” and
belongs to namespace std.
 The std::endl stream manipulator outputs a
newline, then “flushes the output buffer.”
◦ This simply means that, on some systems where outputs
accumulate in the machine until there are enough to “make
it worthwhile” to display them on the screen, std::endl
forces any accumulated outputs to be displayed at that
moment.
◦ This can be important when the outputs are prompting the
user for an action, such as entering data.
 Using multiple stream insertion operators (<<) in a
single statement is referred to as concatenating,
chaining or cascading stream insertion operations.
 Calculations can also be performed in output
statements.
 Variable names such as number1, number2 and sum
actually correspond to locations in the computer’s
memory.
 Every variable has a name, a type, a size and a value.
 When a value is placed in a memory location, the
value overwrites the previous value in that location;
thus, placing a new value into a memory location is
said to be destructive.
 When a value is read out of a memory loca-tion, the
process is nondestructive.
 Most programs perform arithmetic calculations.
 Figure 2.9 summarizes the C++ arithmetic operators.
 The asterisk (*) indicates multiplication.
 The percent sign (%) is the remainder operator.
◦ Yields the remainder after integer division.
◦ Can be used only with integer operands.
 The arithmetic operators are all binary operators.
 Integer division (i.e., where both the numerator and the
denominator are integers) yields an integer quotient.
◦ Any fractional part in integer division is discarded (i.e.,
truncated)—no rounding occurs.
 Arithmetic expressions in C++ must be entered into
the computer in straight-line form.
 Expressions such as “a divided by b” must be
written as a / b, so that all constants, variables and
operators appear in a straight line.
 Parentheses are used in C++ expressions in the same
manner as in algebraic expressions.
 For example, to multiply a times the quantity b + c
we write
◦ a * ( b + c )
 C++ applies the operators in arithmetic expressions
in a precise sequence determined by the following
rules of operator precedence, which are generally
the same as those followed in algebra.
 There is no arithmetic operator for exponentiation
in C++, so x2 is represented as x * x.
 Figure 2.11 illustrates the order in which the
operators in a second-degree polynomial are
applied.
 As in algebra, it’s acceptable to place redundant
parentheses in an expression to make the
expression clearer.
 The if statement allows a program to take alternative
action based on whether a condition is true or false.
◦ If the condition is true, the statement in the body of the if
statement is executed.
◦ If the condition is false, the body statement is not executed.
 Conditions in if statements can be formed by using the
equality operators and relational operators (Fig. 2.12).
 The relational operators all have the same level of
precedence and associate left to right.
 The equality operators both have the same level of
precedence, which is lower than that of the relational
operators, and associate left to right.
 Fig. 2.12 uses six if statements to compare two
numbers input by the user.
 If the condition in any of these if statements is
satisfied, the output statement associated with that
if statement executes.
 Figure 2.13 shows the program and the
input/output dialogs of three sample executions.
If statement with multiple conditions
If ( value > 5 && value>10 )
The statement refers to a condition in which value is greater than 5 and value
greater than 10. The condition will only executes when the statement is true

If ( value == 5 || value > 15 )

The statement will execute if one or all the conditions hold

 using declarations eliminate the need to repeat the
std:: prefix.
◦ Can write cout instead of std::cout, cin instead of std::cin
and endl instead of std::endl, respectively, in the remainder of
the program.
 Many programmers prefer to use the declaration
using namespace std;
which enables a program to use all the names in any
standard C++ header file (such as <iostream>) that a
program might include.
 From this point forward in the book, we’ll use the
preceding declaration in our programs.
 Each if statement in Fig. 2.13 has a single
statement in its body and each body statement is
indented.
 Each if statement’s body is enclosed in a pair of
braces, { }, creating what’s called a compound
statement or a block that may contain multiple
statements.
 Statements may be split over several lines and may
be spaced according to your preferences.
 It’s a syntax error to split identifiers, strings (such as
"hello") and constants (such as the number 1000)
over several lines.
 Figure 2.14 shows the precedence and associativity
of the operators introduced in this chapter.
 The operators are shown top to bottom in
decreasing order of precedence.
 All these operators, with the exception of the
assignment operator =, associate from left to right.