C++ Primer阅读笔记 Chapter 1.Getting Started

Chapter 1.Getting Started

Section 1.1 Writing a Simple C++ Program
The operating system uses the value returned by main to determine whether the program succeeded or failed.
A return value of 0 indicates success.
The main function is special in various ways, the most important of which are that the function must exist
in every C++ program and it is the (only) function that the operating system explicitly calls.
The main function is required to have a return type of int, which is the type that represents integers.
g++: $ g++ prog1.cc -o prog1
cl: C:\directory> cl -GX prog1.cpp

Section 1.2 A First Look at Input/Output
In the case of the input/output operator, the result is the value of its left-hand operand. That is, the
value returned by an input/output operation is the input/output stream itself.
The fact that the operator returns its left-hand operand allows us to chain together input/output requests.
"endl" is a special value, called a manipulator, that when written to an output stream has the effect of
writing a newline to the output and flushing the buffer associated with that device.
Namespaces allow programmers to avoid inadvertent collisions with the same names defined by a library.
When writing a C++ program, in most places that a space appears we could instead use a newline. One exception
to this rule is that spaces inside a string literal cannot be replaced by a newline. Another exception is
that spaces are not allowed inside preprocessor directives.

Section 1.3 A Word About Comments
There are two kinds of comments in C++: single-line and paired.
A single-line comment starts with a double slash (//). Everything to the right of the slashes on the current
line is a comment and ignored by the compiler.
The other delimiter, the comment pair (/* */), is inherited from the C language. Such comments begin with a
/* and end with the next */. The compiler treats everything that falls between the /* and */ as part of the
comment.
Comment pairs can span multiple lines of a program but are not required to do so. When a comment pair does
span multiple lines, it is often a good idea to indicate visually that the inner lines are part of a multi-
line comment. Our style is to begin each line in the comment with an asterisk, thus indicating that the
entire range is part of a multi-line comment.
Comment Pairs Do Not Nest.

Section 1.4 Control Structures
while:

int sum = 0, val = 1;
while (val <= 10) {
    sum += val;
    ++val;
}

for:

int sum = 0;
for (int val = 1; val <= 10; ++val)
    sum += val;

if:

int lower, upper;
if (v1 <= v2) {
    lower = v1;
    upper = v2;
} else {
    lower = v2;
    upper = v1;
}

Operating systems use different values for end-of-file. On Windows systems we enter an end-of-file by typing
a control-z:simultaneously type the "ctrl" key and a "z."
On UNIX systems, including Mac OS-X machines, it is usually control-d.

Section 1.5 Introducing Classes
Headers for the standard library are enclosed in angle brackets (< >). Nonstandard headers are enclosed in
double quotes (" ").
A member function is a function that is defined by a class. Member functions are sometimes referred to as
the methods of the class.
When we call a member function, we (usually) specify the object on which the function will operate. This
syntax uses the dot operator (the "." operator).
To call a function, we follow the function name by the call operator (the "()" operator).

Section 1.6 The C++ Program

Chapter Summary

Defined Terms
argument
A value passed to a function when it is called.

block
Sequence of statements enclosed in curly braces.

buffer
A region of storage used to hold data. IO facilities often store input (or output) in a buffer and read or
write the buffer independently of actions in the program. Output buffers usually must be explicitly flushed
to force the buffer to be written. By default, reading cin flushes cout; cout is also flushed when the
program ends normally.

built-in type
A type, such as int, defined by the language.

cerr
ostream object tied to the standard error, which is often the same stream as the standard output. By default,
writes to cerr are not buffered. Usually used for error messages or other output that is not part of the
normal logic of the program.

cin
istream object used to read from the standard input.

class
C++ mechanism for defining our own data structures. The class is one of the most fundamental features in C++.
Library types, such as istream and ostream, are classes.

class type
A type defined by a class. The name of the type is the class name.

clog
ostream object tied to the standard error. By default, writes to clog are buffered. Usually used to report
information about program execution to a log file.

comments
Program text that is ignored by the compiler. C++ has two kinds of comments: single-line and paired. Single-
line comments start with a //. Everything from the // to the end of the line is a comment. Paired comments
begin with a /* and include all text up to the next */.

condition
An expression that is evaluated as true or false. An arithmetic expression that evaluates to zero is false;
any other value yields true.

cout
ostream object used to write to the standard output. Ordinarily used to write the output of a program.

curly brace
Curly braces delimit blocks. An open curly ({) starts a block; a close curly (}) ends one.

data structure
A logical grouping of data and operations on that data.

edit-compile-debug
The process of getting a program to execute properly.

end-of-file
System-specific marker in a file that indicates that there is no more input in the file.

expression
The smallest unit of computation. An expression consists of one or more operands and usually an operator.
Expressions are evaluated to produce a result. For example, assuming i and j are ints, then i + j is an
arithmetic addition expression and yields the sum of the two int values. Expressions are covered in more
detail in Chapter 5.

for statement
Control statement that provides iterative execution. Often used to step through a data structure or to
repeat a calculation a fixed number of times.

function
A named unit of computation.

function body
Statement block that defines the actions performed by a function.

function name
Name by which a function is known and can be called.

header
A mechanism whereby the definitions of a class or other names may be made available to multiple programs.
A header is included in a program through a #include directive.

if statement
Conditional execution based on the value of a specified condition. If the condition is true, the if body is
executed. If not, control flows to the statement following the else if there is one or to the statement
following the if if there is no else.

iostream
library type providing stream-oriented input and output.

istream
Library type providing stream-oriented input.

library type
A type, such as istream, defined by the standard library.

main function
Function called by the operating system when executing a C++ program. Each program must have one and only
one function named main.

manipulator
Object, such as std::endl, that when read or written "manipulates" the stream itself. Section A.3.1 (p. 825)
covers manipulators in more detail.

member function
Operation defined by a class. Member functions ordinarily are called to operate on a specific object.

method
Synonym for member function.

namespace
Mechanism for putting names defined by a library into a single place. Namespaces help avoid inadvertent name
clashes. The names defined by the C++ library are in the namespace std.

ostream
Library type providing stream-oriented output.

parameter list
Part of the definition of a function. Possibly empty list that specifies what arguments can be used to call
the function.

preprocessor directive
An instruction to the C++ preprocessor. #include is a preprocessor directive. Preprocessor directives must
appear on a single line. We'll learn more about the preprocessor in Section 2.9.2.

return type
Type of the value returned by a function.

source file
Term used to describe a file that contains a C++ program.

standard error
An output stream intended for use for error reporting. Ordinarily, on a windowing operating system, the
standard output and the standard error are tied to the window in which the program is executed.

standard input
The input stream that ordinarily is associated by the operating system with the window in which the program
executes.

standard library
Collection of types and functions that every C++ compiler must support. The library provides a rich set of
capabilities including the types that support IO. C++ programmers tend to talk about "the library," meaning
the entire standard library or about particular parts of the library by referring to a library type. For
example, programmers also refer to the "iostream library," meaning the part of the standard library defined
by the iostream classes.

standard output
The output stream that ordinarily is associated by the operating system with the window in which the program
executes.

statement
The smallest independent unit in a C++ program. It is analogous to a sentence in a natural language.
Statements in C++ generally end in semicolons.

std
Name of the namespace used by the standard library. std::cout indicates that we're using the name cout
defined in the std namespace.

string literal
Sequence of characters enclosed in double quotes.

uninitialized variable
Variable that has no initial value specified. There are no uninitialized variables of class type. Variables
of class type for which no initial value is specified are initialized as specified by the class definition.
You must give a value to an uninitialized variable before attempting to use the variable's value.
Uninitialized variables can be a rich source of bugs.

variable
A named object.

while statement
An iterative control statement that executes the statement that is the while body as long as a specified
condition is true. The body is executed zero or more times, depending on the truth value of the condition.

() operator
The call operator: A pair of parentheses "()" following a function name. The operator causes a function to
be invoked. Arguments to the function may be passed inside the parentheses.

++ operator
Increment operator. Adds one to the operand; ++i is equivalent to i = i+ 1.

+= operator
A compound assignment operator. Adds right-hand operand to the left and stores the result back into the
left-hand operand; a += b is equivalent to a =a + b.

. operator
Dot operator. Takes two operands: the left-hand operand is an object and the right is the name of a member
of that object. The operator fetches that member from the named object.

:: operator
Scope operator. We'll see more about scope in Chapter 2. Among other uses, the scope operator is used to
access names in a namespace. For example, std::cout says to use the name cout from the namespace std.

= operator
Assigns the value of the right-hand operand to the object denoted by the left-hand operand.

<< operator
Output operator. Writes the right-hand operand to the output stream indicated by the left-hand operand:
cout << "hi" writes hi to the standard output. Output operations can be chained together: cout << "hi
<< "bye" writes hibye.

>> operator
Input operator. Reads from the input stream specified by the left-hand operand into the right-hand operand:
cin >> i reads the next value on the standard input into i. Input operations can be chained together: cin >>
i >> j reads first into i and then into j.

== operator
The equality operator. Tests whether the left-hand operand is equal to the right-hand.

!= operator
Assignment operator. Tests whether the left-hand operand is not equal to the right-hand.

<= operator
The less-than-or-equal operator. Tests whether the left-hand operand is less than or equal to the right-hand.

< operator
The less-than operator. Tests whether the left-hand operand is less than the right-hand.

>= operator
Greater-than-or-equal operator. Tests whether the left-hand operand is greater than or equal to the right-hand.

> operator
Greater-than operator. Tests whether the left-hand operand is greater than the right-hand.