++

Contents
TWO C++ Primer Part II: Object-Based programming 51
2.1 Data Abstraction and Encapsulation 51

2.2 Function Calls and Argument passing 58

2.3 Command-Line Arguments 61

2.4 Environment variables 62

2.5 The string Class 63

2.6 Problem Solving with Objects 65

2.7 C++ I/O streams 70

2.8 Error Handling 70

2.9 Object-Based Thinking 73

2.10 C++ Programming Tips 74

2.11 Summary 77

Exercises 78
 CHAPTER TWO I
C++ Primer
Part II: Object-Based
programming

uBUilding on the basics in Chapter I, an overview of C++ is now presented

with emphasis on introducing classes and objects. Enough is covered so that
you can write interesting and complete programs.
Objects help achieve data abstraction and encapsulation, two impor-
tant software qualities. Classes, specifying both data and functions, serve
as blueprints to build objects. These concepts are introduced and illustrated
by a bank account example. Descriptions of the Standard C++ string objects
further reinforce these ideas.
An object-based program uses classes and objects for problem solving. Tasks
are achieved by employing interacting objects in a solution process. The
methodology is demonstrated by a simple exercise in plane geometry and
a complete program.
Argument passing in function calls is described, covering passing by value
and passing by reference in detail. The inline function feature used to avoid
function call overhead is also shown. The way a C++ program receives argu-
ments from its invoking environment is described. This information helps you
in writing programs that receive arguments and options given to the program
when it is first invoked.
Input and output (I/O) operations are critical for programming. Enough
terminal and file I/O, with built-in C++ I/O objects, are introduced to give
you a good start. Also included are error-handling techniques, source code
formatting suggestions, and effective object-based thinking in C++.

One of the most central features of OOP is the division of the whole program
into smaller autonomous entities, called objects, with well-defined interactions.
This feature significantly reduces overall complexity and enhances the quality
of the program in many different ways. An object organizes data and related
operations into a black box, which hides the internal data structures, represen-
tations, and procedures from outside view. A data structure is concrete when
its exact details are fixed and exposed. Traditional programming approaches
depend heavily on concrete data. OOP, on the other hand, emphasizes data ab-
straction and encourages hiding the details of data by presenting only the data's
behavior. For example, if you do not know the details of car construction, you
can still drive one effectively if you know behavior such as "steering clockwise
makes the car turn right." This leaves the implementation of steering to the
black box, which can use one of several alternatives: regular, power-assisted,
rack-and-pinion, and so on. In addition to structures, the object also contains
mechanisms, or procedures, that are necessary to operate the structures. These
procedures are attached to the structures to form one inseparable unit. This
technique is called encapsulation.

The C++ class construct supports data abstraction and encapsulation. A class
describes the construction of an object and serves as a blueprint to build objects.
It specifies the internal workings as well as the external interface of an object. A
class has a name, or tag, and specifies members belonging to the class that may
be data, functions, or objects. Once a class is defined, the class name becomes
a new data type and is used to declare variables of that type. A class-type
variable is an instance of a class and is called an object of that class.
Tobegin, let's consider a simplified class representing bank accounts:

class Account
public:
Account() ; II constructor (1)
Account (unsigned n, double b); II constructor (2)
void deposit (double amt); II deposit amt into this account
bool withdraw(double amt); II withdraw amt from this account
double balance(); II balance inquiry
unsigned id(); II get account number
1* other public members *1
private:
unsigned acct_no; II account number
double acct_bal; II current balance
1* other private members *1
Class names should appear as capitalized nouns, which is the style recom-
mended and followed in this book. Here the class Account is declared following
the general form:
class Name
{

If you are new to C++, you may sometimes forget the final semicolon in a class
declaration. This can cause many unpleasant errors. One way to remember the
semicolon is to type in the form class Name { } i before entering the class
body, which in itself can be very involved.
The class body consists of declarations for data members, function mem-
bers, or both. Member declarations are supplied in the usual way-namely,
with declarations and function prototypes. However, no initializers are allowed
for data member declarations. Except for overloading, all members must have
distinct names. The class Account contains the data members
unsigned acct_noi II account number
double acct_bali II current balance

which are the identification number and current balance of a bank account.
Function prototypes in a class definition specify member functions of the class.
For example,
void deposit(double amt) i
declares deposi t to be a member function. The actual code for member func-
tions usually resides in a separate implementation file.

Once a class is declared, objects of the class can be created. A class is a blueprint
to build objects of a particular type (Figure 2.1), and the objects are known as
instances of the class. The class name becomes a type name and can be used to
declare variables. A class-type variable is an object of that class.
For example, objects of type Account can be defined as follows:
Account susan(5551234, 600.0) i II object susan (3)
Account jack; II object jack (4)
The variable susan is an Account object with the given account number and a
beginning balance of 600. The initialization of this object is through the Account
constructor.
In class Account, the Account member (line 1) is special. In general, a
member function with the same name as the class itself is called a constructor
 ~
class --------;> Account
Account objects

and is treated differently from other member functions. The purpose of a

constructor is to perform initializations when an object is created. For example,
the statement on line 3 allocates space for an Account object and passes the
values in parentheses to the constructor:

The result is an object represented by the variable susan. The constructor is

defined as

public Account: :Account(unsigned id, double amt) II constructor

{ acct_no = id;
if ( amt > a ) acct_bal = amt;
else acct_bal = 0.0;

which provides the desired initialization of the data members acct_no and
acct_bal. No return type of any kind is allowed in declaring a constructor,
which should never return a value. Note that the constructor function name
Account is qualified by Account: : to attach the name to the Account class as a
member. More will be said on this presently.
The variable jack is an object initialized by the constructor that takes no
arguments.
 An object can be thought of as an independent computing agent (a tiny com-
puter) with its own storage and instruction set. The data members define the
storage, and the function members provide the instruction set.
The C++ class construct also specifies access control to its members. In
the class definition, members are sectioned into groups to achieve information
hiding:

• Public members in a class can be accessed from anywhere in a program.

• Private members in a class can be accessed only by member functions of
the same class.
All a user, or client, of a class needs to know is the public interface (Figure 2.2).
As long as the public members are well documented, there is no need to know
any implementation details. In the case of deposit, all that matters is putting
a given amount, amt, into the account. Thus, knowledge of internal details is
confined to member functions. The class Account is thus an abstract data type.
An object embodies the abstract data item. Values stored in an object
constitute its internal state, and public members of an object form its interface
to the outside (other functions and objects). Thereby, an object encapsulates
(envelops) a set of data and function members. The encapsulating object is
called the host object of its members. Many objects can be created from a class.
Although all members-function or data-are thought of as contained
within each individual object, C++ achieves this effect without having to repli-
cate the member functions. The memory required for each object is essentially
for storing the data members.
The Account data members acct_no and acct_bal are pri vate, so their ac-
cess is limited to member functions such as id () and balance (). No operations

Message

~
other than those specifically provided by the Account class can be performed on
these private quantities. In designing a class, you, the 00 programmer, must
design the public/private grouping to support effective use and to maximize
information hiding.

We already know that not every member of an object is accessible from the
outside. When permitted, the members of an object are accessed with the dot
( .), or member-of operator. For example,

susan.deposit(25.60); II deposit into Account object susan

double bal = susan.balance();
II retrieve balance of Account object susan
susan.withdraw(25.0) ; II take 25 out of Account object susan
from.acct_bal -= 30.50; II decrease balance of from account (A)
to.acct_bal += 30.50; II increase balance of to account (B)

Because acct_bal is a private member, the assignments on lines A and B can

be used only by member functions of Account.
Clearly, the general syntax to access a member in a host object is

object .member (member access syntax)

Pointers to class objects are also very useful. For example, the pointer variable
acnt-ptr

is initialized to point to the Account object jack. But it can also be assigned
another value:

When you are dealing with a pointer to an object, the members can be accessed
directly through the pointer with the -> operator:

objptr -> member (member access via pointer)

Generally, a class declaration is kept in a header file, which can be included by
any file that wishes to use objects of the class. For example, the declaration for
Account can be put in the header file Account. h. Member functions of a given
class are usually defined in a separate implementation file, with a file name
ending in .C (or .CPp).For instance, the Account. Cfile begins with
IIIIIII Account.C
#include "Account.h"

void Account: :deposit(double amt)

{ if ( amt > 0 )
acct_bal += amt;

is used for a header file written by a user (Section 14.3).

The notation Account: :deposit puts the name deposit within the scope
(Section 3.1) of the class Account, making it a member function. The double
colon (: :) is the scope operator. If Account: : is not placed in front of the function
name, then it is just a regular (unattached) function, not a member of class
Account.
Note that deposi t () takes only one argument, the amt to be deposited.
There is no mention of the target account to make the deposit. As a member
function, depos i t is always attached to a specific account when it is called. In
OOP, member functions are not pure procedures, but procedures attached to
an object, such as an accelerator to a car. There is never a need to worry about
which car you are driving when you depress the accelerator. Because objects
are known as instances of a class, members in an object are known as instance
members. Thus, deposi t () is an instance function. Input to an instance function
consists of its arguments and the state of its host object (Figure 2.3). To emphasize
the point, some OOP literature refers to instance functions as methods and to
invoking such functions as passing a message to an object. You should be aware
of such widely understood OOP terms, even though these particular phrases
are used only occasionally in the C++ context.
Because deposi t is an instance function, it can access other members in the
host object (e.g., acct_bal) directly, without using the obj ect .member notation.
All members in a class are accessible by member functions.
 ">..
Arguments • Function \
l
• Results

t
State
;"f
\

Host Object A7

A function is either unattached or encapsulated in a class. The function header

specifies the number and type offormal parameters required. In C++, a function
is identified not only by its name but also by its formal parameter list. Thus,
the same function name may be defined more than once with different formal
parameters. This is known as junction overloading (Section 3.7).
When a function is called, the correct number and type of arguments must
be supplied. The arguments in the function call are known as the actual argu-
ments, or simply arguments. The definition of factorial has a formal parameter
n. In the function call factorial (j), the variable j becomes the actual argu-
ment. When a function call is executed, the data or objects referenced by the
actual arguments are bound to the formal parameters and can be used in the
body of the function. This binding is called argument passing.
When a function with more than one argument is called, there is no guarantee
of the order in which arguments are evaluated. Therefore, no code should depend
on any specific order of argument evaluation. Thus, the function call

is wrong because the result depends on which of the two arguments is evalu-
ated first. You should use instead something like this:

ittj
power(i-l, i)i

Parameters in a function header are formal in the sense that any name
can be used for them without changing the meaning of the function. The same
situation is found in mathematics where the notations f (x) = x2 and f (y) = y2
define the same function.
 Formal parameters are local to a function. When a function call is made, a
copy of the value of the actual argument is passed to the corresponding formal
parameter. In other words, arguments are passed by value. With pass by value,
a function can work only on copies of arguments, not on the actual arguments
themselves. Therefore, the actual arguments have the same values before and
after the function call.
When necessary, it is possible to modify data in the calling function. One
way is by passing pointers as actual arguments. Recall that a pointer is the
memory location, or address, of an object or a piece of data. Once the called
function gets the address, it can proceed to modify information stored at that
address. As a result, data in the calling function are altered indirectly.
Unlike basic data types and objects, there is no automatic copying of the
elements in an array when it is passed as an argument. Instead, the address
of its first element is passed. (This is the value of the array name.) Therefore,
the formal array parameter becomes another name by which the same array
elements can be accessed.

Pass by value can be expensive if the arguments represent large data objects.
Pass by reference is a way to pass arguments without copying. C++ supports
reference formal parameters for functions. A reference parameter is an alias for
the actual argument passed (without copying) in a function call. An assignment
to a reference parameter assigns a value to the corresponding actual argument.
A reference parameter is used most often for the following purposes:

1. To pass an argument without making a copy of it (which is more

efficient than pass by value).
2. To allow the called function to modify the actual argument.
3. To collect data produced by the called function.

You declare a reference parameter in a function header by putting the &

character after the type name and in front of the parameter name. For example,
the function

void swap(int& a, int& b)

{ int tmp = bi
b ai
a = tmpi
uses two int reference parameters, a and b, to interchange the values of its
actual arguments. In general, the &before a parameter declares a reference and
is not to be confused with the address-of operator used in expressions. The line

may look a little suspicious at first because tmpis of type int but b is of type
int&. It simply means that tmpgets the value of the actual argument represented
by the int reference b. Thus, the following code works:
int r = 7, s = 11;
swap(r, s); / / now r is 11 and s is 7
The values are switched because a and b are reference parameters that become
aliases for rand s, respectively, when swapis called. In other words, the effect
of the call swap(r , s) is
int tmp = s;
s = r;
r = tmp;
Also recall the std: :cin. get (c) usage. It works because std: :cin. get takes a
reference parameter (char& c). A reference parameter is one form of the C++
reference, a feature explained in Section 3.8.

The C++ coding style sometimes calls for defining many small functions that
are very simple. For such small functions, function call overhead (i.e., the
argument-passing and the value-returning activities associated with a func-
tion call) becomes significant compared to the amount of time spent in the
called function. To reduce this overhead and to increase code efficiency,C++
allows you to declare functions inline. For example,
inline int MAX(inta, int b)
{ return (a > b ? a : b); }
inline double ABS(double a}
{ return (a > 0 ? a : -a); }
A call to an inline function is expanded by the compiler so that the effective
code is substituted at the place of call, and run-time function call overhead
is avoided. An inline specifier advises the compiler to make an inline ex-
pansion if possible. An implementation may expand only inline functions
containing straight-line code with only a few statements. Usually, no condi-
tionals (if), loops (while, for), or other branching statements are allowed. In
most situations, these limitations coincide with good programming practices.
Furthermore, a class member function completely defined inside the class dec-
laration (Section 2.6) is automatically declared inline.
To expand a function inline, the compiler must have seen the function
definition when compiling a file. This is usually done by including a header
file where the definition of the inline function has been placed.

The main function is special in C++ because it marks the starting point for pro-
gram execution and is not called by other functions in the program. However,
it is possible to supply arguments to a C++ program when it is invoked. The
command-line arguments are passed as character strings to the function main.
A main function expecting arguments is normally declared as follows:

int main(int argc, char *argv[])

The parameter argc is an integer. The notation

char *argv [ ]

declares the formal array parameter argv as having elements of type char *
(character pointer). In other words, each ofthe arguments argv [0], argv [l], ... ,
argv[argc-lj is a character pointer. The meanings of the formal arguments
argc and argv are as follows:
argc The number of command-line arguments, including command name
argv [n] A pointer to the nth command-line argument as a character string

If the command name is cmd and it is invoked as

coo argl arg2

then
argc Is 3
argv[O] Points to the command name coo
argv[l] Points to the string argl
argv[2] Points to the string arg2
argv[3] Is 0 (NULL)
The parameters for the function main can be omitted if they are not needed.
Now let's consider a program that receives command-line arguments. To
keep it simple, all the program does is echo the command-line arguments to
standard output:

IIIIIII the echo command IIIIIII

#include <iostream>
int main(int argc, char *argv[] )
{ int i = li II begin with 1
while (i < argc)
std: :cout « argv[i++] II output string
« II output SPACE
« II terminate output line
return Oi

The program displays each entry of argv except argv [0]. To separate the
strings, the program displays a SPACE after each argv [i] , and the last argument
is followed by the proper end of line.
Note that main is declared to return an int, and the last statement of main is

The return value of main indicates, to the invoker of the program, whether
the program executed successfully and terminated normally. This value is re-
ferred to as the exit status. For example, on UNIX systems, a zero exit status
indicates successful or normal execution of the program, whereas a nonzero
(usually positive) exit status indicates abnormal termination. Thus, it is ad-
visable always to use a return statement in the main program, even though it
works without one.

The parameters argc and argv of a main program reference the explicit argu-
ments given on the command line (Section 2.3). Every time a program runs,
another array of strings representing the user environment, called the environ-
ment list, is also passed to the program. This provides a way, in addition to the
command-line arguments, to pass information to a program.
The environment list is always available in the system-defined global
variable

HOME=/users/fac/pwang (UNIX)
PATH=/usr/local/bin:/usr/local:/usr/ucb:/bin:/usr/bin:. (UNIX)
TERM=vt200 (UNIX)
PATH=C:\iC:\NETMANAGiC:\JDK1.2\BINiC:\TOOLS\VIM46W32\VIM-4.6(Windows)
The first three examples are from UNIX and the fourth is from Windows. The
final element of the environ array is a zero pointer (NULL)
to mark the end.
 To access environ, include the header <stdlib. c>.Although direct search
of environ is possible, it is simpler to access environment values with the
Standard Library function getenv:
char *getenv(char * varName)
This function searches the environment list for a string whose name part
matches the varNamegiven and returns a pointer to the value part. If no match
is found, then varName is not an environment variable and NULL is returned.
The function getenv makes it easy to retrieve environmental values. For
example
#include <stdlib.h>

char* uname = getenv ("PATH"

); II obtain commandpath
char* tname getenv ("TERM") ; II obtain terminal name

2.5 THE string CLASS

Account showed how a class is defined and used. Standard C++ provides many
useful classes as part of the language. You'll get to know many of them as you
make progress. One such class is string, in the.std namespace, which makes
operations on character strings easier and less error prone. Before string was
introduced, the only way to represent a character string in C++ was the C-style
string-an array of characters terminated by the '\0' character. Now you may
find the string class a better choice in many situations.
To use the string class, you need to include the C++ header
#include <string>
To create a string object, simply use
std: :string stLobj( c_str );
where c_str is a C-style string. For example,
std:: string strl ("Happy Birthday\n") ;
As an application, let's rewrite the stringMatch function (Section 1.15) using
string objects.
int stringMatch(std::string& str, std: :string& line) II (1)
if ( str.empty() ) return -1; II (2)
int j, k;
int sl= str.size(), 11 = line.size(); II string length (3)
for (int i = 0 ; i < 11 ; i++)
{ if ( line[i] != str[O]) II first chars different (4)
 continue; II skip rest of loop body
II compare remaining characters
II until first mismatch or end of string
for ( j = i + 1, k = 1;
line[j)==str[k) &&k < sl; II (5)
j++, k++
) { }
if (k sl return i; II successful match
else
if (j -- 11) return -1; II no match possible anymore

The str ingMatch function looks for str in 1ine and returns the starting position
in line if a match is found. Otherwise, -1 is returned. It receives string objects
as references (line I), checks if str is empty (line 2), obtains the length of the
given strings (line 3), and compares characters (lines 4 and 5) to do the job.
You can use subscripts to access individual characters in a string object.
For example, the function

void downcase(std: :string& st)

{ int len = st.size();
for (int i=O; i < size; iff)
st[i) = tolower(st[i));

changes all uppercase characters in the argument string to lowercase.

You can also concatenate strings using the + operator:
string s3 = sl + s2; (appends sl and s2)

where sl is a string object and s2 is a string object or C-style string. The string
s3 is s2 appended to sl while sl and s2 remain unmodified. Tomodify sl, use

str.compare(any_str) (compares strings)

str.compare(iO, n, any_str) (compares substrings)
to compare the host str to any_str (C-style or string object), starting from
index i 0for n characters, if the first two args are given, or the entire string. The
result is positive, negative, or zero indicating str is bigger than, less than, or
equal to any_str in alphabetical order. See Section 6.3 for other useful member
functions of the string class.
 The Standard Library function call
get line (istream& in, string& sty-obj, char eol) (reads line into string)
reads from the istream object in into the string object sty-obj until either the
given end-of-line character eol (usually' \n ,) or the end of file is encountered.
If the third argument eol is not given, then it is assumed to be \n If the input
I I.

length exceeds str .max_size (), the read operation fails (Section 2.7).
Section 2.8 contains a complete example that uses stringMatch ().

One important purpose of OOP is to solve problems better by using objects.

To illustrate what this means in a simple way, let's consider a problem from
plane geometry: Given four vertices A, B, C, and D in the x-y plane, determine
whether ABC D is a rectangle.
Clearly, one direct way to make the determination is to decide whether
the neighboring sides of ABC D are all mutually perpendicular. An ad hoc
procedure could be written for this purpose, and the problem would be solved.
But this is the traditional procedure-oriented approach.
The 00 approach first identifies the interacting objects in the problem do-
main. Here the objects are the vertices and the sides. The sides are determined
by the vertices, and the orthogonal properties of neighboring sides lead to the
solution. Further analysis leads us to the identification of a two-dimensional
vector as the object needed because it can represent a vertex or a side. Thus,
for the 00 solution of the given problem, a Vector2D class is first established.

Vectors in two-dimensional space are familiar geometric objects. A vector v

has an x component and a y component:

Vectors also have well-defined arithmetic and other kinds of operations. A

class Vector2D is defined to model two-dimensional vectors:

class Vector2D
{ public:
Vector2D() {} II no-args constructor
Vector2D(float a, float b) I I inline (1)
{ x = a; y = b; }
 Vector2D difference (Vector2D&a);
float inner(Vector2D& a);
bool isPerpendicular(Vector2D& a);
bool nonzero() II inline (2)
{ return ( x ! = O. 0 II y ! = O. 0 ); }
void display();
1* other members not shown *1
private:
float x, y;

They represent the x- and y-direction components of a vector. There is a no-

args constructor and a constructor that initializes both vector components
(line 1). The overloaded constructors and the member function nonzero (line 2)
are defined completely in the Vector2D class declaration rather than merely
being declared with a function prototype. Functions included in this way are
automatically inline (Section 2.2).

The Vector2D constructor is overloaded as constructors usually are. One ver-

sion takes two arguments and initializes the data members x and y. The other
takes no arguments and does nothing. A constructor that takes no arguments
must be present to allow the usage

where no initialization is intended. The no-args constructor is referred to as

the default constructor. Two points can be made about supplying default con-
structors:

1. If a class defines no constructor at all, a default constructor that does

nothing is supplied automatically.
2. If a class defines any constructor, no default constructor is
automatically supplied. This is fine if the default constructor is not
needed. However, if it is needed, an appropriate one must be given
explicitly.
to declare u as an object. This code instead declares u as a function returning a
Vector2Dvalue.

Let's turn our attention to the other member functions of Vector2D.The mem-
ber function inner
float inner(Vector2D a) ;
receives a Vector2Dobject argument and returns a float value. The actual code
for inner is defined in the file Vector2D. c:
111/1111 Vector2D.C IIIIIIIIII
#include <iostream>
#include "Vector2D.h"

float Vector2D: :inner (Vector2D&a)

{ return(x * a.x + y * a.y); }
Again, because inner is a member function, it is allowed to access the private
members x, y (in the host object) and a. x, a. y (in object a). Usually, data and
function members can be accessed only through an established object of the
class. For example,
Vector2D u(2.0, 3.0), v(4.0, 5.0);
u. inner (v) i
computes the inner product of the vectors u (host object of inner) and v (argu-
ment to inner). Here the Vector2D v is passed to the member function inner
of the object u. Because the data in the host object (u in this case) are already
available, inner requires only one argument.
An object ought to know how to display itself. This can usually be done
by defining a member function display. For Vector2D,it can be
void Vector2D: :display()
{ std: :cout « "(" « x « "
« y « ") "i

The Vector2D member function difference subtracts the given Vector2D

object v from the host object and returns their difference as a Vector2D object.
Vector2D Vector2D: :difference (Vector2D&v)
{ Vector2D tmp;
 tmp.x = x - V.Xi
tmp.y = y - V.Yi
return tmpi

Another member function determines if a given vector v is perpendicular

to the host object:

inline float ABS(float x)

{ return (x > 0 ? x : -x) i }

bool Vector2D::isPerpendicular(Vector2D& v)
return ( nonzero() &&v.nonzero()
&& ABS(inner(v)) < 0.00000001 ) i

It makes sure both vectors are nonzero and their inner product is zero, up to a
tolerance. Note that both difference and isPerpendicular take an argument
passed by reference.

Now that we have the Vector2D. hand Vector2D. C files in place, we can con-
struct a solution for the rectangle problem that makes use of Vector2D objects.
The approach is simple:

1. Represent the given vertices A, B, C, and D as four Vector2D objects.

2. Subtract neighboring vertices (2D vectors) to get the sides that are
again 2D vectors.
3. Determine perpendicularity of neighboring sides..:-- __
.._ .._------~ --------~
Using Vector2D objects, our task is reduced to reading the four vertices
from the user and testing whether the neighboring sides (as 2D vectors) are all
perpendicular. Each point is read from user input into a vector by getVec:

IIIIIII rectangle.C
#include <iostream>
#include nVector2D.hn

Vector2D getVec(int i) II input a point as vector

float X,Yi
n_ n.,
std: :cout « X « II ll
i «
std: :cin » Xi
n_ n.
std::cout « y « lI 11
i « ,
std::cin » Yi
The getVec function actually creates a new Vector2D object by making an
explicit constructor call. The main program looks like this:

int main()
{ std: :cout « "Enter vertices 0,1,2,3 "
« std: :endl;
Vector2D p[4] ; II vector array (A)
for ( int i = 0; i < 4; itt) II input all four points
p[i] = getVec(i);
Vector2D u = prO] .difference(p[3]);
Vector2D v;
for (int i = 0; i < 3; itt) II process all sides
{ v = p[it1] .difference(p[i]); II vector difference (C)
if ( ! u. isPerpendicular (v) ) II check perpendicularity
{ std::cout« "No, not a rectangle." «std::endl;
return 1;

}
std: :cout « "Yes, a rectangle." « std: :endl;
return 0;

After the coordinates for the four vertices are read (in sequence), four vectors
are in the array p [4] whose declaration (line A) invokes the Vector2Ddefault
constructor four times. A 20 vector u representing one side of the quadrilateral
is then calculated by vector subtraction (line B).A second Vector2Dobject v is
made for an adjacent side (line C). The perpendicularity of u and v is checked.
After all sides are checked, the right conclusion can be made.
Assuming the file Vector2D. 0 has already been produced, compile
rectangle. Cwith Vector2D. 0 and run the program.
The ability to work with vectors that correspond to real geometric objects
allows the solution to be stated simply and elegantly with geometric concepts
and also makes it much easier to explain and understand. More important, the
Vector2Dclass can help in many other situations in plane geometry. Hence, the
class has potential for reuse.
Furthermore, the object-based solution is easily adaptable to changes in
the problem specification. For instance, determining whether ABC D is a par-
allelogram involves almost no change to the program. Youjust add a member
iSParallel (Vector2D&b) to the Vector2Dclass if it is not already there.
Section 1.7 mentioned cin, cout, and cerr-three ready-made objects for I/O
in each program. These objects are instances of the I/O stream classes that are
part of the C++ Standard Library. Toavoid global name conflicts, the Standard
Library classes and objects are placed in a separate namespace std, which is
the reason we use the prefix in std: :coutoWehave also seen the use of cin. get
and cout.put for character I/O.
While these standard objects take care of terminal I/O, there are occasions
when you want direct I/O from or to a specific file. This can be done by setting
up new I/O objects connected to the desired files. The declarations
#include <iostream>
#include <fstream>

std: :ifstream in (infile) j II input from file

std: :of stream out (outfile) j II output to file
are used to establish objects for file I/O. The file names are C-style strings.
From your knowledge of c++ classes, you can deduce that the ifstream
and of stream classes have constructors supporting the declarations of in and
out. If outfile is a new file, it will be created. Otherwise, its contents will be
replaced. Once established, these file I/O objects are used in much the same
way as cin and couto Open files are automatically closed when your program
terminates. An open file can also be specifically closed by calling the member
function close:
in.close() j

out.close() j

in.eof () II true or false

in. fail () II true or false
to test if the stream has reached the end of file or has failed.
For an example involving file I/O, see Section 2.8. Other input/output
functions provided by the Standard Library are discussed in Section 6.7.

A very important aspect of programming concerns the handling of possible

errors during the execution of a program. Many kinds of errors can occur at run
time. The main program may be invoked with incorrect arguments. A function
expecting a positive argument may be passed a negative value. Arithmetic
operations can overflow or underflow. A well-written program should detect
errors and take appropriate actions.

The main program should first check the arguments supplied on the command
line for correctness. If the arguments are unacceptable, a clear message should
be displayed stating the nature of the error and its cause (if known). Use
the object cerr for sending error messages to ensure that they appear on the
terminal immediately without buffering. A conditional statement such as

if (argc != 3)
{ std: :cerr « argv[O] « ": expects 2 arguments but was given"
« argc-l « std: :endl;
std: :cerr « "Usage" « argv[Oj « " input-file output-file";
« s td: :end1;

checks the number of command-line arguments supplied. Note that the value
of argc is, by definition, the number of command-line arguments plus 1. Al-
ways identify the program unit or subunit displaying the error message. The
command name identifies which program is announcing the error. When ap-
propriate, a function name further narrows down the error location. In this
example, the program refers to its own name as argv [0], which is better than
assuming a specific file name.
After displaying an error message, a program may continue to execute,
return a particular value not produced normally, or elect to abort. The Standard
Library function exit is called to terminate the execution of a program:

When exit is called anywhere in a program, program execution is terminated.

For normal termination, status should be a (or EXIT_SUCCESS). For abnormal
termination such as an error, a positive status, usually 1 (or EXIT]AILURE),is
used. To use exit, you should include the header file <stdlib.h>. The library
function abort () can be called, and it produces a core dump file for postmortem
analysis before exiting.
File I/O objects maintain internal error states that can be checked for any
failure. For example, after the code
if ( in.fail() )
{ std: :cerr « "Can't open" « file
« std: :end1;

The ifstream class (Section 6.7) member function fail () returns true if the
file failed to open. The same usage applies for an of stream object.

Let's put the stringMatch function (Section1.15)to use together with appropri-
ate 1/0 and error handling. The intention is to define a stringSearch command
that works with standard I/O when given no arguments or with specific I/O
files.

1111111 stringSearch.C
#include <iostream>
#include <string>
#include <fstream>
#include <stdlib.h>

void match(std: :string& str, std: :istream& in, std: :ostream& out)
{ if ( str.empty() ) II str is empty
{ std: :cerr « "match: empty match string"
« std: :endl;

}
string line;
while ( std: :getline(in, line, '\n') ) I I (a)
{ if ( stringMatch(str, line) > 0 ) II (b)
out « line « std::endl; II (c)
}
out. flush () ;

The function match searches (line b) for str in each line from the given in-
put stream in (line a) and outputs any matching lines to the output stream
out (line c). Note that reference parameters are used. Failure to use reference
parameters for I/O objects can prove unwise in most situations.
int main (int argc, char* argv[])
{ if ( argc < 2 I I argc > 4 )
 std: :cerr « "Usage:" « argv[O]
« " str [infile [outfile]]" « std: :endl;

}
std: :string str(argv[l]);
if ( argc == 2 ) II use standard 1/0
match(str, std: :cin, std::cout);
else II use file
{ ifstream infile(argv[2]);
if (infile.fail() ) II (2)
std: :cerr « argv[O] « ":can't open input file"
« argv[2] « std: :endl;
return 1;
}
if ( argc == 3 )
match(str, infile, std::cout);
else II argc == 4
{ of stream ofile(argv[3]);
if ( ofile.fail() ) II (3)
{ std: :cerr « argv[O] « ":can't open output file"
« argv[3] « std: :endl;
exit (1) ;
}
match(str, infile, ofile);

The main program of stringSearch. Canticipates common errors: wrong num-

ber of arguments (line 1), failure to open the input file (line 2), and inability to
open the output file (line 3). In the first case, a brief guide to command usage is
displayed. Run this program on files and check your results against the UNIX
grep command if available.

The traditional approach to program design involves breaking down a given

problem into a number of steps. Each step is either simple and straightforward
or may have to be broken down further. The sequence of steps forms a proce-
dure that solves the given problem. This approach is known as procedure-based
decomposition.
An 00 program establishes objects, and these objects cooperate and in-
teract to solve a problem. Thus, object orientation involves a whole new way
of thinking. Program design begins with identifying the interacting entities,
or objects, in a given problem. In a banking application, for example, objects
can be accounts, customers, credit records, monthly statements, and so on. The
key is thinking in terms of quantities present in the problem domain rather
than programming artifacts in the computer language domain. An object may
represent a physical item such as a monthly statement or a logical item such
as a transaction. The objects must be self-contained and must correspond to
well-understood concepts in the problem domain. Thinking with the language
of the problem, not the language of the computer, is essential. Some objects may
have to be further broken down into smaller constituent objects. This approach
is known as object-based decomposition. Objects thus identified lead to software
objects, defined by classes, that simulate real ones in the problem domain.
The interactions among the problem-domain objects must then be consid-
ered carefully to define the external behavior of the objects and their interde-
pendence. Class definitions of the different objects can then be coded. The set
of all public data and function members forms the public interface of objects
in a class. The public interface must support the intended external behavior
precisely. The public interface determines how objects are used by other parts
of the program. Hiding behind the public interface are internal implementa-
tion details kept from outside access. Thus, object orientation decouples the
internal workings of objects from the rest of the program and significantly
reduces program complexity. Internal data and procedures can be modified
without affecting other parts of the program as long as the public interface is
preserved.
A good 00 design takes into account features such as generalizations of
the given problem, possible future extensions, reuse of existing code, ease of
modification, and so on. These ideas will become more concrete as you become
more familiar with C++ and OOP.

Here are some basic programming tips and things to remember to improve
your C++ programs:

• ·Include <iostream> to use I/O streams in the C++ Standard Library,

which is in its own namespace std. Add <fstream> for file I/O.
• Include <stdlib.h> to use Standard Library functions such as exit.
• Declare functions, variables, and classes before using them.
• Always terminate a declaration or a class definition with a semicolon.
 • Terminate a simple statement, but not a compound statement, with a
semicolon.
• A C-style character string is an array of characters terminated by '\ 0' .
Consider using the C++ string class instead of the C-style string when
you can.
• Use zero-based indexing for arrays. Hence, int arr [100] has its index
running from a to 99.
• A character is represented by an integer and can be used as such.
Logical values are of type bool.
• There is no exponentiation operator.
• The address-of operator & produces a pointer.
• The value-of operator * produces a value through a pointer.
• Except for reference parameters, arguments of functions are always
passed by value.
• Loops in C++ use continuation conditions. The iteration ends when the
condition becomes false.
• Logical false is zero, and logical true is anything else.
• Learn useful idioms such as for (; ;) (infinite loop),
for(int i=O ; i < j ; i++),while(i--),and
while ( std:: cin. get (c) ). (Idioms are pointed out throughout the
book.)
• Apply the ternary operator?: to form conditional expressions; use the
% operator to compute the remainder.
• Avoid hard-coded constants; use const identifiers instead.
• Avoid passing objects by value in function calls; use pass by reference
whenever possible.

If you develop a consistent formatting style in which to render your programs,

you avoid syntax errors and make the programs readable. The function style
used in this book is explained here with an example:

II logical function equal compares strings x and y

II returns true if x is equal to y, false otherwise

bool equal (char xl], char y[]) II (1)

{ if ( x == y ) return 1; II (2)
int i=O; II (3)
 while (x[i] == y[i]) II (4)
if (x[i] -- ' \0 ' ) return true; II (5)
i++; II (6)
1* end of while * I II (7 )
return false; II ( 8)
II end of function equal II (9)

Use comments to document the purpose and the effects of the function,
the meaning of the arguments, and the value returned. Format the function
body as follows:

1. Start the function header flush with the left margin.

2. Format the function body as a compound statement. Line up the
opening brace with the function name. Indent all statements one level.
3. Keep statements on separate lines for readability.
4. For the body of a statement, such as if, while, for, and so on, some
programmers always prefer to use a block, even if it contains only one
statement.
5. Keep a simple statement on one line. Some programmers may prefer
using another line for the body of the if statement. That is all right as
well.
6. Indent statements inside a block another level.
7. Line up the dosing brace for while vertically with the opening brace.
A comment can be added to dearly indicate the end of a multiline
construct.
8. Always put a return at the end of a function if it returns a value.
9. Line up the dosing brace of a function vertically with the opening
brace. If the function is lengthy, a comment at the end will help as well.

Use names in all caps for symbolic constants, preferring canst over #define
(Sections 14.4 and 3.9). Give functions and variables meaningful names (in all
lowercase), using the underscore C) or capitalization to connect multiple words
when appropriate.

1. Use capitalized nouns for dass names. Join multiple words, and
abbreviate if necessary, while capitalizing each word, as in Vector2D
and GroupLeader.
 2. Put each class definition in a separate header file, and be sure to use
the once-only header feature (Section 3.15). Put member function
definitions in a corresponding. C (or. CPp) file, which uses #include to
include its own header file.
3. In a class definition, put public members first and carefully document
public member functions with comments. Specify the meaning of
arguments.
4. Give only extremely simple member functions inside the class
definition.
5. If a class has any constructor, provide a default constructor.

Program examples in this book follow the formatting conventions closely.

However, because explanations are usually included in the text, the examples
tend not to be extensively commented.

Objects encapsulate functions and data to form an independent computing

unit. An object hides internal workings and is used only through its public in-
terface, achieving data abstraction. The isolation of object internals from the rest
of the program greatly simplifies the program. A class describes the structure
of an object and specifies access control to class members, which can be data,
functions, or other objects. Once defined, a class name becomes a user-defined
type and is used to establish objects or instances of the class. A constructor is a
special member function that initializes an object. A default constructor, which
takes no arguments, is needed for establishing simple variables or arrays of
class type. An object is the host of its members, and the members are accessed
via the host object with the operators. and ->.
C++ provides the class string as a better alternative to C-style strings in
many situations. The string class supplies useful operations such as size ()
(string length), empty ( ) (test), compare () (comparing substrings), and access to
individual characters by indexing. The + operator can be used to concatenate a
string object with another or a C-style string. The get line library function can
read a line from a given input stream into a string object.
Using objects to solve problems is natural and effective. An object-based
solution involves identifying the interacting objects in the problem domain and
building classes to model their behavior. A sequence of interactions among the
objects can represent the solution to the given problem. Changes in the problem
specification can be handled with modifications in the interactions. The Vector
example makes these points clear.
 Both unattached and member functions in C++ can be overloaded. When
a function call is made, the actual arguments are evaluated in an unspecified
order. Normally, arguments are passed by value; that is, the called function re-
ceives a copy of the arguments being passed. Pass by reference is accomplished
using reference parameters. Inline functions can avoid run-time function call
overhead. The function main can receive arguments supplied on the command
line. The library function getenv can retrieve environmental values.
Important topics to consider in order to write interesting programs in-
clude establishing I/O stream objects for reading and writing files, handling
of errors, object-based thinking, programming tips, and code formatting rec-
ommendations. This overview gives you a cross-sectional view of Standard
C++ and sets the stage for learning the elaborate constructs of later chapters.

1. Consider the Account class in Section 2.1. Add a member function void
display () to this class.

2. Add a member function transfer () for the Account class that transfers a given
amount from another account to the host account. Also implement the same
function as a nonmember.

3. Consider class member function definition and invocation. If the function

deposit can be defined as

void Account: :deposit (double amt)

{ acct_bal += amti }
why can it not be used with the notation Account : :deposit (400.0) i to deposit
400.0?

4. Consider the Account class in Section 2.1. Are the following declarations cor-
rect? Possible? Explain why.

Account paul;
Account marYi
 6. Suppose sally is already declared as an Account object with an account iden-
tification and initial balance. Is the call sally. Account (new_id, new_balance)
possible? Why?

7. How do you convert a C-style string to a string object? And vice versa? Is it
possible to pass a C-style string to a function parameter declared as a string?
Assign a C-style string to a string variable? Why?

8. Apply the library function get line in a program that counts the number of
lines in any text file specified on the command line.

9. Write a reverse-echo program that takes all words on the command line and
displays them backward, character by character.

10. Let words in a file be character strings separated by one or more white-space
characters (SPACE, TAB, NEWLINE). Write a program to count the number of
words in the input file (cin).

11. Modify the word-count program in Exercise 10 to take an optional argument,

which is the name of the input file.

12. Add the '==' operator to the Vector2D class. Add the member function
is-parallel (Vector2D&)to test whether a vector is parallel to the host vector
object. Given any four points A, B,C, and D, use Vector2Dobjects to determine
if ABCD is a parallelogram.

14. NIM is a game in which two players alternate in drawing counters, pennies, or
the like from a set of 12arranged in three rows of three, four, and five counters,
respectively. With each move, a player is allowed to draw either one, two, or
three counters. The player who draws the last counter loses. Write a program
to play NIM with one person or with two. (Hint: Consider a NIM board object.)