Chapter Summaries

Chapter 1 Summary
* The collection of programs used by a computer is referred to as the
software for that computer. The actual physical machines that make
up a computer installation are referred to as hardware.
* The five main components of a computer are: the input device, the
output device, the central processing unit, the main memory, and the
secondary memory.
* A computer has two kinds of memory: main memory and secondary
memory. Main memory is only used while the program is running.
Secondary memory is used to hold data that will stay in the computer
before and after the program is run.
* A computers main memory is divided into a series of numbered
locations called bytes. The number associated with one of the bytes
is called the address of the byte. Often several of these bytes are
grouped together to form a larger memory location. In that case, the
address of the first byte is used as the address of this larger
memory location.
* A byte consists of eight binary digits, each either zero of one. A
digit that can only be a zero or one is called a bit.
* A compiler is a program that translates a program written in a
high-level language like C++ into a program written in the machine
language which the computer can directly understand and execute.
* A sequence of precise instructions that leads to a solution is
called an algorithm. Algorithms can be written in English or in a
programming language, like C++. However, the word algorithm is
usually used to mean a sequence of instructions written in English.
* Before writing a C++ program, you should design the algorithm that
the program will use.
* Programming errors can be classified into three groups: syntax
errors, run-time errors, and logic errors. The computer will usually
tell you about errors in the first two categories. You must discover
logic errors yourself.
* The individual instructions in a C++ program are called statements.
* A variable in a C++ program can be used to name a number.
* A statement in a C++ program that begins with cout << is an output
statement which tells the computer to output to the screen whatever
follows the <<.
* A statement in a C++ program that begins with cin >> is an input
statement.


*Chapter 2 Summary*
* Use meaningful names for variables.
* Be sure to check that variables are declared to be of the correct
data type.
* Be sure that variables are initialized before the program attempts
to use their value. This can be done when the variable is declared
or with an assignment statement before the variable is first used.
* Use enough parentheses in arithmetic expressions to make the order
of operations clear.
* Always include a prompt line in a program whenever the user is
expected to enter data from the keyboard, and always echo the users
input.
* An if-else-statement allows your program to choose one of two
alternate actions. An if-statement allows your program to decide
whether or not to perform some one particular action.
* A do-while-loop always executes its loop body at least once. in some
situations a while-loop might not execute the body of the loop at
all.
* Almost all number constants in a program should be given meaningful
names that can be used in place of the numbers. This can be done by
using the modifier const in a variable declaration.
* Use an indenting, spacing and line break pattern similar to the
sample programs.
* Insert comments to explain major subsections or any unclear part of
a program.


*Chapter 3 Summary*
* A good plan of attack for designing the algorithm for a program is
to break down the task to be accomplished into a few subtasks, then
decompose each subtask into smaller subtasks, and so forth until the
subtasks are simple enough that they can easily be implemented as
C++ code. This approach is called top-down-design.
* A function that returns a value is like a small program. The
arguments to the function serve as the input to this small program
and the value returned is like the output of the small program.
* When a subtask for a program takes some values as input and produces
a single value as its only result, then that subtask can be
implemented as a function.
* A function should be defined so that it can be used as a black box.
The programmer who uses the function should not need to know any
details about how the function is coded. All the programmer should
need to know is the function prototype and the accompanying comment
that describes the value returned. This rule is sometimes called the
principle of procedural abstraction.
* A variable that is declared in a function definition is said to be
local to the function.
* Global named constants are declared using the const modifier.
Declarations for global named constants are normally placed at the
start of a program after the include directives and before the
function prototypes.
* Call-by-value formal parameters are variables that are local to the
function. Occasionally it is useful to use a formal parameter as a
local variable.
* When you have two or more function definitions for the same function
name, that is called overloading the function name. When you
overload a function name, the function definition must have
different numbers of formal parameters or some formal parameters of
different types.



*Chapter 4 Summary*
* All subtasks in a program can be implemented as functions, either as
functions that return a value or as void-functions.
* A formal parameter is a kind of place holder that is filled in with
a function argument when the function is called. There are two
methods of performing this substitution: call-by-value and
call-by-reference.
* In the call-by-value substitution mechanism, the value of an
argument is substituted for its corresponding formal parameter. In
the call-by-reference substitution mechanism, the argument should be
a variable and the entire variable is substituted for the
corresponding argument.
* The way to indicate a call-by-reference parameter in a function
definition is to attach the ampersand sign & to the type of the
formal parameter.
* An argument corresponding to a call-by-value parameter cannot be
changed by a function call. An argument corresponding to a
call-by-reference parameter can be changed by a function call. If
you want a function to change the value of a variable, then you must
use a call-by-reference parameter.
* A good way to write a function prototype comment is to use a
precondition and a post condition. The precondition states what is
assumed to be true when the function is called. The postcondition
describes the effects of the function call; that is, the
postcondition tells what will be true after the function is executed
in a situation in which the precondition holds.
* Every function should be tested in a program in which every other
function in that program has already been full tested and debugged.
* A driver program is a program that does nothing but test a function.
* A simplified version of a function is called a stub. A stub is used
in place of a function definition that has not yet been tested (or
written) so that the rest of the program can be tested.


*Chapter 5 Summary*
* A stream of type ifstream can be connected to a file with a call to
the member function open. Your program can then take input from that
file./ifstream fin; fin.open(infile.dat);/
* A stream of type ofstream can be connected to a file with a call to
the member function open. Your program can then send output to that
file. /ofstream fout; fout.open(out.dat);/
* You should use the member function fail to check whether a call to
open was successful. /if (fin.fail( ))/ {cout << Fail to open;
exit(1);}
* An object is a variable that has functions associated with it. These
functions are called member functions. A class is a type whose
variables are objects. A stream is an example of an object. The
types ifstream and ofstream are examples of classes.
* The following is the syntax you use when you write a call to a
member function of an object:

/Calling_Object.Member_Function_Name(Argument_List);/

An example with the stream cout as the calling object and precision as
the member function is the following: /cout.precision(2);/

* Stream member functions such as width, setf, and precision can be
used to format output. These output functions work the same for the
stream cout, which is connected to the screen, and for output
streams connected to files.
* A function may have formal parameters of a stream type, but they
must be call-by-reference parameters. They cannot be call-by-value
parameters. The type ifstream can be used for an input-file stream
and the type ofstream can be used for an output-file stream.
* If you use istream (spelled without the f) as the type for an
input stream parameter, then the argument corresponding to that
formal parameter can be either the stream cin or an input-file
stream of type ifstream. If you use ostream (spelled without the
f) as the type of an output stream parameter, then the argument
corresponding to the formal parameter can be either the stream cout
or an output-file stream of type ofstream.
* Every input stream has a member function named get that can be used
to read one character of input. The member function get will not
skip over whitespace. Every output stream also has a member function
named put that can be used to write one character to the output
stream.
* The member function eof can be used to test when a program has
reached the end of an input file. The member function eof works well
for text processing. However, when processing numeric data, you
might prefer to test for the end of a file by using the other
methods we discussed in this chapter. /while (! fin.eof( )) {}/
* Function parameters can have default arguments that provide values
for parameters if the corresponding argument is omitted in the call.
These arguments must follow any parameters that are not provided
default arguments. Calls to such a function must supply arguments
for parameters without default arguments first. Arguments beyond
this are used instead of defaults, up to the number of parameters
the function has.

For example:



/void new_line(istream& instream_par = cin)/

/{/

/ char symbol;/

/ do/

/ {/

/instream_par.get(symbol);/

/ } while (symbol != |n);/

/ }/

/ /

If we call this function as /new_line( );/ the formal
parameter takes the default argument /cin/. If we call this as
/new_line(fin);/ the formal parameter takes the argument provided in the
call /fin/.


* Chapter 7 Summary*
* Boolean expressions are evaluated similar to the way arithmetic
expressions are evaluated
* Most modern compilers have a bool type having the values true and
false. There are still compilers in use that do not implement the
full ANSI Standard C++. With these older compilers, true is
represented as 1 and false is represented as 0.
* You can write a function so that it returns a value of true or
false. A call to such a function can be used as a Boolean expression
in an if-else-statement or anywhere else that a Boolean expression
is permitted.
* One approach to solving a task or subtask is to write down
conditions and corresponding actions that need to be taken under
each condition. This can be implemented in C++ as a multiway
if-else-statement.
* A switch-statement is a good way to implement a menu for the user of
your program.
* Use function calls in multiway branch statements, such as
switch-statements and multiway if-else-statements.
* A block is a compound statement that contains variable declarations.
The variables declared in a block are local to the block. Among
other uses, blocks can be used for the action in one branch of a
multiway branch statement, such as a multiway if-else-statement.
* A for-loop can be used to obtain the equivalent of the instructions
repeat the loop body n times. /for (n = 1; n<= 10; n++)/
* There are four commonly used methods for terminating an input loop:
list headed by size, ask before iterating, list ended with sentinel
value, and running out of input.
* It is usually best to design loops in pseudocode that does not
specify a choice of C++ looping mechanism. Once the algorithm has
been designed, the choice of which C++ loop statement to use is
usually clear.
* One way to simplify your reasoning about nested loops is to make the
loop body a function call.
* Always check loops to be sure that the variables used by the loop
are properly initialized before the loop begins.
* Always check loops to be certain they are not iterated one too many
or one too few times.
* When debugging loops, it helps to trace key variables in the loop
body.
* If a program or algorithm is very difficult to understand or
performs very poorly, do not try to fix it. Instead, throw it away
and start over.


*Chapter 6 Summary*
* A structure can be used to combine data of different types into a
single (compound) data value.
* A class can be used to combine data and functions into a single
(compound) object.
* A member variable or a member function for a class may be either
public or private. If it is public, it can be used outside of the
class. If it is private it can be used only in the definition of
another member function.
* A function may have formal parameters of a class or structure type.
A function may return values of a class or structure type.
* A member function for a class can be overloaded in the same way as
ordinary functions are overloaded.
* A constructor is a member function of a class that is called
automatically when an object of the class is declared. A constructor
must have the same name as the class of which it is a member
* A data type consists of a collection of values together with a set
of basic operations defined on these values.
* A data type is called an abstract data type if a programmer who uses
the type does not need to know any of the details about how the
values and operations for that type are implemented.
* One way to implement an abstract data type in C++ is to define a
class with all member variables private and with the operations
implemented as public member functions.


*Chapter 9 Summary*
* An array can be used to store and manipulate a collection of data
that is all of the same type.
* The indexed variables of an array can be used just like any other
variables of the base type of the array.
* A for-loop is a good way to step through the elements of an array
and perform some program action on each indexed variable.
* The most common programming error made when using arrays is
attempting to access a nonexistent array index. Always check the
first and last iterations of a loop that manipulates an array to
make sure it does not use an index that is illegally small or
illegally large.
* An array formal parameter is neither a call by value parameter nor a
call by reference parameter, but a new kind of parameter. An array
parameter is similar to a call by reference parameter in that any
change that is made to the formal parameter in the body of the
function will be made to the array argument when the function is
called.
* The indexed variables for an array are stored next to each other in
the computers memory so that the array occupies a contiguous
portion of memory. When the array is passed as an argument to a
function, only the address of the first indexed variable is given to
the calling function. Therefore, a function with an array parameter
usually needs another formal parameter of type int to give the size
of the array.
* When using a partially filled array your program needs an additional
variable of type int to keep track of how much of the array is being
used.
* To tell the compiler that an array argument should not be changed by
your function, you can insert the modifier const before the array
parameter for that argument position. An array parameter that is
modified with a const is called a constant array parameter.
* The base type of an array can be a structure or class type. A
structure or class can have an array as a member variable.


*Chapter 10 Summary*
* A cstring variable is the same thing as an array of characters, but
it is used in a slightly different way. A string variable uses the
null character '\0' to mark the end of the string stored in the
array.
* cstring variables usually must be treated like arrays, rather than
simple variables of the kind we used for numbers and single
characters. In particular, you cannot assign a cstring value to a
cstring variable using the equal sign =, and you cannot compare the
values in two cstring variables using the == operator. Instead you
must use special cstring functions to perform these tasks.
* When you define a function that changes the value in a cstring
variable, your function should have an additional int parameter for
the declared size of the cstring variable. That way the function can
check to make sure it does not attempt to place more characters in
the cstring variable than the cstring variable can hold. The
predefined functions in the library with the header file cstring do
not have such a parameter, so extra care must be exercised when
using many of them.
* A very robust input function that will read anything the user types
in must read the input as a string of characters. If numeric input
is desired, the string of digits that is read in will need to be
converted to a number.
* If you need an array with more than one index, you can us a
multidimensional array, which is actually an array of arrays.
* An array of strings can be implemented as a two-dimensional array of
characters.
* The ANSI Standard string library provides a fully featured string
class.


*Chapter 11 Summary*
* A pointer is a memory address, so a pointer provides a way to
indirectly name a variable by naming the address of the variable in
the computer's memory.
* Dynamic variables are variables that are created and destroyed while
a program is running
* Memory for dynamic variables is in a special portion of the
computer's memory called the heap. When a program is finished with a
dynamic variable, the memory used by the dynamic variable an be
returned to the heap for reuse; this is done with a delete statement.
* A dynamic array is an array whose size is determined when the
program is running. A dynamic array is implemented as a dynamic
variable of an array type.
* A destructor is a special kind of member function for a class. A
destructor is called automatically when an object of the class
passes out of scope. The main reason for destructors is to return
memory to the heap so the memory can be reused.
* A copy constructor is a constructor that has a single argument that
is of the same type as the class. If you define a copy constructor
it will be called automatically whenever a function returns a value
of the class type and whenever an argument is plugged in for a call
by value parameter of the class type. Any class that uses pointers
and the operator new should have a copy constructor.