Lecture No.

Introduction to OOPS

Why Do We Need OOP?

OOP was developed because limitations were

discovered in earlier approaches to
programming. To appreciate what OOP does,
you need to understand what these
limitations are and how they arose from
traditional programming languages.

Procedural Languages

Pascal, C, BASIC, Fortran, and similar

traditional programming languages are
procedural languages. That is, each
statement in the language tells the computer
to do something: Get some input, add these
numbers, divide by 6, display that output. A
program in a procedural language is a list of
instructions.For very small programs, no other
organizing principle (often called a paradigm)
is needed. The programmer creates the list of
instructions and the computer carries them
out.

Division into Functions

When programs become larger, a single list of

instructions becomes unwieldy. Few
programmers can comprehend a program of
more than a few hundred statements unless it
is broken down into smaller units. For this
reason, the function was adopted as a way to
make programs more comprehensible to their
human creators. (The term function is used in
C++ and C. In other languages, the same
concept may be called a subroutine, a
subprogram, or a procedure.) A program is
divided into functions and—ideally, at least—
each function has a clearly defined purpose
and a clearly defined interface to the other
functions in the program. The idea of
breaking a program into functions can be
extended by grouping a number of functions
together into a larger entity called a module,
but the principle is similar: a grouping of
instructions that carry out specific tasks.
Dividing a program into functions and
modules is one of the cornerstones of
structured programming, the somewhat
loosely defined discipline that has influenced
programming design for several decades.

Problems with Structured Programming

As programs grow ever larger and more

complex, even the structured programming
approach begins to show signs of strain. You
may have heard about, or been involved in,
horror stories of program development. The
project is too complex, the schedule slips,
more programmers are added, complexity
increases, costs skyrocket, the schedule slips
further, and disaster ensues. Analyzing the
reasons for these failures reveals weaknesses
in the procedural paradigm itself. No matter
how well the structured programming
approach is implemented, large programs
become excessively complex. What are the
reasons for this failure of procedural
languages? One of the most crucial is the role
played by data. In a procedural language, the
emphasis is on doing things—read the
keyboard, invert the vector, check for errors,
and so on. The subdivision of a program into
functions continues this emphasis. Functions
do things, just as single program statements
do. What they do may be more complex or
abstract, but the emphasis is still on the
action. What happens to the data in this
paradigm? Data is, after all, the reason for a
program’s existence. The important part of an
inventory program isn’t a function that
displays the data or a function that checks for
correct input; it’s the inventory data itself. Yet
data is given second-class status in the
organization of procedural languages. For
example, in an inventory program, the data
that makes up the inventory is probably read
from a disk file into memory, where it is
treated as a global variable. Global, means
that the variables that constitute the data are
declared outside of any function so they are
accessible to all functions. These functions
perform various operations on the data. They
read it, analyze it, update it, rearrange it,
display it, write it back to the disk, and so on.
I should note that most languages, such as
Pascal and C, also support local variables,
which are hidden within a single function. But
local variables are not useful for important
data that must be accessed by many different
functions. Figure 1-1 shows the relationship
between global and local variables.

Figure 1-1 Global and local variables

Suppose a new programmer is hired to write a

function to analyze this inventory data in a
certain way. Unfamiliar with the subtleties of
the program, the programmer creates a
function that accidentally corrupts the data.
This is easy to do, because every function has
complete access to the data. It’s like leaving
your personal papers in the lobby of your
apartment building: Anyone can change or
destroy them. In the same way, global data
can be corrupted by functions that have no
business changing it. Another problem is that,
because many functions access the same
data, the way the data is stored becomes
critical. The arrangement of the data can’t be
changed without modifying all the functions
that access it. If you add new data items, for
example, you’ll need to modify all the
functions that access the data so that they
can also access these new items. It will be
hard to find all such functions and even
harder to modify all of them correctly. It’s
similar to what happens when your local
supermarket moves the bread from aisle 4 to
aisle 12. Everyone who patronizes the
supermarket must figure out where the bread
has gone and adjust their shopping habits
accordingly. The relationship of functions and
data in procedural programs is shown in
Figure 1-2.
Figure 1-2 The procedural paradigm

What is needed is a way to restrict access to

the data, to hide it from all but a few critical
functions. This will protect the data, simplify
maintenance, and offer other benefits.

Relationship to the Real World

Procedural programs are often difficult to

design. The problem is that their chief
components—functions and data structures—
don’t model the real world very well. For
example, suppose you are writing code to
create the elements of a graphics user
interface: menus, windows, and so on. What
functions will you need? What data
structures? The answers are not obvious, to
say the least. It would be better if windows
and menus corresponded more closely to
actual program elements.

New Data Types

There are other problems with traditional

languages. One is the difficulty of creating
new data types. Computer languages
typically have several built-in data types:
integers, floating-point numbers, characters,
and so on. What if you want to invent your
own data type? Perhaps you want to work
with complex numbers, or two-dimensional
coordinates, or dates—quantities the built-in
data types don’t handle easily. Being able to
create your own types is called extensibility
because you can extend the capabilities of
the language. Traditional languages are not
usually extensible. Without unnatural
convolutions, you can’t bundle both x and y
coordinates into a single variable called Point
and then add and subtract values of this type.
Traditional programs are more complex to
write and maintain.

The Object-Oriented Approach

The fundamental idea behind object-oriented

languages is to combine into a single program
entity both data and the functions that
operate on that data. Such an entity is called
an object.

An object’s functions, called member

functions in C++ (because they belong to a
particular class of objects), typically provide
the only way to access its data. If you want to
read a data item in an object, you call a
member function in the object. It will read the
item and return the value to you. You can’t
access the data directly. The data is hidden,
so it is safe from accidental alteration. Data
and its functions are said to be encapsulated
into a single entity. Encapsulation and data
hiding are key terms in the description of
object-oriented languages. If you want to
modify the data in an object, you know
exactly what functions interact with it: the
member functions in the object. No other
functions can access the data. This simplifies
writing, debugging, and maintaining the
program. A C++ program typically consists of
a number of objects that communicate with
each other by calling one another’s member
functions.

Figure 1-3 shows the organization of a C++

program.

Figure 1-3 The object-oriented paradigm

What are called member functions in C++ are
called methods in some other object-oriented
(OO) languages such as Smalltalk, one of the
first OO languages. Also, data items may be
called instance variables. Calling an object’s
member function is often referred to as
sending a message to the object.

The Corporate Analogy

You might want to think of objects as

departments—such as sales, accounting,
personnel, and so on—in a company.
Departments provide an important approach
to corporate organization. In most companies
(except very small ones), people don’t work
on personnel problems one day, payroll the
next, and then go out in the field as
salespeople the following week. Each
department has its own personnel, with
clearly assigned duties. It also has its own
data: payroll, sales figures, personnel records,
inventory, or whatever, depending on the
department. The people in each department
control and operate on that department’s
data. Dividing the company into departments
makes it easier to comprehend and control
the company’s activities and helps maintain
the integrity of the information used by the
company. The payroll department, for
instance, is responsible for payroll data. If you
work in the sales department and you need to
know the total of all the salaries paid in the
southern region in July, you don’t just walk
into the payroll department and start
rummaging through file cabinets. You send a
memo to the appropriate person in the
department and then wait for that person to
access the data and send you a reply with the
information you want. This ensures that the
data is accessed accurately and it is not
corrupted by inept outsiders.
This view of corporate organization is shown
in Figure 1-4. In the same way, objects
provide an approach to program organization
while helping to maintain the integrity of the
program’s data.

Figure 1-4
The
corporate
parad

Concepts of OOPS

Features of Object-Oriented Languages

Real-World Objects

When you approach a programming problem

in an object-oriented language, you no longer
ask how the problem will be divided into
functions, but how it will be divided into
objects. Thinking in terms of objects rather
than functions has a surprisingly helpful effect
on how easily you can design programs. This
results from the close match between objects
in the programming sense and objects in the
real world. What kinds of things become
objects in object-oriented programs? The
answer is limited only by your imagination,but
here are some typical categories to start you
thinking:

Physical objects
Elevators in an elevator control program
Automobiles in a traffic flow simulation
Countries in an economics model
Aircraft in an air traffic control system
Elements of the computer user environment
Windows
Menus
Graphics objects (lines, rectangles, circles)
The mouse, keyboard, disk drives, printer
• Data-storage constructs
Customized arrays
Stacks
Linked lists
Binary trees
• Human entities
Employees
Students
Customers
Salespeople
• Collections of data
An inventory
A personnel file
A dictionary
A table of the latitudes and longitudes of
world cities
• User-defined data types
Time
Angles
Complex numbers
Points on the plane
States and Abilities
The match between programming objects and
real-world objects is the happy result of
combining data and member functions. This is
an important concept, so let’s look at it
another way. Many real-world objects, at least
the interesting ones, have both a state
(characteristics that can change) and abilities
(things they can do). For example, an
elevator could be in the following state: It’s
on the 3rd floor, it contains four passengers,
and the passengers have pushed buttons for
the 7th, 11th, and 15th floors. The elevator
might also have the following abilities: It can
go down, it can go up, it can open and close
its doors, it can query other elevators to see
where they are, and it can calculate where it
should go next.

In C++, an object’s data records its state and

its member functions correspond to its
abilities. For an elevator object, the data
might be
• Current_floor_number
• Number_of_passengers_aboard
• List_of_buttons_pushed

The member functions might be

• GoDown()
• GoUp()
• OpenDoors()
• CloseDoors()
• GetInfo()
• CalculateWhereToGo()
The underscore character (_) is often used to
separate words in C++ names, as is the technique of
running words together but capitalizing the first letters.
Parentheses (( )) after a name indicate a function.
Incidentally, most C++ compilers allow names (variable
names, function names, and so on) to be as long as you
want, but only the first 32 characters are meaningful to
the compiler. Upper- and lowercase letters, the
underscore, and the digits from 0 to 9 are permissible
characters, but a name cannot start with a digit.

Object-oriented programming combines the programming

equivalent of states and abilities—which are represented
in a program by data and functions—into a single entity
called an object. The result is a programming entity that
corresponds neatly with many real-world objects.Making
objects the central feature of program design constitutes a
revolution in programming. No such close match between
programming constructs and the items being modeled
exists in procedural languages.

Classes

In OOP, objects are instances of classes. What does this

mean? Let’s look at an analogy. Almost all computer
languages have built-in data types. For instance, a data
type int, meaning integer, is predefined in C++. You can
declare as many variables of type int as you need in your
program:

int day; int count; int divisor; int answer;

In a similar way, you can define many objects of the same
class, as shown in Figure 2-1. A class serves as a plan, or
a template. It specifies what data and what functions will
be included in objects of that class. Defining the class
doesn’t create any objects, just as the mere existence of a
type int doesn’t create any variables of type int.
Figure 2-1 A class and its objects

A class is thus a description of a number of similar

objects. This fits your non-technical understanding of the
word class. Sting, Madonna, and the artist formerly
known as Prince, are members of the class of rock
musicians. There is no one person called “rock musician,”
but specific people with specific names are members of
this class if they possess certain characteristics.

An object can be called an instance or an instantiation of

a class because the object is a “real” example or an
instance of the specifications provided by the class. This
leads to a name commonly used for an object’s data:
instance data. It is called this because there is separate
data for each object; that is, for each instance of the class.

What is Abstraction?

The concept of abstraction relates to the idea of hiding

data that are not needed for presentation. The main idea
behind data abstraction is to give a clear separation
between properties of data type and the associated
implementation details. This separation is achieved in
order that the properties of the abstract data type are
visible to the user interface and the implementation
details are hidden. Thus, abstraction forms the basic
platform for the creation of user-defined data types called
objects. Data abstraction is the process of refining data to
its essential form. An Abstract Data Type is defined as a
data type that is defined in terms of the operations that it
supports and not in terms of its structure or
implementation.
In object-oriented programming language C++, it is
possible to create and provide an interface that accesses
only certain elements of data types. The programmer can
decide which user to give or grant access to and hide the
other details. This concept is called data hiding which is
similar in concept to data abstraction.
How Types of Abstraction Differs:

There are two broad types of abstraction; functional

abstraction and data abstraction. The main difference
between functional abstraction and data abstraction is that
functional abstraction refers to a function that can be used
without taking into account how the function is
implemented. Data abstraction refers to the data that can
be used without taking into account how the data are
stored. There is also a difference in the way the access
takes place in functional abstraction and data abstraction.
In functional abstraction, access to the function is
provided through a specific interface defined to invoke
the function. In contrast, in data abstraction, access to the
data is provided through a specific set of operations
defined to examine and manipulate the data. For instance,
when a programmer is using C++ standard data types, this
means that users are using the concept of data abstraction.
When using data types, the users are not concerned with
how the data is stored but they are concerned with what
operations are provided and what properties are
supported.
Reasons for the need of Abstraction
Flexibility in approach:
By hiding data or abstracting details that are not needed
for presentation, the programmer achieves greater
flexibility in approach.

Enhanced Security:
Abstraction gives access to data or details that are needed
by users and hide the implementation details, giving
enhanced security to application.

Easier Replacement:
With the concept of abstraction in object-oriented
programming language, it is possible to replace code
without recompilation. This makes the process easier and
saves time for users.

Modular Approach:
In object-oriented programming language C++, the
abstraction concept helps users to divide the project
application into modules and test each of them separately.
Then all modules are integrated and ultimately tested
together. This approach makes the application
development easier.
There are various ways of achieving abstraction in object-
oriented programming language C++. One approach is to
take modular based code that is broken apart into smaller
segments, known as functions. This functional or modular
approach helps the code to be reused again and again
when needed. For example, a programmer might write a
function for computing an average and another
programmer might write a function for computing salary.
These functions can be reused when needed, by anyone.
The modular based approach helps to centralize all data
of a similar type, under the control of a type module.
Defining module types allow the module to be an abstract
data type. In many other programming languages, there is
a small drawback associated with the approach to
accessing module type.

Data abstraction

It is the result of defining classes with emphasis on the

similarities of its objects and ignoring their differences. A
good abstraction is one that emphasizes details that are
significant to us and suppresses details that are not
important. A class is an abstraction. Thus, an abstraction
focuses on the outside view of the object and clearly
separates its essential behavior from the internal
implementation details.
1. Emphasizes similarity of objects and ignore their
differences
2. Good abstraction emphasizes significant details and
ignores unimportant details
3. Class is abstraction
4. Focuses on outside view of object only

Encapsulation

The concept of abstraction brings forth another related

term known as encapsulation. Encapsulation is the
process of combining or packaging data with functions
and thereby allowing users to create a new data type. This
new data type is termed abstract data type. Though the
new data type is similar to that of built-in data type, it is
termed abstract data type because it enables users to
abstract a concept from the problem space into the
solution space. Apart from the above, all the features that
hold for built-in types also hold for abstract data types.
Type checking process that are performed for built-in
types are also achieved in the same way and level for
abstract data types.

Encapsulation is the process of combining data and

functions into a single unit called class. Using the method
of encapsulation, the programmer cannot directly access
the data. Data is only accessible through the functions
present inside the class. Data encapsulation led to the
important concept of data hiding. Data hiding is the
implementation details of a class that are hidden from the
user. The concept of restricted access led programmers to
write specialized functions or methods for performing the
operations on hidden members of the class. Attention
must be paid to ensure that the class is designed properly.
 Lecture No. 3
Concepts of OOPS

Inheritance

The idea of classes leads to the idea of

inheritance. In our daily lives, we use the
concept of classes being divided into
subclasses. You know that the class of
animals is divided into mammals, amphibians,
insects, birds, and so on. The class of vehicles
is divided into cars, trucks, buses, and
motorcycles.The principle in this sort of
division is that each subclass shares common
characteristics with the class from which it’s
derived. Cars, trucks, buses, and motorcycles
all have wheels and a motor and are used to
transport people or goods; these are the
defining characteristics of vehicles. In
addition to the characteristics shared with
other members of the class, each subclass
also has its own particular characteristics:
Buses, for instance, have seats for many
people, whereas trucks have space for
hauling heavy loads. This idea is shown in
Figure 3-1. Notice in the figure that features A
and B, which are part of the base class, are
common to all the derived classes, but that
each derived class also has features of its
own.

Figure 3-1 Inheritance

In a similar way, an OOP class can be used as the basis

for one or more different subclasses. In C++, the original
class is called the base class; other classes can be defined
that share its characteristics, but add their own as well.
These are called derived classes.
Inheritance is somewhat analogous to using functions to
simplify a traditional procedural program. If you find that
three different sections of a procedural program do almost
exactly the same thing, you can recognize an opportunity
to extract the common elements of these three sections
and put them into a single function. The three sections of
the program can call the function to execute the common
actions and they can perform their own individual
processing as well. Similarly, a base class contains
elements common to a group of derived classes. As
functions do in a procedural program, inheritance
shortens an object-oriented program and clarifies the
relationship among program elements.

Reusability

Once a class has been written, created, and

debugged, it can be distributed to other
programmers for use in their own programs.
This is called reusability. It is similar to the
way a library of functions in a procedural
language can be incorporated into different
programs. However, in OOP, the concept of
inheritance provides an important extension
to the idea of reusability. A programmer can
take an existing class and, without modifying
it, add features and capabilities to it. This is
done by deriving a new class from the
existing one. The new class will inherit all the
capabilities of the old one, but may also
include new features of its own. For example,
you might have written (or purchased from
someone else) a class that creates a menu
system, such as that used in the Turbo C++
Integrated Development System (IDE). This
class works fine and you don’t want to change
it, but you want to add the capability to make
some menu entries flash on and off. To do
this, simply create a new class that inherits all
the capabilities of the existing one but adds
flashing menu entries. The ease with which
existing software can be reused is a major
benefit—possibly the major benefit—of OOP.
Many companies find that reusing classes on
a second project provides a major return on
their original investment.

Creating New Data Types

One of the benefits of objects is that they give
the programmer a convenient way to
construct new data types. Suppose you work
with two-dimensional positions (such as x and
y coordinates or latitude and longitude) in
your program. You would like to express
operations on these positional values with
normal arithmetic operations, such as
position1 = position2 + origin; where
the variables position1, position2, and
origin each represent a pair of independent
numerical quantities. By creating a class that
incorporates these two values and declaring
position1, position2, and origin to be
objects of this class, you can, in effect, create
a new data type. Many features of C++ are
intended to facilitate the creation of new data
types in this manner.

Polymorphism and Overloading

The = (equal) and + (plus) operators, used in

the position arithmetic shown above, don’t
act the same way they do in operations on
built-in types such as int. The objects
position1 and so on are not predefined in
C++, but are programmer-defined objects of
class Position. How do the = and +
operators know how to operate on objects?
We must define new operations for these
operators. These operators will be member
functions of the Position class. Using
operators or functions in different ways,
depending on what they are operating on, is
called polymorphism (one thing with several
distinct forms). When an existing operator,
such as + or =, is given the capability to
operate on additional data types, it is said to
be overloaded. Functions are overloaded
when multiple functions have the same name
but different arguments. Overloading can
make programs easier to write and to
understand. It’s a kind of polymorphism; it is
also an important feature of OOP.

C++ and C
C++ is derived from the C language. Strictly
speaking, it is a superset of C: Almost every
correct statement in C is also a correct
statement in C++, although the reverse is not
true. The most important elements added to
C to create C++ are concerned with classes,
objects, and object-oriented programming.
(C++ was originally called “C with classes.”)
However, C++ has many other features as
well, including an improved approach to I/O
and a new way to write comments. Figure 3-2
shows the relationship between C and C++.

Figure 3-2 The relationship between C and

C++

Message
A running program is a pool of objects where objects are
created, destroyed and interacting. This interacting is
based on messages which are sent from one object to
another asking the recipient to apply a method on itself.
To give you an understanding of this communication, let's
come back to the class Integer. In our pseudo
programming language we could create new objects and
invoke methods on them. For example, we could use
Integer i; /* Define a new integer object */
i.setValue(1); /* Set its value to 1 */
to express the fact, that the integer object i should set its
value to 1. This is the message ``Apply method setValue
with argument 1 on yourself.'' sent to object i. We notate
the sending of a message with ``.''. This notation is also
used in C++; other object-oriented languages might use
other notations, for example ``- ''.
Sending a message asking an object to apply a method is
similar to a procedure call in ``traditional'' programming
languages. However, in object-orientation there is a view
of autonomous objects which communicate with each
other by exchanging messages. Objects react when they
receive messages by applying methods on themselves.
They also may deny the execution of a method, for
example if the calling object is not allowed to execute the
requested method.
In our example, the message and the method which
should be applied once the message is received have the
same name: We send ``setValue with argument 1'' to
object i which applies ``setValue(1)''.
Definition (Message) A message is a request to an object
to invoke one of its methods. A message therefore
contains
the name of the method and
the arguments of the method.
Consequently, invocation of a method is just a reaction
caused by receipt of a message. This is only possible, if
the method is actually known to the object.
Definition (Method) A method is associated with a class.
An object invokes a method as a reaction to receipt of a
message.

Dynamic Binding

Early binding refers to events that occur at compile time.

In essence, early binding
occurs when all information needed to call a function is
known at compile time. (Put
differently, early binding means that an object and a
function call are bound during
compilation.) Examples of early binding include normal
function calls (including
standard library functions), overloaded function calls, and
overloaded operators. The
main advantage to early binding is efficiency. Because all
information necessary to call
a function is determined at compile time, these types of
function calls are very fast.

The opposite of early binding is late binding. As it relates

to C++, late binding refers
to function calls that are not resolved until run time.
Virtual functions are used to
achieve late binding. As you know, when access is via a
base pointer or reference, the
virtual function actually called is determined by the type
of object pointed to by the
pointer. Because in most cases this cannot be determined
at compile time, the object
and the function are not linked until run time. The main
advantage to late binding is
flexibility. Unlike early binding, late binding allows you
to create programs that can
respond to events occurring while the program executes
without having to create a
large amount of "contingency code." Keep in mind that
because a function call is not
resolved until run time, late binding can make for
somewhat slower execution times.
 Lecture No. 4
C++ syntax, exceptions and statements and
namespaces

Program Organization

Here’s how your source file is usually

arranged. Preprocessor directives such as
#include come first, followed by class
specifications, followed by main(). The
main() function contains statements that
define objects and send messages to them.
Figure 4-1 shows what this looks like.

Figure 4-1 Source file organization

In larger programs, things may be a bit more

complicated. There will probably be many
files. Some will contain class specifications,
whereas others will hold the code that uses
these classes. Nevertheless, the simple
arrangement used here reveals the
essentials of OOP.

Syntax of the Class Specification

The class specification consists of the

keyword class, the name of the class (here
it’s HotDogStand), an opening brace, a closing
brace, and a semicolon:
class HotDogStand <-- keyword
“class” and class name
{ <-- opening brace
<-- other program lines go here
}; <-- closing brace
and semicolon
The braces (sometimes called curly brackets)
are delimiters. They enclose the body of the
class specification so you (and your C++
compiler) can see where it begins and ends.
They serve the same purpose as the BEGIN
and END keywords in Pascal and BASIC.
Paired braces are the standard delimiters in
C++ and you’ll encounter them in many other
situations as well. Notice how the opening
brace is aligned vertically over the closing
brace. This makes it easier to tell which brace
goes where when you read a listing. The
semicolon ends the entire specification.
Semicolons are used to end program
statements, data declarations, and class
specifications (but not functions). In the case
of classes, both a closing brace and a
semicolon are necessary. Remember that the
class specification does not create any hot
dog stand objects; it merely specifies how
they will look when (and if) they are created.

Variable Declarations

Two variables, HotDogsOnHand and

BunsOnHand, are declared and specified to be
integers (type int). This is one of several
basic data types available in C++.
int HotDogsOnHand;
int BunsOnHand;
These declarations don’t give values (such as
47) to these variables, they merely give them
names and specify that they will require a
certain space in memory (although memory
space is not actually set aside until an object
is created).

Functions

There are three functions in the class

specification: initData(), SoldOneDog(),
and displayData(). Tell the C++ compiler
that these names apply to functions (and not
variables or something else) by appending
parentheses to the name:
void initData() <--parentheses
designate a function
{
}
The keyword preceding the function name
indicates the type of data returned by the
function. None of the hot dog stand functions
returns a value, so the void keyword is used.
If a function returns an int, for example, you
can write
int someFunc()
{
}
You could also add parameters to the function
by placing values or variable names within
the parentheses. Arguments convey values to
the function, like this:
void anotherFunc(float temperature,
float humidity)
{
}
As with the class specification itself, the body
of the function is delimited with braces:
void initData() <-- function named
initData with no return type, no
arguments
{ <-- start of
function body
<-- other statements would go here
} <-- end of function
body (NO semicolon)
A class specification is terminated by a
semicolon, but a function is not.

Public and Private

The idea behind public and private is to allow

some parts of an object to be accessed by
program statements outside the object while
other parts can be accessed only from within
the object itself, as shown in Fig 4-2.
Figure 4-2 Public and private access

The public and private keywords, followed

by colons, are used to designate these parts.
Here all the data is private and all the
member functions are public. This is the usual
situation: You want to hide the data from the
outside world so it is protected from
accidental alteration. However, you want the
member functions to be public so other parts
of the program can call them to tell the object
to do something. To work with the data, don’t
access it directly; instead, ask a member
function to access it for you.
Exceptions

Exceptions provide a systematic, object-

oriented approach to handling runtime errors
generated by C++ classes. To qualify as an
exception, such errors must occur as a result
of some action taken within a program and
they must be ones the program itself can
discover. For example, a constructor in a
user-written string class might generate an
exception if the application tries to initialize
an object with a string that’s too long.
Similarly, a program can check if a file was
opened or written too successfully and
generate an exception if it was not. Not all
runtime errors can be handled by the
exception mechanism. For instance, some
error situations are not detected by the
program but by the operating system, which
may then terminate the application. Examples
are stack overflow, the user pressing the key
combination, or a hardware divide-by-zero
error.

Namespaces
The larger a program is, the greater the
danger of name clashes, that is, a single
name being used—inadvertently—to refer to
several different things. This is a particular
problem in multifile programs, where files
may have been created by different
programmers or different companies. For
example, suppose a class alpha is defined in
a file A:
// file A
class alpha
{ };
In another file, which will eventually be linked
with file A, there is also a specification for a
class that— unbeknownst to the creators of
file A—has been given the same name:
// file B
class alpha
{ };
The resulting name clash will cause linker
errors. Programmers might then try to fix the
problem by renaming one of the alpha
classes. However, there’s an easier way. A
recent revision to the draft ANSI C++
standard introduces a new solution to this
 problem: namespaces. A namespace is a
section of a program specified by the keyword
namespace and enclosed in brackets. A name
used within a namespace does not have
global visibility; instead, its scope is limited to
the namespace.
 Lecture No. 5
Basic program construction: data types, variables,
functions and statements

Basic C++ Data Types

Objects are composed of two major elements:

instance data and member functions.
You can use C++ to define any data type you
want, but the built-in types save you from
going to this trouble in most common
situations. There are seven basic types built
into C++. Of these basic types, one
represents characters, three represent whole
numbers (integers), and three represent real
(floating-point) numbers. Table 1-1
summarizes the C++ data types.
Table 5-1 C++ data types
Type Name - Used to Store - Examples
of Values Stored
char - Characters - ‘a’, ‘B’,
‘$’, ‘3’, ‘?’
short - Small whole numbers - 7,
30,000, -222
int - Normal-sized whole numbers
(same as short or same as long) -
long - Large whole numbers -
1,000,000,000, -123,456,789
float - Small real numbers - 3.7, 199.99,
-16.2, 0.000125
double - Large real numbers -
7,553.393.95,47, -0.048512934
long double - Extra-large real numbers -
9,123,456,789,012,345.666

Characters
Characters are stored in variables of type
char. The statement
char ch3;
creates space in memory for a character and
names it ch3. To store a particular character
in this variable, use a statement like
ch3 = ‘a’;
Character constants, such as ‘a’, ‘B’, ‘&’ or
‘4’, are surrounded by single quotes.
Assignment Operator

The equal sign (=) causes the value on its

right to be assigned to (placed in) the variable
on its left; that is, following this statement,
the variable ch3 will have the value ‘a’. The
equal sign is called the assignment operator
because it assigns the value on the right to
the variable on the left.
All characters are actually stored as numbers
(which, as you know, is all a computer
understands). The ASCII code is used to
translate characters into numbers. Thus ‘A’
is 65, ‘B’ is 66, and so on. The ASCII code is
shown in Appendix E.

Escape Sequences

Various special characters are represented by

letters preceded by a backslash. This is called
an escape sequence because the backslash
causes the interpretation of the next
character to “escape” from the normal ASCII
code and indicate something different. Table
1-2 shows the most common escape
sequences.

Table 5-2 Common escape sequence

Escape Sequence - Character Represented

‘\n’ - New line. Causes the cursor to move
to the start of the next line. (Same as a
carriage return plus a line feed.)
‘\t’ - Tab character.
‘\b’ - Backspace.
‘\r’ - Carriage return. Causes the cursor to
move to the start of this line. Also generated
by the key.
Variables of type char are occasionally used
to store whole numbers rather than
characters. You can say
ch3 = 44;However, the range of numerical
values that can be stored in type char is
from -128 to 127, so this works only for very
small numbers. Whole numbers are usually
stored in variables of type int, which is faster
for the computer to process than type char.A
variable of type char occupies 1 byte, or 8
bits, of memory.
Integers

Integers represent whole numbers, that is,

values that can be counted, such as the
number of people living in Thomasville
(12,348) or lines of text on a page (33).
Integers cannot represent numbers with
decimal points or fractional parts, such as 2.3
or 4/7. Integers can be negative: -7, -413.
There are three integer types in C++: short,
int, and long. They are similar but occupy
different amounts of memory and can handle
numbers in different numerical ranges, as
Table 1-3 shows. I also include type char in
this table, even though it is mostly used for
characters, because it can be used to store
small whole numbers as well.
Table 5-3 Integer types in C++

Type - Name - Size - Range

char - 1 byte (8 bits) - -128 to 127
short - 2 bytes (16 bits) - -32,768 to 32,767
int - Same as short on 16-bit systems,
same as long on 32-bit systems
long - 4 bytes (32 bits) - -2,147,483,648 to
2,147,483,647
Type short always occupies 2 bytes. It can
store numbers in the range of -32,768 to
32,767. Type long always occupies 4 bytes
and can store numbers in the range of
-2,147,483,648 to 2,147,483,647.
In 16-bit systems, type int occupies 2 bytes,
the same as short. In 32-bit systems, it
occupies 4 bytes, the same as long, and can
therefore handle a larger range of values.
Older operating systems, such as DOS and
Windows 3.1, are 16-bit systems. Newer
systems, such as Windows 95, OS/2, and
Windows NT, are 32-bit systems. Unix has
always been a 32-bit system. The int type is
the most commonly used integer type and
operates the most efficiently whatever
system you use. However, if you want to
guarantee a 2-byte variable even in a 32-bit
system (to save space), you must use short;
if you want to guarantee a 4-byte variable on
a 16-bit system (to hold large values), you
must use long. Here’s an example of defining
some integer variables and giving them
values:
int MilesDriven; <-- declare variables
long population;
MilesDriven = 1024; <-- give the
values
population = 1405836L;
The L is used to designate a type long
constant, one that won’t fit in an integer (in a
16-bit system).

Unsigned Integers

All the integer types have unsigned versions.

Unsigned variables can’t hold negative
numbers, but their range of positive values is
twice as large as that of their signed brothers.
Table 1-4 shows how this looks.
Table 5-4 Unsigned integers
Type Name - Size - Range
unsigned char - 1 byte (8 bits) - 0 to 255
unsigned short - 2 bytes (16 bits) - 0 to
65,535
unsigned int or unsigned - Same as
unsigned short on 16-bit systems, Same as
unsigned long on 32-bit systems
unsigned long - 4 bytes (32 bits) - 0 to
4,294,967,295
Ordinary integers, without the unsigned
designation, are signed by default. You can
use the keyword signed, but it’s not
necessary.

Floating Point

Floating-point numbers are used to represent

values that can be measured, such as the
length of a room (which might be 5.32
meters) or the weight of a rock (124.65
pounds). Floating-point values are normally
expressed with a whole number to the left of
a decimal point and a fraction to the right.
Instead of a decimal point, you can use
exponential notation for floating-point
numbers. Thus, 124.65 in normal
notation is 1.2465e2 in exponential notation,
where the number following the e indicates
the number of digits the decimal point must
be moved to the right to restore the number
to normal notation. Exponential notation is
commonly used to display numbers that are
inconveniently long in decimal notation. Thus,
9,876,000,000,000,000,000 in normal
notation is 9.876e18 in exponential notation.
There are three kinds of floating-point
numbers in popular operating systems, as
shown in Table 1-5. (Some systems don’t
have long double.)
Table 5-5 Floating-point numbers
Type Name - Size - Range - Precision
float - 4 bytes (32 bits) - 10e-38 to 10e38 5
digits
double - 8 bytes (64 bits) - 10e-308 to
10e308 15 digits
long double - 10 bytes (80 bits) - 10e-4932
to 10e4932 19 digits
The most common floating-point type is
probably type double, which is used for most
C++ mathematical library functions. Type
float requires less memory than double
and may speed up your calculations. Type
long double is used in the floating-point
processor in Intel microprocessors and is
useful for very large numbers Here’s an
example of defining and using variables of
the various floating-point types:
float pi_float;
double pi_double;
long double pi_long_double;
pi_float = 3.1415;
pi_double = 3.14159265358979;
pi_long_double = 3.141592653589793238;
Here I’ve assigned constants representing the
mathematical constant pi to variables of the
three types, using as many digits of precision
as each type will allow. Figure 1-11 shows the
amounts of memory required for all the data
types except long double. You can initialize
variables to specific values when they are
first declared. Thus the six statements above
could be condensed into
float pi_float = 3.1415;
double pi_double = 3.14159265358979;
long double pi_long_double =
3.141592653589793238;

Whitespace
C++ doesn’t mind if you put extra spaces into
a program line. You can use them to align
things so they’re easier to read. You could say
float pi_float = 3.1415;
double pi_double = 3.14159265358979;
long double pi_long_double =
3.141592653589793238;
You can put as many spaces, tabs, and new
lines as you want in your program. These
characters constitute
whitespace, and the C++ compiler ignores
whitespace in almost all situations.
Programmers use whitespace to make the
program easier for humans to follow.

Comments

You can add comments to your program

listing to help yourself—and anyone else who
might need to look at your listing—
understand what it does. Comments are
preceded with a double slash: //.
Here’s a code fragment, taken from the
previous section, that uses a full-line
comment and comments following each of
three statements:
// these variables are declared and
initialized at the same time
float pi_float = 3.1415; // 5-digit
precision
double pi_double =
3.14159265358979; // 15-digit
precision
long double pi_long_double =
3.141592653589793238; // 19-digit
precision Any text following the // symbol
until the end of the line is ignored by the
compiler.
Another kind of comment allows you to write
comments that span multiple lines. Here’s an
example:
/*
if you have a really long multiline
comment it is easier to
use this arrangement than to write
the double-slash symbol before
every line
*/
The /* symbol starts the comment and the
*/ ends it. The end of a line does not
automatically end a comment that starts with
/* (as it does with those starting with //), so
you can write as many comment lines as you
want before terminating with the */ symbol.
This comment style is harder to type and
requires two symbols per comment instead of
one, so it is not usually used for single-line
comments.
As you know, adding numerous comments to
your code makes it far more comprehensible
to anyone else who must understand your
program. And, difficult as it may be to
believe, you yourself may find comments
helpful if you try to read a listing you haven’t
seen for some time.

Introduction to Input/Output

The most important things that member

functions do is : performing input and output.
If you can’t put data into objects and get it
out again, they’re not going to be too useful.
In this lesson, I’m going to explore some
basics of performing input/output (I/O) in C+
+.
Output to the Screen

Here’s a statement that causes a line of text

to be displayed on the screen:
cout << “This text will appear on the
screen.”;
The name cout, pronounced “C out,”
represents a C++ object that is associated
with the screen display. The << operator,
called the put to operator, causes whatever is
on its right to be sent to whatever is on its
left. The cout object and the << operator are
part of the C++ standard stream library, so
you don’t need to define them yourself or
even worry too much about how they work.
Figure 5-1 shows how cout works.

Figure 5-1 Output with cout

String Constants
The text “This text will appear on the
screen.” is called a string constant. A string
constant is surrounded by double quotes
(unlike a character constant, which is
surrounded by single quotes). The entire
statement, as with all C++ statements, is
terminated with a semicolon.
You can output numerical constants the same
way. The statement
cout << 27;
causes a 27 to appear on the screen, whereas
cout << 123.45;
displays 123.45.
You can display the values of variables as well
as numbers. For example, this code displays
2.7:
float fvar1 = 2.7;
cout << fvar1;
More than one value can be displayed with a
single cout statement, using multiple put to
operators:
float height = 2.7;
cout << “It is ” << height << “ meters
high.”;
This would produce the output
It is 2.7 meters high.
You can also reformat such a statement so
that the put to operators line up vertically,
thus making the statement easier to read:
cout << “It is”
<< height
<< “meters high.”;
Or you could use three separate cout
statements to produce the same output.

Formatting Output

It’s nice to have some control over the way

output is formatted. In C++ stream I/O, a
variety of techniques are available for this
purpose. I’ll show two examples here.

New Lines Not Automatic

Some languages, such as BASIC,
automatically move to a new line at the end
of every output statement, but C++ does not.
Nor are different variables in the same
statement placed on separate lines. New lines
are not created automatically by the cout
object or the put to operator. For example,
the statements
cout << 6.25;
cout << 30.9 << 2.5;
produce the output 6.2530.92.5
where all the output is run together. This is
probably not what you want.

Escape Sequences

One of the easiest ways to format data is to

insert a character called an escape sequence
into a string constant. For example, you can
use the ‘\n’ escape sequence to start a new
line:
cout << “\nNow I'll ask you some
questions about yourself.”;
cout << “\nFirst, enter your age: ”;
produces the display
Now I'll ask you some questions about
yourself.
First, enter your age:
The ‘\n’ before “First” causes the second
string constant to be displayed on a separate
line from the first. (The '\n’ before “Now”
ensures that the first line begins on a new line
as well, even if something else has already
been printed by a preceding statement.)
You can use the escape sequence '\t’ to
generate tab characters. The code
cout << “\nJoe\tFred\tSally”;
cout << “\nGeorge\tBud\tSandy”;
lines up the names in columns.
Joe Fred Sally
George Bud Sandy

The endl Manipulator

There’s another approach to starting new

lines in C++. An object called a manipulator
can be inserted into an output stream, just
like a data item. Manipulators can be used to
format output, among other purposes.
Probably the most common manipulator is
endl (a contraction of “end line”). Inserted
into a cout statement, endl causes the
cursor to move to the start of the next line,
just as '\n’ does. (Also, endl flushes any
output that may be waiting in the output
buffer to the display.)
Earlier, I showed two lines that used the ‘\n’
escape sequence to start text on a new line.
Here’s how to achieve the same result using
endl:
cout << endl;
cout << “Now I'll ask you some
questions about yourself.” << endl;
cout << “First, enter your age: ”;
The first statement ensures you start on a
new line and the endl at the end of the
second statement causes the text beginning
with “First” to start on a new line.

Input from the Keyboard

Here’s how to input a number, entered by the

user from the keyboard, and store it in a
variable intvar:
int intvar;
cin >> intvar;
The cin object (for “C in”) represents the
keyboard, and the get from operator (>>)
takes whatever is on the left and puts it in the
variable on the right. When this statement is
executed, the program waits for the user to
type a number and press . Figure 5-2 shows
how this looks.

Figure 5-2 Input with cin

Usually, of course, you want to prompt the

user before waiting for input:
int age;
cout << “Enter your age: ”;
cin >> age;
This produces the following interaction:
Enter your age: 34
where the user enters the 34. You can use the
get from operator multiple times in the same
statement:
int age;
float height;
cout << “Enter your age and height:”;
cin >> age >> height;
Here the user presses <ENTER>,<SPACE>, or
<TAB>after each value before entering the
next one. However, it’s usually better to
prompt the user for only one value at a time,
to avoid any possibility of confusion.

Stream I/O

The techniques for input and output I’ve

shown here are called stream I/O. A stream is
a general term for a flow of data. As you’ll see
when you write a complete program, to use
stream I/O, you need to include a file of
declarations in your program. This file,
IOSTREAM.H, is called a header or include file.

Old-Style C I/O

If you are a C programmer, you are familiar

with a completely different style of input and
output using printf(),scanf(), and similar
library functions (declared in STDIO.H). You
can use these functions in C++ as well, but
the preferred approach is to use stream I/O.
Why? First, it’s easier to avoid mistakes. Have
you ever used the wrong format specifier in
printf() (e.g., %d instead of %f), so that
data is displayed incorrectly? It’s easy to do,
and in scanf(), the wrong specifier can crash
your program as well. Second, the stream I/O
approach lets you use cout and cin with
classes you write yourself. This allows you to
perform I/O on any programming object the
same way it’s performed on basic data types.
This is a very powerful technique, which is
unavailable with standard C I/O. Some old-
time C programers can’t get the hang of
stream I/O and persist in using standard I/O,
but they are missing out on some powerful
and important features of C++.

Member Functions

Data is one of the two parts of objects. The

second part: member functions. Typically a
program calls an object’s member functions
to tell the object to do something. This is why
calling an object’s member function is also
called sending a message to the object. In the
hot dog stand example, there are three
member functions: initData(),
SoldOneDog(), and displayData(). Earlier,
for simplicity, I showed these functions with
empty function bodies. Now it’s time to fill in
these functions and see what they can
actually do.

Initializing the Data

At the start of each day, you want to initialize

the number of hot dogs and buns at a stand.
Use the initData() function for this. This
requires both cout (for the prompts) and cin
statements. Here’s how it looks:
void initData()
{
cout << “Enter dogs on hand:”;
cin >> HotDogsOnHand;
cout << “Enter buns on hand:”;
cin >> BunsOnHand;
}
An example of interaction with this function
would be
Enter dogs on hand: 30
Enter buns on hand: 52
where the program displays the prompts and
the user enters 30 and 52.

Recording a Sale

When a hot dog is sold, the stand operator

calls Sally to tell her this fact. When she
receives such a call, she wants the program
to decrease both the number of hot dogs and
the number of buns by one. Here’s a member
function that does the job:
void SoldOneDog()
{
HotDogsOnHand = HotDogsOnHand - 1; //
subtract 1 from variable
BunsOnHand = BunsOnHand - 1; //
subtract 1 from variable
}
Here there’s no interaction with the user, only
a little arithmetic.
Figure 5-3 shows how Sally interacts with an
object of class HotDogStand, using its
member functions.

Displaying Data

Remember that a HotDogStand object

records the numbers of hot dogs and buns on
hand, in the variables HotDogsOnHand and
BunsOnHand. You can use cout statements to
display these values. The resulting
displayData() function looks like this:
void displayData()
{
cout << “Hot dogs on hand = ”
<< HotDogsOnHand << endl;
cout << “Buns on hand = ”
<< BunsOnHand << endl;
}
The output from this function will be
something like this:
Hot dogs on hand = 347
Buns on hand = 298
You’ve simply inserted two statements into
the function. These statements make up the
function body. (As you’ve seen, you could
produce the same output with four cout
statements or with only one.)
 Lecture No. 6
Basic Operators

Arithmetic Operators
In the SoldOneDog() function, shown above,
you used the subtraction operator (-) to
subtract one from two values. C++ includes
the usual four arithmetic operators plus a
fifth, less common one, as shown in Table 6-1.
Table 6-1 Arithmetic operators

Operator - Purpose
+ - Addition
- Subtraction
- Multiplication
/ - Division
% - Remainder
The first four operators perform familiar
operations. The remainder operator, % (also
called the modulus operator), is used to
calculate the remainder when one integer is
divided by another. Thus the expression
20 % 3 evaluates to 2, because 20 divided by
3 is 6, with a remainder of 2.
You can use any of the arithmetic operators
just as you would in normal arithmetic or
algebra or most other programming
languages. They are called binary operators
because they operate on two quantities. That
is, expressions involving them have the form
alpha+beta, where the + operates on alpha
and beta. Of course, you can make arithmetic
expressions as complicated as you want. For
example,
c = (f-32) * 5 / 9;
converts a temperature in Celsius to one in
Fahrenheit. Use parentheses so the
subtraction will be carried out first, despite its
lower precedence. (The term precedence
refers to the order in which operations are
carried out. The * and / operators have
higher precedence than the + and -
operators.)
In C++, it’s perfectly all right to mix different
arithmetic types in the same expression. For
example, in the above statements, f might
be type int and c might be type float. The
compiler would not complain. Instead, it
would automatically convert the types
appropriately before carrying out the
arithmetic.

Increment and Decrement Operators

In programming, there always seems to be a

need either to add 1 to something or to
subtract 1 from something, just as there was
in the example above. These situations are so
common that C++ includes two special
operators that perform the task in a much
more compact form than using the normal
addition and subtraction operators. The
decrement operator subtracts 1 from a
variable and the increment operator adds 1 to
it. Here’s the SoldOneDog() function,
rewritten to use the decrement operator:
void SoldOneDog()
{
--HotDogsOnHand; // subtract 1 from
HotDogsOnHand
--BunsOnHand; // subtract 1 from
BunsOnHand
}
The decrement operator consists of two
minus signs together: —. If HotDogsOnHand
were 30 and BunsOnHand were 52, then after
executing this function, these two variables
would be 29 and 51.
Similarly, the increment operator, ++,
increases the variable it’s applied to by 1. The
increment and decrement operators are
called unary operators because they operate
on only one variable. Their priority is higher
than that of arithmetic operators, so in the
expression ++x + 3, the value of x will be
incremented before the addition is carried
out.

Relational Operators

Relational operators compare two values and

evaluate to a true/false value, depending on
whether the comparison is true or not. There
are six such operators, as shown in Table 6-2.
Table 6-2 Relational operators
Symbol - Meaning - Example
== - equal to - a == b
!= - not equal to - a != b
< - less than - a<b
> - greater than -a>b
<= - less than or equal to - a <= b
>= - greater than or equal to - a >= b
The expressions in the Example column will
be either true or false depending on the
values of a and b. For example, suppose a is
9 and b is 10. Then a==b is not true, because
9 does not equal 10, but a!=b is true, as are
a<b and a<=b. The expressions a>b and a>=b
are false. You can compare characters as well
as numbers, because characters have
underlying (ASCII) numerical values. Thus, it’s
true that ‘a’<‘b’ and that ‘A’==65, but not
true that ‘z’<=‘a’ (because ‘z’ in fact has
a higher ASCII value than ‘a’). Now that you
understand relational operators, let’s look at
the three kinds of C++ loops and see how
they decide what to do based on expressions
that use these operators.
Logical Operators

It’s often convenient to test the true/false

values of several expressions at the same
time and combine the results into a single
true/false value. For instance, you might want
to create a true value any time both x<10
and y<5 are true. True/false values can be
operated on with logical operators. There are
three logical operators in C++ (see Table 6-
3). Two of them combine two true/false
values, and the third negates a true/false
value.
Table 6-3 Logical operators
Logical Operator | Meaning | Example
&& | AND | x>0 && x<10
|| | OR |x==3 || x<1
! | NOT |!x
An AND expression is true only if the
expressions on both sides of the && operator
are true. Thus, the example in the table is
true only if x is greater than 0 and also less
than 10. The AND operator is often used to
determine whether something is in a specified
range. In the example in the table, the
expression is true if x is in the range of 1to 9.
Similarly, the expression
ch >= 'a' && ch <= 'z'
is true if ch is a lowercase letter.The OR (||)
operator evaluates to true if either or both of
its operands are true. For example,
j==0 || ch == 'q'
is true if either j is 0 or ch equals ‘q’, or if
both are true.
The OR operator is often used to discover if a
value is outside a specified range. The
expression
temp<65 || temp>75
is true if temp is outside the 65 to 75 range
(the “comfort zone” for Fahrenheit
temperatures).
The ! (NOT) operator negates the variable
following it. Thus, !alpha is true if alpha is
false, and false if alpha is true. (As you can
see, this operator has an Alice in Wonderland
quality.) It’s often used when you want a
while loop to continue until something is
true, instead of continuing until it’s false. For
example,
while( !alpha )
{
}
will cycle until alpha becomes true
(nonzero).
Logical expressions can often be written in
several ways. The expression
temp<65 || temp>75
could also be written
!(temp>=65 && temp<=75)
because a value being not in range is the
same as it’s being out of range.

Precedence

In normal algebraic expressions,

multiplication and division are carried out
before addition and subtraction. For example,
in the expression 2*2+3*3 the 2s are
multiplied (which gives 4), then the 3s are
multiplied (giving 9), and only then are these
results added, yielding 13. The multiplications
are carried out before the addition because
the * operator has a higher precedence than
the + operator. If there was no precedence
and the compiler just evaluated expressions
blindly from left to right, the compiler would
obtain a different answer. Multiplying the 2s
gives 4, adding the 3 makes 7, and
multiplying the result by 3 gives 21, which is
not what you expect. Thus precedence is
important in normal arithmetic expressions.
It’s also important
when different C++ operators are used. You
may have wondered why, when I say temp<65
|| temp>75 how I can be sure that the
true/false value of temp<65 and temp>75
are evaluated first, before being ORed
together. If the processor proceeded from left
to right, for example, temp<65 would be
evaluated, ORed with temp (whatever that
would mean, because temp is a number, not
a true/false value), and the result compared
with 75. This isn’t what I want, of course. The
expression is evaluated correctly because
relational operators have a higher precedence
than logical operators. How is the expression
n + 2 < x + 3 evaluated? You want to
compare two arithmetic expressions, n+2 and
x+3. Is that what’s happening? Yes, because
arithmetic operators have a higher
precedence than relational operators. Table
6-4 shows the precedence relations, with the
higher precedence operators higher in the
table.
Table 6-4 Precedence relations

Operators | Operator Types |

Precedence
/ % | Multiplicative | Higher
+ - | Additive
< > <= >= == != | Relational
&& || | Logical
= | Assignment | Lower
Notice that the assignment operator, =, has
the lowest precedence of all; that is, it’s
applied after all the other operators.
 Lecture No. 7
Flow control statements: if else, switch

Simple Decisions

The if Statement

The simplest way to make a decision in C++

is with the if statement. Here’s an example
of an if statement at work:
if(denominator == 0)
cout << “Division by zero is illegal”;
If a variable called denominator is 0, this
fragment causes a message to be displayed.
If denominator is not 0, then nothing
happens.
As with loops, if you use more than one
statement in the body of an if statement, you
need to surround them with braces.
if(choice == 's') // if user chooses
“sold dog' option
{
cout << “Selling a dog”; // verify I
sold the dog
stand1.SoldOneDog(); // sell the dog
}
An if statement consists of the keyword if
followed by a test expression in parentheses.
The loop body, which follows, consists of
either a single statement or multiple
statements surrounded by braces. (With the
exception of the keyword, an if statement
has the same syntax as a while statement.)
Notice that there is no then keyword in C++,
as there is in some other languages. The body
of the loop follows immediately after the test
expression.

Figure 7-1 shows the syntax of the if

statement and Figure 7-2 show how it
operates.

The if…else Statement

In a simple if statement, something happens
if the condition is true, but if the condition is
not true, nothing happens at all. Suppose you
want something to happen either way: one
action if the condition is true and a different
action if the condition is false. To do this, you
use an if…else statement. The following
fragment takes the hour of the day,
expressed in 24-hour time, and displays it in
12-hour time, with “am” or “pm” as
appropriate:
if(hours < 12)
cout << hours << “ am”; // e.g., “7
am” if hours is 7
else
cout << hours-12 << “ pm”; // e.g., “3
pm” if hours is 15
Actually, this simple approach doesn’t handle
the situation very well when hours is 0
(midnight) or 12 (noon). You’ll see how to
deal with these cases in the next lesson. As
with other C++ constructions, the if body or
the else body may consist of multiple
statements surrounded by braces rather than
the single statements I show here.
Test Expression

The test expression in an if or an if…else

statement can be just as complicated as
expressions in loops. For example, this if…
else statement advances the day from
February 28 to either March 1 or February 29,
depending on whether the year is a leap year
or not:
// if it's Feb 28 and it's a leap year
if(day==28 && month==2 && year%4==0 &&
year%100 != 0)
day = 29; // then the next day is the
29th
else // otherwise,
{
day = 1; // next day is March 1st
month = 3;
}
Leap years occur when the year is divisible by
4 (e.g., 1996 is a leap year), but not divisible
by 100 (so 1900 is not a leap year, although it
is divisible by 4. The remainder operator (%)
is used to find if the year is divisible by 4 (and
by 100) with no remainder. The AND
operators make sure that February 29 occurs
only when all the conditions are true at once.

Nested if…else Statements

You can nest if…else statements within one

another. Typically, the nested statements end
up in the else body rather than in the if
body. For example
if(age<2)
cout << “\nInfant”;
else
if(age<18)
cout << “\nChild”;
else // age >= 18
cout << “\nAdult”;
This if…else “ladder” prints an appropriate
description of a person’s age.
An insidious problem may arise when you
nest if…else statements. Here’s a program
fragment that is intended to have a similar
functionality to the one above, except it can’t
print the adult designation:
if(age>2) // if greater than 2
if(age<18) // and less than 18
cout << “\nChild”; // it's a child
else
cout << “\nInfant”; // ERROR:
inappropriate response
Will this fragment print “Infant” when age
is less than or equal to 2, as I want? Alas, no.
“Infant” will be printed whenever age is
greater than or equal to 18. Why? I have
mislead you with the indentation, so it looks
as if the else matches up with the first if. It
doesn’t. Here’s the rule: An else is
associated with the nearest preceding if
that doesn’t have its own else. The correct
version of the fragment above would be
if(age>2)
if(age<18)
cout << “\nChild”;
else // the else goes with the
preceding if
cout << “\nAdult”; // appropriate
response, age>=18
If you really want an else to be associated
with an if that doesn’t immediately precede
it, you must surround the intervening if
statement with braces
if(age>2)
{
if(age<18)
cout << “\nChild”;
}
else // this else goes with the top if
cout << “\nInfant”; // appropriate
response
The braces make the entire if statement
invisible to the else. The moral is to be
careful with complicated if…else
statements.

The else if Construction

In the previous example of an if…else

statement that displayed “am” or “pm” for
hour values less than and greater than 12. I
also acknowledged that this statement didn’t
handle the occasions when hour was 0 or 12.
How can I fix this? I can check for these
specific values of hour and respond
accordingly. Here’s how that looks with an
if…else ladder:
if(hours == 0) // first-level indent
cout << “Midnight”;
else
if(hours == 12) // second-level indent
cout << “Noon”;
else
if(hours < 12) // third-level indent
cout << hours << “ am”;
else
cout << hours-12 << “ pm”;
If the hours is 0, it’s midnight, so the
program displays an appropriate message
and exits from the entire
if…else ladder. If it isn’t 0, the program goes
on to the next if…else. It keep moving to
more deeply nested if…else statements
until it finds one whose test expression is true
or it runs out of possibilities.
This arrangement does what I want, but it’s
hard for humans to read the multiple
indentations. Here’s a somewhat more easily
understood way to rewrite the same code:
if(hours == 0)
cout << “Midnight”;
else if(hours == 12)
cout << “Noon”;
else if(hours < 12)
cout << hours << “ am”;
else
cout << hours-12 << “ pm”;
The if that follows each else is simply
moved up onto the same line, thus creating a
sort of artificial else if construction and
removing the multiple levels of indentation.
This arrangement not only saves space, it
presents a clearer picture of the program’s
logic (at least, after you’ve gotten used to it).
Notice that the else if construction is not
really a part of the syntax of the C++
language; it’s merely a way to rewrite an if…
else ladder by rearranging the whitespace
on the page.

Fine-Tuning Loops

This is a good place to introduce the break

and continue statements, even though they
pertain to loops, because they are used most
effectively in conjunction with decisions. Also,
break is an important feature in the switch
statement. Usually loops work well with the
straightforward syntax I showed in the last
session. However, sometimes you need to
fudge things a bit to make a loop behave as
you want. The break and continue
statements provide this addedflexibility.

The break Statement

The break statement causes you to exit

immediately from a loop, as shown in Figure
7-3.

The break statement is often used to handle

unexpected or nonstandard situations that
arise within a loop. For example, here’s a
code fragment that sets the variable isPrime
to 1 if an integer n is a prime number or to 0
if n is not a prime number. (A prime number
is divisible only by itself and 1.) To tell if n is
prime, Use the straightforward approach of
trying to divide it by all the numbers up to n-
1. If any of them divide evenly (with no
remainder), then it’s not prime.
isPrime = 1; // assume n is prime
for(j=2; j<n; ++j) // divide by all
integers from 2 to n-1
{
if(n%j == 0) // if evenly divisible,
{
isPrime = 0; // n is not a prime
break; // no point in looping again
}
}
You want to divide by all the numbers up to
n-1, so you use a for loop with appropriate
expressions. However, if one of the j values
does divide evenly, there’s no use remaining
in the loop and dividing by the remaining the
j values. As soon as the program finds the
first number that divides evenly, it should set
isPrime to 0 and then immediately exit from
the loop. The break statement allows you to
exit from the loop at any time.

The continue Statement

The continue statement is similar to the

break statement in that it is usually activated
by an unexpected condition in a loop.
However, it returns control to the top of the
loop—causing the loop to continue—rather
than causing an exit from the loop. Figure 7-4
shows how this looks.

Whereas the break statement causes an exit

from a loop, the continue statement causes
part of the loop to be “short-circuited” or
bypassed while the loop keeps running. That
is, following a continue, control goes back to
the top of the loop. Here’s an example:
do
{
cout << “Enter dividend: ”;
cin >> dividend;
cout << “Enter divisor: ”;
cin >> divisor;
if(divisor == 0) // if user error,
{
cout << “Divisor can't be zero\n”;
continue; // go back to top of loop
}
cout << “Quotient is ” << dividend /
divisor;
cout “\nDo another (y/n)? ”;
cin >> ch;
} while(ch != 'n');
Division by zero is illegal, so if the user enters
0 for the divisor, control goes back to the top
of the loop and the program prompts for a
new dividend and divisor so the user can try
again. To exit from the loop, the user must
answer ‘n’ to the “Do another” question.

The switch Statement

The switch statement checks a variable and

routes program control to any of a number of
different sections of code, depending on the
value of the variable. Here’s an example:
switch(diskSpeed)
{
case 33: // if diskSpeed is 33
cout << “Long-playing album”;
break;
case 45: // if diskSpeed is 45
cout << “Single-selection”;
break;
case 78: // if diskSpeed is 78
cout << “Old single-selection”;
break;
default: // if nothing matches
cout << “Unknown format”;
}
The switch statement consists of the
keyword switch followed by a variable name
in parentheses. The body of the switch
statement, enclosed in braces, follows. Within
the body are a number of labels, which are
names followed by a colon. In a switch
statement, these labels consist of the
keyword case followed by a constant and
then the colon. When the value of the switch
variable is equal to the constant following a
particular case, control will go to the
statements following this case label. The
above section of code prints different
messages depending on the value of the
diskSpeed variable. If diskSpeed is 33,
control jumps to the label case 33. If
diskSpeed is 45, control jumps to the label
case 45, and so on. If diskSpeed doesn’t
match any of the cases, control jumps to the
default label (or, if there is no default, falls
through the bottom of the switch). Figure 7-5
shows the syntax of the switch statement
and Figure 7-6 shows its operation.

Fig 7-5
Fig 7-6

The variable or expression used to determine

which label is jumped to (diskSpeed, in this
example) must be an integer or a character or
must evaluate to an integer or a character.
The values following the cases must be—or
must evaluate to—integer or character
constants. That is, you can use variable
names or expressions, such as alpha, j+20,
and ch+’0’, as long as alpha, j, and ch
already have appropriate values. Once control
gets to a label, the statements following the
label are executed one after the other from
the label onward. In this example, the cout
statement will be executed. Then what? If the
break weren’t there, control would continue
down to the next cout statement, which is
not what you want. Labels don’t delimit a
section of code, they merely name an entry
point. The break causes control to break out
of the switch entirely. Here’s another
example that might be used in the hot dog
stand program. It gives the user the choice of
three stands for which to record the sale of a
hot dog. The user types a digit from ‘1’ to
‘3’, which is then used as the switch
variable.
cin >> choice;
switch(choice)
{
case '1';
stand1.SoldOneDog();
break;
case '2';
stand2.SoldOneDog();
break;
case '3';
stand3.SoldOneDog();
break;
}
The Conditional Operator

The conditional operator was invented

because a particular construction occurs often
in C++ programs and it is nice to shorten it.
Here’s an example of the lengthy version of
the code:
if(alpha<beta)
min = alpha;
else min = beta;
I have a variable min and I want to set it to
alpha or beta, whichever is smaller. This if…
else statement requires four lines of code
However, using the conditional operator, it
can be shortened min =
(alpha<beta) ? alpha : beta;
The conditional operator is the only C++
operator that operates on three operands. It
consists of two symbols: a question mark and
a colon. First comes a test expression (with
optional parentheses), then the question
mark, then two values separated by the
colon. If the test expression is true, the entire
expression takes on the value before the
colon (here it’s alpha); if the test expression
is false, the entire expression takes on the
value following the colon (beta). Figure 7-7
shows the syntax of the conditional operator
and Figure 7-8 shows its operation.

Fig 7-7
Fig 7-8

Here’s another example. The statement

absvalue = (n<0) ? -n : n;
imitates an absolute value function. (The
absolute value of a number is simply the
number with any negative sign removed.) The
result is -n if n is less than 0 and +n
otherwise.
 Lecture No. 8
Loop control statements: while, do-while, for

To determine how many times to cycle

around a loop, all C++ loops check whether
an expression is true or false. This tells them
whether to cycle one more time or to exit the
loop immediately. Thus, to understand loops
you must first examine what makes an
expression true or false, and how to construct
such true/false expressions. Then you can
examine specific kinds of loops: the while
loop, the do loop, and the for loop.

while Loops

A while loop lets you do something over and

over until a condition changes. The condition
is something that can be expressed by a
true/false value. For example, a while loop
might repeatedly ask the user to enter a
character. It would then continue to cycle
until the user enters the character ‘q’ (for
“quit”).
Here’s an example of a while loop that
behaves just this way:
while(ch != 'q')
{
cout << “Enter a character: ”;
cin >> ch;
}
If the user does not press ‘q’, the loop
continues. Some sample interaction might
look like this:
Enter a character: c
Enter a character: a
Enter a character: t
Enter a character: s
Enter a character: q
A while loop consists of the keyword while
followed by a test expression (also called a
conditional expression or condition) enclosed
in parentheses. The body of the loop is
delimited by braces (but no semicolon), just
like a function. Figure 7-9 shows how this
looks.
Fig 7-9
If the body of the loop consists of only one
statement, you don’t need the braces.
while(n < 100)
n = n * 2; <--One-statement loop body,
so no braces
This loop will keep doubling n until n is not
less than (i.e., becomes greater than or equal
to) 100; it will then terminate. If n has a value
of 1 when the loop is entered, what value will
it have when the loop terminates? That’s
right, 128. The values will go 1, 2, 4, 8, 16,
32, 64, and 128, at which point the loop
terminates (i.e., control goes to the statement
following the loop). Figure 7-10 is a flow chart
of a while loop’s operation.
Note that the test
expression is checked
before the body of the
loop is executed. If the
condition is false when
the loop is entered,
then the body of the
loop will never be
executed. This is
appropriate in some
situations, but it means
you must be careful
that a variable in the
test expression has an
appropriate value
before you enter the
loop. The ch in the first
example must not have
a value of ‘q’ when
you enter the
loop, or the loop body
will never be executed.
The n in the second
loop must be initialized
to a value less than
Fig 7-10

do Loops

The do loop (often called the do while loop)

operates like the while loop except that the
test expression is checked after the body of
the loop is executed. This is nice when you
always want something (whatever is in the
body of the loop) done at least once, no
matter what the initial true/false state of the
condition is. Figure 7-11 (below) shows how
this looks.
Fig 7-11 Fig 7-12

Here’s an example of a do loop. This

fragment repeatedly performs addition on two
numbers entered by the user. When the user
enters 0 for the first number, the loop
terminates.
do
{
cout << “\nEnter two numbers (to quit,
set first to 0): ”
cin >> x >> y;
cout << “The sum is ” << x + y;
} while(x != 0);
A do loop begins with the keyword do,
followed by the body of the loop in braces,
then the keyword while, a test expression in
parentheses, and finally a semicolon. This
arrangement is shown in Figure 7-12 (above).
The do loop is the only loop that is
terminated with a semicolon. The semicolon
is necessary because the test expression
follows the loop body, so the closing brace of
the loop body can’t act as a delimiter for the
entire loop. The do loop has a slightly
dubious reputation among C++ programmers
because its syntax is not quite so clean and
easy to read as that of the while loop. The
consensus is to use a while loop unless
there’s a really good reason to use a do loop.

for Loops

In both the while and do loops, you usually

don’t know, at the time you enter the loop,
how many times the loop will be executed.
The condition that terminates the loop arises
spontaneously inside the loop: The user
answers ‘n’ instead of ‘y’, for example. This
is not the case with for loops.
In a for loop, the number of times the loop
will be executed is (usually) stated at the
beginning of the loop. Here’s a loop that
prints 20 asterisks in a line across the page:
int j; // define the loop variable
for(j=0; j<20; ++j); // cycle 20 times
cout << '*'; // print asterisk
The parentheses following the keyword for
contain three different expressions, separated
by semicolons. In the most common situation,
these three expressions operate on a variable
called the loop variable, which in this example
is j. These three expressions are
• The initialization expression, which usually
initializes the value of a loop variable.
• The test expression, which usually checks
the value of the loop variable to see whether
to cycle again or to quit the loop.
• The increment expression, which usually
increments (or decrements) the value of the
loop variable.
In the example, the loop variable j is given
an initial value of 0, then the test expression
is evaluated. If this expression is true (if j is
less than 20), the body of the loop is
executed and the increment expression is
executed (j’s value is increased by 1). If the
test expression is false, the loop terminates.
Figure 7-13 shows the syntax of the for loop,
and Figure 7-14 depicts its operation.

Fig 7-13 Fig 7-14

How many times will the loop in the example
be executed? 20 times. The first time through
the loop, j is 0; the last time, it’s 19. (It does
not run from 1 to 20, as you might expect.)
Starting at 0 and continuing until the loop
variable is 1 less than a constant is the most
common arrangement in for loops because,
among other reasons, array indexes (which
you’ll learn about in Chapter 3) typically start
at 0 and go up to 1 less than the size of the
array. If you did want the loop variable to run
from 1 to 20, you could write
for(j=1; j<=20; ++j)
// body of loop
where the less-than-or-equals operator is
used instead of the less-than operator.
However, this is not a common idiom in C++.
Notice that, as in the while loop, the test
expression is evaluated before the loop body
is executed the first time. Thus, the loop body
may not be executed at all if the test
expression is false to begin with. Here’s
another example of a for loop, this one with
multiple statements in the loop body. As in
the other loops, multiple statements must be
surrounded by braces.
int j; // define loop variable
int total = 0; // define and
initialize total
for(j=0; j<10; ++j) // cycle 10 times
{
total = total + j; // add j to total
cout << total << ' '; // display total
}
This fragment will display the sequence
0 1 3 6 10 15 21 28 36 45
Notice that there is no rule that says that the
loop variable must be increased by 1 each
time through the loop. You can also decrease
it by 1:
for(j=10; j>0; --j)
cout << j << ' ';
which will display
10 9 8 7 6 5 4 3 2 1
or you can increase it or decrease it by any
other amount. This code
for(j=0; j<100; j=j+10)
cout << j << ' ';
will display
0 10 20 30 40 50 60 70 80 90
There is a surprising amount of flexibility in
what you can put in the three expressions in
a for loop. For example, you can use
multiple statements in the initialization
expression and the test expression. Here’s an
example of a for
loop with such multiple statements:
for(j=0, total=0; j<10; ++j,
total=total+j)
cout << total << ' '; // display total
This loop prints
0 1 3 6 10 15 21 28 36 45
as in the earlier example. However, here the
variable total is set to 0 in the initialization
expression instead of before the loop, and
increased by j in the increment expression
instead of in the loop body. The individual
statements in these expressions are
separated by commas. Another option is to
leave out any or all of the three for loop
expressions entirely, retaining only the
semicolons. Generally, taking advantage of
the flexibility of the for loop in these ways
causes more confusion than it’s worth, but
big-time C gurus enjoy it.

Nested Loops
You can nest one loop inside another. For
example, the following program fragment
prints a 10 by 10 square of Xs,
like this:
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
in the upper-left corner of the screen.
for(y=0; y<10; y++) // outer loop,
drops down line-by-line
{
for(x=0; x<10; x++) // inner loop,
goes across char-by-char
cout << 'X'; // print 'X'
cout << endl; // go to new line
}
Of course, you can embed any kind of loop
inside any other kind of loop, and loops can
be nested in loops that are nested in other
loops, and so on.
 Lecture No. 9
Simple Functions
/

What is a function?

A function is a structure that has a number of program

statements grouped as a unit with a name given to the
unit. Function can be invoked from any part of the C++
program.

Features of Function:

To understand why the program structure is written

separately and given a name, the programmer must have a
clear idea of the features and benefits of function. This
will encourage better understanding of function usage:
Use of Functions gives a Structured Programming
Approach
Reduces Program Size:
The piece of code that needs to be executed, or the piece
of code that is repeated in different parts of the program,
can be written separately as a function and stored in a
place in memory. Whenever and wherever needed, the
programmer can invoke the function and use the code to
be executed. Thus, the program size is reduced.
Having known about the function and its features let us
see how to declare, define and call a function in a C++
program.

Declaring a Function:

It has been discussed that, in order for a variable to be

used, it must be declared. Just like variables, it follows
that function definitions must be declared. The general
method of declaring a function is to declare the function
in the beginning of the program.
The general format for declaring a function is
return_datatype function name(arguments);

Suppose we have a function named as exforsys which

return nothing from the function it is declared as

void exforsys( );

This declared would inform the compiler that the

presence of the function exforsys is there in the program.
In the above the return type void tells the compiler that
the function has no return value and also the empty braces
( ) indicate that the function takes no arguments.

Defining a function:

The definition is the place where the actual function

program statements or in other words the program code is
placed.
The general format of the function definition is as
follows:
return_datatype functionname(arguments) //Declarator
{
…….. program statements //Function Body
……….
}
In the above the declarator must match the function
declaration already made. That is the function name, the
return type and the number of arguments all must be same
as the function declaration made. In fact if arguments are
declared and defined. The order of arguments defined
here must match the order declared in the function
declaration.
After the declarator the braces starts and the function
body is placed. The function body has the set of program
statements which are to be executed by the function. Then
the function definition ends with } ending braces.
For example let us see how to define a function exforsys
declared as void that prints first five integers.
void exforsys( )
{ int i;
for (i=1;i<=5;i++)
cout<< i;
}
The output of the function when it is called would be:
12345

Calling the function:

The function must be called for it to get executed. This

process is performed by calling the function wherever
required.
The general format for making the function call would be
as follows:
functionname();
When the function is called the control, transfers to the
function and all the statements present in the function
definition gets executed and after which the control,
returns back to the statement following the function call.
In the above example when the programmer executes the
function exforsys, he can call the function in main as
follows:
exforsys();
a complete program in C++ to help the programmer to
understand the function concepts described above:
#include
void main( )
{
void exforsys( ); //Function Declaration
exforsys( ); //Function Called
cout<<”\n End of Program”;
}
void exforsys( ) //Function Definition
{
int i;
for(i=1;i<=5;i++)
cout<< i;
}
The output of the above program is 12345
What is an argument?
An argument is the value that is passed from the program
to the function call. This can also be considered as input
to the function from the program from which it is called.
How to declare a function passed with argument

Declaring a function:

The general format for declaring the function remains the

same as before except the data type passed as arguments
in functions are in the same order in which it is defined in
function.
The format for declaring a function with arguments is:
return_datatype functionname(datatype1,datatype2,..);
In this example, the data types are the types of data
passed in the function definition as arguments to the
function. Care must be taken to mention the number of
arguments and the order of arguments in the same way as
in function definition.
For example, suppose a function named exforsys takes
two integer values as arguments in its functions definition
and returns an integer value. The function declaration of
exforsys would be written:
int exforsys(int,int);

Function Definition:

The function definition has the same syntax as the

function definition previously defined, but with added
arguments. The general format for defining a function
with arguments is written as:

return_datatype functionname(datatype1
variable1,datatype2 variable2,..)
{
Program statements
………….
return( variable);
}
In the above example, the return data type defines the
data type of the value returned by the function. The
arguments are passed inside the function name after
parentheses with the data type and the variable of each
argument. Care must be taken to mention the number of
arguments and the order of arguments in the same way as
in function declaration.
For example, if the function exforsys takes two integer
values x and y and adds them and returns the value z the
function definition would be defined as follows:

int exforsys(int x,int y)

{
int z;
z=x+y;
return(z);
}
In the above program segment, a return statement takes
the general format
return(variable) ;

This value specified in the return as argument would be

returned to the calling program. In this example, the value
returned is z, which is an integer value, the data type
returned by the function exforsys is mentioned as int.

Calling the function by value:

The calling of function takes the same syntax as the name

of the function but with value for the arguments passed.
The function call is made in the calling program and this
is where the value of arguments or the input to the
function definition is given.

The general format for calling the function with

arguments is

functionname(value1,value2,…);

In the above exforsys function suppose integer value 5

and 6 are passed, the function call would be as follows:

exforsys(5,6);

As soon as the function call exforsys is made the control,

transfers to the function definition and the assignment of
5 to x and 6 to y are made as below.

int exforsys(int x,int y)

exforsys(5,6);
It is possible to store the return value of the function in a
variable. In the above example, the assignment of the
function call to integer variable b can be produced as
follows:
Int b;
b = exforsys(5,6);

The above statement assigns the returned value of the

function exforsys. The value z is then added to the value
of x and y to the variable b. So, variable b takes the value
11.
Let us see the whole program to understand in brief the
concept of function with arguments

The output of the above program would be

#include
int exforsys(int,int);
void main()
{
int b;
int s=5,u=6;
b=exforsys(s,u);
cout&lt;&lt;”\n The Output is:”&lt;
}
int exforsys(int x,int y)
{
int z;
z=x+y;
return(z);
}
The Output is:11
 Lecture No. 10
Functions: Call by reference & Function return
Values

The arguments passed to a function can be performed in

two ways:
Passed By Value & Passed By Reference

Passed By Value:

earlier, all examples for the function with arguments were

passed by value. Arguments passed by value are the
copies of the values of variables and are passed to the
function. The variables defined in the calling function are
not passed in this manner.
For example:
int s=5, u=6;
int z;
z = exforsys(s,u)

would pass values as

int exforsys(int x, int y)

z = exforsys(5,6);
Thus, the copies of the values 5 and 6 are passed to the
function definition and not the variables s and u. Thus,
any changes in the variable x and y would not have any
effect or change the variables s and u. Because s and u
are not passed in this manner, only copies of the variables
are passed to the function definition.

Passed By Reference:

Passed by reference indicates a contrast in that the

variables are not passed by value. When a variable is
passed by reference, it passes the variable to the function
definition and not the copies of the value. Any changes to
the variable in function definition would effect or reflect
corresponding changes in the variables passed as
reference.
The symbol used for denoting the passed by reference is
& (ampersand).
For Example:
Suppose two integer variables x and y are defined in the
calling function, the main program with values x=5 and
y=4.
Suppose the function exforsys receives the value as
passed by reference from this function it is defined and
called as follows:
#include <iostream.h>
void main( )
{
void exforsys(int&,int&);
//Function Declaration - & denotes passed by reference
int x=5,y=4;
exforsys(x,y);
cout<<”\n The output from Calling program is:”;
cout<<”\n x=”<< x;
cout<<”\n y=”<< y;
}

void exforsys(int& s, int& u)

//Function Definition - & denotes passed by reference
{
s=s*10;
u=u*10;
}

In the above example, the reference arguments are

indicated by the symbol ampersand & following the data
type of the argument. In the above program, since the
variables or arguments are passed by reference the
assignment is as follows:
void exforsys(int& s, int& u)
exforsys(x, y);

The variable x and y are passed to the called function

exforsys where it is associated with variables s and u.
Whatever changes were made in the variable s and u
effect or reflect on the variables x and y respectively and
vice versa. Only in the above, the function multiplied the
value of variable s and u by 10 which is reflected in the
variable a and b. Thus, in this case, it has not returned
any value by using return statement. The programmer
must take careful notice and make use of the passed by
reference concept by returning more than one value. By
using the concept of passing by reference, it is possible to
return more than one value.
The output of the above program would be
The output from Calling program is:
x=50
y=40

So what are Reference Arguments

The short and enigmatic definition is that it’s
another name—an alias—for a variable. Why
would anyone want a different name for a
variable? The most important reason has to
do with function arguments. Recall that when
I pass an argument to a function by value (as
you’ve seen many times already), this value
originates in a variable in the code that calls
the function and is then copied into another
variable in the function itself. The function
then operates on its own copy of the variable;
it cannot access the original variable. But
what happens if I want the function to operate
on the original variable? When this is the
case, I must use a different approach to
specifying the name the function uses for an
argument. By doing this, I can make the
name used by the function refer to the
original variable in the code that called the
function, instead of referring to a newly
created copy of the variable within the
function.

Function return values

Functions can return the following values:
All elementary types: int, char, float, etc. ....
Pointers - to anything, but beware of dangling pointers,
see chapter 6.
References - but beware of dangling references, see
chapter 6.
Structs.
They cannot return arrays, but, of course, they can return
a pointer to an array.
Only one value can be returned.
 Lecture No. 11
Functions: Call by reference

What is Inline Function?

Inline functions are functions where the call is made to
inline functions. The actual code then gets placed in the
calling program.
Reason for the need of Inline Function:
Normally, a function call transfers the control from the
calling program to the function and after the execution of
the program returns the control back to the calling
program after the function call. These concepts of
function saved program space and memory space are used
because the function is stored only in one place and is
only executed when it is called. This concept of function
execution may be time consuming since the registers and
other processes must be saved before the function gets
called.
The extra time needed and the process of saving is valid
for larger functions. If the function is short, the
programmer may wish to place the code of the function in
the calling program in order for it to be executed. This
type of function is best handled by the inline function. In
this situation, the programmer may be wondering “why
not write the short code repeatedly inside the program
wherever needed instead of going for inline function?”
Although this could accomplish the task, the problem lies
in the loss of clarity of the program. If the programmer
repeats the same code many times, there will be a loss of
clarity in the program. The alternative approach is to
allow inline functions to achieve the same purpose, with
the concept of functions.
What happens when an inline function is written?
The inline function takes the format as a normal function
but when it is compiled it is compiled as inline code. The
function is placed separately as inline function, thus
adding readability to the source program. When the
program is compiled, the code present in function body is
replaced in the place of function call.
General Format of inline Function:
The general format of inline function is as follows:
inline datatype function_name(arguments)
The keyword inline specified in the above example,
designates the function as inline function. For example, if
a programmer wishes to have a function named exforsys
with return value as integer and with no arguments as
inline it is written as follows:
inline int exforsys( )
Example:

The concept of inline functions:

#include <iostream.h>
int exforsys(int);
void main( )
{
int x;
cout << “\n Enter the Input Value: ”;
cin>>x;
cout<<”\n The Output is: “ << exforsys(x);
}

inline int exforsys(int x1)

{
return 5*x1;
}

The output of the above program is:

Enter the Input Value: 10
The Output is: 50
The output would be the same even when the inline
function is written solely as a function. The concept,
however, is different. When the program is compiled, the
code present in the inline function exforsys( ) is replaced
in the place of function call in the calling program. The
concept of inline function is used in this example because
the function is a small line of code.
The above example, when compiled, would have the
structure as follows:

#include <iostream.h>
int exforsys(int);
void main( )
{
int x;
cout << “\n Enter the Input Value: ”;
cin>>x;
//The exforsys(x) gets replaced with code return 5*x1;
cout<<”\n The Output is: “ << exforsys(x);
}

When the above program is written as normal function

the compiled code would look like below:

include <iostream.h>
int exforsys(int);
void main( )
{
int x;
cout << “\n Enter the Input Value: ”;
cin>>x;
//Call is made to the function exforsys
cout<<”\n The Output is: “ << exforsys(x);
}

int exforsys(int x1)

{
return 5*x1;
}

A programmer must make wise choices when to use

inline functions. Inline functions will save time and are
useful if the function is very small. If the function is
large, use of inline functions must be avoided.
Default parameters
In a function definition a formal parameter can be given a
default value.
Example.
void init(int count=0, int start=1, int end=100)
{
// body ...
}
Call:
init(); //is equivalent to
init(0,1,100)
//or
init(22,23); //equivalent to
init(22,23,100);
Note: only trailing parameters can be defaulted:
void init(int count=0,int start,int end); //ILLEGAL

Overloaded function names

Consider the following function addf, which adds floats.
float addf(float a, float b)
{
return a + b;
}
If we want to provide an integer add, we might define:
int addi(int a, int b)
{
return a + b;
}
However, in C++, through overloading of function
names, we can use the more natural name add for both,
and the linker will bind the appropriate version -
according to the types of the arguments:
float add(float a, float b)
{
return a + b;
}

int add(int a, int b)

{
return a + b;
}
Caller:
int i,j,k;
float x,y,z;
...
z = add(x,y); // float add(float a, float b); called
k = add(i,j); // float add(int a, int b); called
Function name overloading is made possible, by allowing
the parameter types to become part of function's identity.
Note: the return type is not used in this disambiguation.
Function name overloading finds extensive use in classes:
A class may have a number of constructors, all with the
same name, but each having a different parameter list.
To enable classes, especially within a class hierarchy, to
exhibit uniformity of behaviour; e.g. trivially, many
classes can have an overloaded print function.
 Lecture No. 12
Arrays

Array Fundamentals
An array is a way to group together a number
of variables of a single data type. Arrays are
useful primarily because the individual
variables stored in an array can be accessed
using an index number. This makes it easy to
cycle through the array, accessing one
variable after another.

Defining an Array
To define an array, you tell the compiler to
set aside storage for a given number of data
items of a specified type. You also tell the
compiler the name of the array. Here’s an
example of an array definition that creates
storage for four integers. Give this array the
name age; perhaps it will be used to store the
ages of four people.
int age[4];
The int specifies the type of data to be
stored, age is the name of the array, and 4 is
the size of the array; that is, the maximum
number of variables of type int that it will
hold. Brackets [] (not braces or parentheses)
surround the size. It’s the brackets that tell
the compiler I’m defining an array and not
something else, such as a function. Figure 12-
1 shows the format of this array definition.

You can define arrays of any data type, of

course. Here’s an array of 100 variables of
type float, called foo: float foo[100]; //
100 floats
There is also no problem defining arrays of
types you have created yourself, using
classes:
airtime DenverDepartures[50]; // array
of 50 airtimes
The type of the array can be any kind of class,
whether it behaves like a data type or not:
HotDogStand stands[6]; // array of 6
hot dog stands
Here you have an array of objects that
represent physical objects, not data types. It
doesn’t matter to the compiler.

Array Elements

Each variable stored in an array is called an

element. The elements are numbered. These
numbers are called index numbers or
indexes. Some people also refer to them as
subscripts. The index of the first array
element is 0, the index of the second is 1, and
so on. If the size of the array is n, the last
element has the index n-1. For example, in
the age array, which has a size of 4, the
elements are numbered 0, 1, 2, and 3. This
numbering can be the source of some
confusion. Keep in mind that the last element
in an array has an index one less than the
size of the array. Figure 12-2 shows the array
elements for the age array stored in memory.
(Here each element is assumed to occupy 2
bytes.) The elements have been given the
values 44, 16, 23, and 68. Don’t confuse the
values of the elements with their index
numbers (0 to 3).

Accessing Array Elements

You refer to individual array elements using
their index numbers and the array name.
Somewhat confusingly, the brackets [] are
used again, but in a different context than in
defining an array. As you can see in Figure
12-2, the first element is called age [0], the
second is age [1], and so on. You can make
statements such as age[2] = 23;
which sets element age [2] to a value, and
cout << age[3];
which displays the value of age [3] (which is
68, given the data in Figure 3-2). Remember
that the statement
int age[4];
defines an array of four elements, but the
expression
age[2]
does not define an array of two elements; it
refers to the third element of the array.
The real power of arrays comes from the fact
that you can use a variable, rather than a
constant such as 2, as an array index. For
example, you can print out all the values in
the age array with the code
int age[4]; // define the array
... // (other code inserts values)
for(int j=0; j<4; ++j) // cycle
through four elements
cout << age[j] << endl; // display
each element
Such code is a common idiom in C++. The
for loop cycles through values of j from 0 to
3, which are simply the values of the array
index needed to access each element. Notice
that the expression j<4 uses the size of the
array as a limit, but restricts j to one less
than this value. The output from this
fragment might be something such as
44
16
23
68
depending on what values had been inserted
into the array. To set the elements of the
array age to values obtained from the user,
you might say
int age[4];
...
for(int j=0; j<4; ++j)
{ cout << “Enter the value of element
” << j << “: ”;
cin >> age[j];
}
Interaction with this fragment might be
Enter the value of element 0: 44 <--
User enters 44, 16, etc.
Enter the value of element 1: 16
Enter the value of element 2: 23
Enter the value of element 3: 68

Initializing Array Elements

You can set array elements to a value when
you first define the array. Here’s an example:
int coins[6] = { 1, 5, 10, 25, 50, 100
};
The first element is initialized to 1, the second
to 5, and so on. The equal sign connects the
list of values to the array definition,the values
are separated by commas, and the list is
delimited by braces, as shown in Fig 14.3
below

You could display these values with a for

loop:
for(int j=0; j<6; ++j)
cout << coins[j] << “ ”;
which would produce the output
1 5 10 25 50 100
Here’s another example:
int days_per_month[12] = { 31, 28, 31,
30, 31, 30,
31, 31, 30, 31, 30, 31 };
A surprising feature of array initialization is
that you don’t need to count how many items
are being initialized unless you want to. The
definition
int coins[] = { 1, 5, 10, 25, 50,
100 };
works just as well as the earlier version,
despite not specifying the array size. The
compiler cleverly counts how many values
there are and uses this for the array size.
What happens if you specify an array size but
it disagrees with how many initialization
values are actually on the list? If there are
more values than the array size specified, the
compiler complains. If there are fewer values
in the list than the array size, the compiler
will simply fill out the balance of the array
with 0s. Thus if you want to initialize an array
—of any size—with all 0s, you need only say
int anarray[10] = { 0 }; // initialize
10 ints to 0
The first element is initialized to 0 explicitly
and the remaining 9 are initialized to 0
because no value is given for them. If they
are not initialized, the elements of arrays
declared inside a function will have random
(garbage) values. Arrays declared outside of a
function or class—that is, as external
variables—are initialized to zero
automatically.

Multidimensional Arrays

So far, you’ve looked only at one-dimensional

arrays. You can create arrays of as many
dimensions as you like, and each dimension
can be a different size. Here’s the definition of
a 4 by 3 array:
float sales[4][3]; // define two-
dimensional array
Notice that each array dimension is
surrounded by its own set of brackets. Don’t
write [4,3], as is done in some languages. If
the first dimension represents sales districts
(North, South, East, and West, say) and the
second dimension represents the three
months in a quarter, then I might represent
this array as shown in Fig

Individual array elements are accessed using

two indexes. Thus in Figure above, the
element in the upper-right corner of sales is
sales[0][[2] and the element in the lower-
left corner is sales[3][0]. To display all the
elements of such an array, you would
probably use two nested for loops.
for(int y=0; y<3; ++y) // step from
row to row
{
for(int x=0; x<4; ++x) // step from
column to column
cout << sales[x][y] << ' '; // display
value and a space
cout << endl; // go to next line
}
A two-dimensional array can be looked at as
an array of arrays. The sales array is an
array of four subarrays, each of which has
three elements. The subarrays are one-
dimensional arrays called sales[0],
sales[1], and so on. This way of looking at
things is important if you want to refer to the
subarrays of an array, which is common in
arrays of strings.
To initialize a two-dimensional array, make a
list of lists
float sales[4][3] = { { 1437.07,
234.50, 654.01},
{ 322.00, 13838.32, 17589.88},
{ 9328.34, 934.00, 4492.30},
{12838.29, 2332.63, 32.93} };
where each subarray is initialized with its own
list of numbers separated by commas and
delimited with braces; these four lists are in
turn separated by commas and delimited with
braces. If you initialize an array as shown
here and then use the nested for loops to
display its contents, the output will be
1437.07, 234.50, 654.01
322.00, 13838.32, 17589.88
9328.34, 934.00, 4492.30
12838.29, 2332.63, 32.93
A three-dimensional array would be defined
with the three dimensions in brackets
int cube[4][3][5]; // array of 60 ints
and its elements would be accessed with
expressions such as cube[1][2][3]. Arrays
of higher dimensions can be defined and
accessed similarly.

Danger: Index Out of Range

C++ contains no built-in mechanism to

prevent a program from using an incorrect
index value. If your program generates an
index value that is smaller than 0 or so large
it points beyond the last element of the array,
you may be in for big trouble. If you read data
from nonexistent array elements (really
memory outside your array), you will obtain
meaningless data. However, if you write data
into memory outside your array, you may
write over other data, your program, or who
knows what.
There are two morals here. The first is to be
careful when programming arrays. The
second is that it would be nice to have a “safe
array,” one that automatically checks all
index values to be sure they are in bounds. As
it turns out, you can use a class to create safe
arrays.
 Lecture No. 13
stacks

Postfix Increment Operators

When you store characters in the array name,

you want to start with the array index of 0, as
usual, and then increment this index for each
additional character. Do this with the code
name[n] = ch; // store the character
++n; // increment the index
The second line here is rather short; it’s too
bad I need to devote a whole line of code to
it. In fact, it would be nice if I could cause n
to be incremented inside the same statement
in which it’s used as the array index. Here’s
how this might look:
name[++n] = ch;
it’s perfectly legal syntax as far as the
compiler is concerned. However, there’s a
glitch.The index n starts off at 0, and I want
to put the first character in array element 0,
so I don’t want to increment n until after the
contents of ch have been placed in the array.
Unfortunately, ++n causes n to be
incremented before it is used. The result will
be that the first character of the name will go
in name[1] instead of in name[0]. Is there a
way to increment n after it’s used? The
designers of C and C++ anticipated just this
situation and built the necessary capability
into the increment and decrement operators.
Here’s the statement rewritten so it works
properly:
name[n++] = ch;
When the ++ operator follows its operand, it’s
called a postfix operator. When it precedes its
operand, as you’ve seen several times before,
it’s called a prefix operator. The prefix
operator is applied before the value of the
variable is used, whereas the postfix operator
is used after the variable is used. This is
summarized as follows.
++n Prefix operator Incremented before
being used
n++ Postfix operator Incremented after
being used
Using the postfix operator, I can rewrite the
do loop in EMPLOY1 as
do
{
ch = getche(); // get one char at a
time
name[n++] = ch; // store in “name”
array
} while(ch != '\r'); // quit if
“Enter” key
This saves a line of code, which is widely
believed to make the listing more readable.
You will not be surprised to learn that there is
a postfix version of the decrement operator
(n--) as well as of the increment operator.

The Stack Class

An array is a built-in way to store data, but

arrays are inappropriate in many situations. A
major task of programming is creating other
data-storage structures such as linked lists,
stacks, queues, hash tables, dictionaries, and
vectors. Each such storage structure has
advantages and disadvantages. It’s faster to
access a random data item or easier to add
an item using some containers, whereas
using others, it’s easier to search or sort the
data. As it turns out, data storage structures
belong in another category that lends itself to
being modeled by classes. Along with real-
world objects such as hot dog stands and
data types such as time, you can also model
arrays, linked lists, and so on. Let’s look at an
example in which a class models a stack. A
stack is a data storage structure that is
convenient when you want to access the most
recently stored data item first. This is often
referred to as LIFO, for Last In First Out. It’s
like a stack of trays in a cafeteria. The
dishwasher puts trays on the stack and
customers take them off. The last tray placed
on the stack goes on top, so it’s the first one
to be removed. (That’s why the tray you get
is often still warm and damp; it’s been
recently washed. Trays at the bottom of the
stack may have been there, unused, for
weeks.) Stacks are useful in many
programming situations, such as parsing
algebraic expressions like 2*x+4*(3+y),
where they are convenient for storing
intermediate results. Hewlett Packard
calculators use a stack-based approach to
calculations.

Pushing and Popping

Stacks can hold any kind of data, from basic

types to complicated class objects. However,
like an array, each stack usually holds only
one kind of data, int or float or whatever,
but not a mixture. When you place a value on
a stack, you are said to push it; when you
take a value off, it’s called popping it. Figure
13-1 shows what this looks like.

In this example, I use an array, as instance

data of the Stack class, to store a number of
integers. Listing 13-2 shows STACK1, which
specifies the Stack class and then tests it by
creating a stack, pushing three integers on it,
and then popping them back off and
displaying them.
Listing 13-2 STACK1
// stack1.cpp
// class models a stack
#include <iostream.h>
class Stack // a stack holds up to 20
ints
{
private:
int st[20]; // integers are stored in
array
int top; // index of last item pushed
public:
void init() // initialize index
{
top = -1;
}
void push(int var) // place an item on
the stack
{
st[++top] = var;
}
int pop() // remove an item from the
stack
{
return st[top--];
}
};
void main()
{
Stack s1; // create a stack object
s1.init(); // initialize it
s1.push(11); // push 3 items onto
stack
s1.push(12);
s1.push(13);
cout << s1.pop() << endl; // pop 3
items and display them
cout << s1.pop() << endl;
cout << s1.pop() << endl;
}
When you pop items off a stack, they appear
in reversed order. Thus the output from this
program is
13
12
Notice that use of both prefix and postfix
operators to manipulate the array index has
been done. This instance variable, top,
represents the top of the stack. (Think of a
pointer to the top cafeteria tray.) It’s
initialized to -1 with the init() member
function when main() first starts. When
items are pushed, top is incremented first (+
+top), and only then used as the index, so
top always points one place beyond the last
item pushed. When items are popped, they
are accessed first and then the index is
decremented (top--), so top again points
just above the top of the stack.

An Array Disguised as a Stack

The actual instance data, st, which is used as

the storage mechanism in an object of the
Stack class, is an ordinary array of type int.
However, to the user, a Stack object seems
to operate like a stack: Data is added and
removed with the push() and pop()
member functions, rather than with index
numbers as in an array. The Stack class
wraps an array with class member functions
so it looks, to the user, like a completely
different storage mechanism. This is a
common theme in OOP classes: They create a
new interface between the programmer and
the data. An example of this is the use of
classes to wrap the basic Windows
Application Program Interface (API) functions
in a new and presumably easier-to-use set of
classes and member functions.
 Lecture No. 14
Strings

Strings

Text—such as a name—can be treated strictly

as an array of characters. Loops can be used
to input and output the text from such arrays,
one character at a time. This is all a little
awkward. Text is so common in computer
programs that having to program a loop
every time text must be handled is not
acceptable.
Fortunately, C++ provides a sophisticated
repertoire of ways to simplify text handling.
The C++ method of text handling treats text
as a string, which is a sequence of characters
terminated by a special character. This
approach to text was developed in C, long
before the arrival of OOP, so such strings are
not object oriented. Strings are a key feature
of both C and C++ programming, and often
form the foundation of more sophisticated
string classes.
String Variables

A string is a sequence of characters in which

the last character has a numerical value of 0
(zero). As a character, this value can be
represented by the escape sequence ‘\0’. It
is often called the null character. Using a
special value like this to indicate the end of a
text string means that there is no reason to
store the length of the text as a separate
integer value, as I did in the EMPLOY1
program. Instead, string-handling routines
look for the ‘\0’ to determine when the
string ends.
A string variable is an array of type char. Like
other variables, it may or may not contain a
value at any given time. Here’s how you
would define a string variable called str:
char str[80]; // string variable; can
hold up to 80 characters
When the string variable is first created, no
value is stored in it. Unlike variables of basic
types, string variables can be different sizes;
this one can hold a string of up to 80
characters.
Although they are really arrays of type char,
C++ treats strings in some ways like a basic
data type such as int. For one thing, cin and
cout know how to handle strings, so you can
use ordinary stream I/O to input or output a
string with a single statement. Here’s how
you would create a string variable, read some
text into it from the keyboard, and then
display this same text:
char str[80]; // create a string
variable str
cin >> str; // get text from user,
store in str
<< str; // display text entered by
user
The user types the characters of the string
and then presses . ( This is called entering the
text.)
Figure 14-1(below) shows how the array str
looks in memory after the user has entered
the string “Amanuensis” (which means one
employed to copy manuscripts).
String Constants
You can initialize a string variable to a value
when you define it, just as you can with other
variables. Here’s one way to initialize a string
variable called name to the string “George”:
char name[20] = {'G', 'e', 'o', 'r',
'g', 'e', '\0'};
This is the format used to initialize arrays of
other types: a list of values separated by
commas. However, typing all those quotes
and commas is inefficient to say the least, so
the designers of C and C++ took pity on us
and acknowledged that strings were slightly
more than arrays of type char by allowing
this kind of initialization:
char name[20] = “George”;
where double (not single) quotes delimit text.
A sequence of characters surrounded by
double quotes like this is called a string
constant. Although you can’t see it, a null
‘\0’) is included as the last character of this
string constant “George”; it’s inserted
automatically by the compiler. Thus, although
there are only six characters in the name
George, there are seven characters in the
string constant “George”: six letters and the
‘\0’ character. If you’re creating a string
variable, you must keep this in mind. The
array you define must be large enough to
hold the largest number of characters you will
ever store in it plus one more for the null
character.
char name[6] = “George”; // not OK,
the '\0' won't fit
char name[7] = “George”; // OK, it
just fits
A string constant is a value that can be
placed in a string variable. You might wonder
whether this means you can say
name = “George”; // illegal
In this situation, C++ thinks of a string
variable as an array, and you can’t use the
equal sign to assign a whole bunch of values
to an array, even though the equal sign is
used to initialize an array. As with any array,
you don’t need to specify the number of
elements in a string variable if you initialize it
when you define it. You can say
char somestring[] = “Four score and
seven years ago”;
and the compiler will make somestring just
the right length to hold the string constant
(including the null character). This can save
you a lot of counting.
Improved String I/O

You can use cout and cin for strings.

char str[80];
cin >> str; // get string from user,
store in str
cout << str; // display string entered
by user
Some sample interaction with this program
fragment might look like this:
Caramba! <--user enters this
Caramba! <--program displays this
Used in this way, with the overloaded >>
operator, cin has an unfortunate drawback.
Once it encounters a space (the ‘ ‘
character) typed by the user, it stops reading
the input, so you might have the following
interchange with this program:
Law is a bottomless pit.
Law
Only the word “Law” is stored in str.
Everything else the user typed is lost. To fix
this, you must resort to another construction:
the get() member function of the istream
class. To read a string that may
contain blanks, you can use this construction:
char str[80];
cin.get(str, 80); // get string from
user
cout << str; // display string
Not only does get() handle input that
contains blanks, it also provides an easy way
to ensure that the user won’t overflow the
string array. The first argument to get() is
the name of the array where the string will be
stored; the second is the maximum length of
the string that can be accepted. This length
includes the null character, so you can use
the same number here that you use for the
size of the array. You can then input strings of
up to, in this case, 79 characters.
Using const Variables

The code fragment just shown provides the

motivation to introduce a new keyword.
Notice that the number 80 appears in two
places: as the size of the array str and as
the maximum number of characters that can
be placed in that array by cin.get(). These
numbers should be the same; if they’re not,
the input from get() may overflow the array,
or—less seriously—space may be wasted in
the array because get() can’t fill it up. To
ensure that these numbers are the same, it’s
desirable to use a variable instead of a
numerical constant, like this:
int size = 80; // array size
char str[size]; // define array
cin.get(str, size); // get string from
user
cout << str; // display string
Now if you change the value of size in the
first statement, making size equal to 40, for
example, then both the array size and the
character limit in cin.get() will be changed
automatically, ensuring they remain the
same. This is a safer way to program, but I
can go further. An array size cannot be
modified during the course of a program. This
implies that the variable size should be a
constant, so that the programmer is
prevented from inadvertently modifying it.
But how can a variable be a constant? Using
the keyword const. This keyword is used in
the definition of a variable that cannot
change its value during the course of the
program. Here’s how you might use const:
const int SIZE = 80; // array size:
cannot be changed
char str[SIZE]; // define array
cin.get(str, SIZE); // get string from
user
cout << str; // display string
Use all uppercase letters as a reminder that
SIZE is a constant. Now you can change the
value of SIZE if you want, but only by
rewriting its declaration and recompiling the
program. Attempts by other program
statements to modify it will elicit a compiler
error. Because it cannot be changed, a const
variable must be initialized to a value when
it’s first defined. Old-time C programmers
may remember when a preprocessor
directive, #define, was used to create
constants, as in #define SIZE 80
This construction can also be used in C++,
but it has fallen out of favor because no data
type can be applied to the name, which
means the compiler can’t verify that the
correct type is used. This makes programs
potentially more error prone. The const
keyword can be used to improve program
reliability in a variety of other situations,
notably with function arguments.

Eating Extra Characters

Nothing is perfect, and sometimes when you

mix cin.get() with cin >>, a problem arises
(at least with some compilers). For example,
suppose you say
cout << “Enter the patient's age: ”;
cin >> age; // get a number
cout << “Enter the patient's name: ”
cin.get(name, SIZE); // get a string
The name may not be obtained from the user.
Instead, the program appears to skip right
over the last statement. Why is this? Because,
following the input of the number age, a
newline character ‘\n’) is left behind in the
input buffer. When cin.get() is executed, it
reads the new line from the buffer, assumes
this is all there is to read, and exits. To get rid
of this new line, I can employ another
member function of istream, called
ignore(). Here’s the revised code:
cout << “Enter the patient's age: ”;
cin >> age; // get a number
cin.ignore(10, '\n'); // eat the
newline
cout << “Enter the patient's name: ”
cin.get(name, SIZE); // get a string
Here the ignore() function reads and
discards up to 10 characters (which probably
won’t be there) and the new line. The moral:
If you’re having trouble using cin.get(), try
using cin.ignore() to eat any extra new
lines first.
Library Functions for Strings
As with all library functions, you can find out
more about the string functions by looking
them up in your compiler’s documentation or
online help. These string-oriented library
functions all require the header file STRING.H.

Finding String Lengths

The strlen() function returns the length of a

string used as an argument. Here’s a
fragment in which a string variable s1 is
initialized to “Songs” and the strlen()
function is applied to s1:
char s1[] = “Songs”;
cout << “Length of s1 = ”
<< strlen(s1);
The output would be
Length of s1 = 5
Notice that the terminating ‘\0’ character is
not included in the length reported by
strlen(). Nevertheless, that character is
there in s1, taking up space in memory. The
array s1 is actually 6 bytes long.
Copying Strings

You can copy a string variable or constant to

another string variable using the strcpy()
function.
char src[] = “Songs”; // string
initialized to a value
char dest[80]; // empty string
variable
strcpy(dest, src); // copies the
contents of src into dest
After this statement has been executed, dest
will contain “Songs”. The string src will not
be changed. Notice that strcpy() causes the
string named in its right argument to be
copied to the string in its left argument. If this
right-to-left direction seems backward to you,
remember that it’s how the assignment
operator (=) works: The value on the right is
copied into the variable on the left.
Appending Strings

Appending strings might be called adding

strings. If you append the string “hurry”
onto the string “You better “ the result is
“You better hurry”. Here’s how that might
look as a program fragment:
char s1[80] = “You better ”;
char s2[] = “hurry”;
strcat(s1, s2);
The string s1 is now “You better hurry”.
The library function strcat() appends one
string to another. The cat in strcat() stands
for concatenate, another word for append.
Some languages allow you to concatenate
strings using the + operator, as in s1+s2; this
isn’t permitted with ordinary C strings. Let’s
make a slight change in the previous code
fragment. Will these statements operate
correctly?
char s1[] = “You better ”; // s1 is 12
bytes long
char s2[] = “hurry”; // s2 is 6 bytes
strcat(s1, s2); // Error: now s1 needs
to be 17 bytes
No, because the compiler makes s1 just large
enough to hold “You better “ and
concatenating anything else onto it will
overflow s1, leading to unpredictable but
probably unpleasant results. The moral is,
when you put a string anywhere, you’d better
be sure there’s enough space for it.

Comparing Strings

It’s often useful to compare strings—in

checking passwords, for example. The
strcmp() function compares two strings and
returns a number indicating that the strings
are the same or, if they aren’t the same,
which comes first alphabetically. This function
is case sensitive, so “Smith” is not the same
as “smith”.
char name[] = “Smith”;
n1 = strcmp(name, “Renaldo”); <--
returns 1 (first argument follows
second)
n2 = strcmp(name, “Smith”); <--returns
0 (first argument same as second)
n3 = strcmp(name, “Townsend”); <--
returns -1 (first argument precedes
second)
Some string functions have close cousins that
perform similar but not quite identical tasks.
For example, the stricmp() function
compares two strings in the same way that
strcmp() does but is not case sensitive; the
I stands for case insensitive. Thus it will tell
you that “Blue” and “blue” are identical.
The strncmp() function is also similar to
strcmp(), except that it looks only at a
specified number of characters in the strings
it’s comparing. Many other string functions
have similar variations, signaled by the
addition of a letter in the function name.
Some string functions cannot be used
effectively without an understanding of
pointers. These include functions that search
a string for a given character and search a
string for another string. Because the C++
function library was inherited from C, it is not
based on classes. However, most C++
compilers also include a class library that
contains a string class. For example, Borland
C++ includes a class called cstring.

A Homemade String Class

The motivation for creating a string class

arises from the deficiencies of ordinary C
strings and string functions. Here are a few:

• You must define an array, not a single variable, to store

a string.
• You can’t copy one string to another with the
assignment operator (=).
• The string functions don’t warn you if you overflow a
string array.
• You can’t concatenate strings with the + operator.
• You can’t compare strings with the ==, !=, <, and >
operators.
In this section, I’m going to take a first step
toward creating a homemade string class. I’ll
address the first two items on the list here;
the last three require that you know how to
overload C++ operators, so I’ll defer them
until later. I’ll name the string class xString.
Its instance data consists of an ordinary string
and it includes member functions to initialize
itself to an ordinary string, get a string from
the user, display its own contents, and
append one string to another. A surprising
benefit of making a string into a class is that
you can use the equal sign to set one
xString object equal to another. Listing 14-2
shows STRCLASS.
Listing 14-2 STRCLASS
// strclass.cpp
// uses a class to models strings
#include <iostream.h>
#include <string.h> // for strlen(),
strcpy(), etc.
const int MAX = 80; // maximum length
of xStrings
class xString
{
private:
char str[MAX]; // ordinary C string
public:
void init( char s[] ) // initialize
with string
{
strcpy(str, s);
}
void input() // get string from user
{
cin.get(str, MAX);
}
void display() // display string
{
cout << str;
}
void append(xString xs) // append
argument string
{
if(strlen(str) + strlen(xs.str) < MAX-
1)
strcat(str, xs.str);
else
cout << “\nError: xString too long” <<
endl;
}
};
void main()
{
xString s1, s2, s3; // make xString
objects
s1.init(“Greetings, ”); // initialize
s1
cout << “Enter your name: ”;
s2.input(); // get s2 from user
s1.append(s2); // append s2 to s1
s3 = s1; // set s3 to s1
s3.display(); // display s3
}
In main(), the program creates three xString
objects. It initializes s1 to an ordinary string
using the function init(), gets text from the
user for s2 with the input() function,
appends s2 to s1 with append(), sets s3
equal to s1 using the assignment operator,
and finally displays s3 with display(). This
may not be exactly what you would want to
do with three string objects, but it does
provide a chance to exercise all the member
functions of the xString class.

Arrays of Strings

A commonly used construction is an array of

strings. Such arrays can hold lists of
employee names, passwords, file names, and
so on. In this session, I’m going to create a
class based on an array holding the names of
the days of the week. First, however, I’ll
review the syntax of an array of strings.

Syntax of Arrays of Strings

You can create an array of empty string

variables using a simple two-dimensional
array. Because a string is an array, an array
of strings is an array of arrays.

Arrays of Empty Strings

Suppose you don’t know yet what strings you

want to store but you want to create space
for them. To store five strings, each of which
can be up to 10 characters long, you would
define an array this way:
char names[5][10]; // array of 5
strings
Notice that the number of strings is always
the first dimension given. The length of the
strings (which, because this is an array, must
all be the same) is the second dimension.
Figure 14-3 shows how this looks.

You might write some code so the user could

enter names into this array:
for(j=0; j<5; j++)
{
cout << “Enter name (or press Enter to
exit loop): ”;
cin.get(names[j], 10);
if( strlen(names[j])==0 ) // if user
presses [Enter],
break; // exit from loop
}
Here the for loop won’t let the user enter
more than five names. By pressing and thus
inserting a 0-length name into the array, the
user can exit the loop after entering fewer
than five names. Notice that a single string is
referred to as names[j], with only one index.
This is how you refer to one sub-array in a
two-dimensional array.

Arrays of Initialized Strings

You can initialize the strings in an array of

strings when you create them. Here’s an
example in which I store the days of the
week:
const int MAX = 10; // maximum length
of day name, +1
const int DPW = 7; // days per week
const char day_name[DPW][MAX] = //
array of day names
{ “Sunday”, “Monday”, “Tuesday”,
“Wednesday”,“Thursday”, “Friday”,
“Saturday”};
The string constants used for initialization are
separated by commas and surrounded by
braces, just as constants are in one-
dimensional arrays. This causes each string
constant to be installed in the appropriate
subarray of day_name.
Figure 14-4 shows how this looks.

Figure 14-4
shows that there is some space wasted at the
ends of the shorter string constants because
all the string variables are the same length.
You can avoid this if you use pointers,
Variable names MAX and DPW are used for
the array dimensions and made them type
const. The entire array type has been made
const because presumably the days of the
week will never need to be changed.
 Lecture No. 15
Structures

A C++ structure is a way to group together

several data items that can be of different
types. An array, by contrast, groups a number
of data items of the same type. Structures are
typically used when several data items form a
distinct unit but are not important enough to
become a class. Structures are more
important in C, where there are no classes. In
C++, a class plays many of the roles filled by
structures in C. Nevertheless, there are still
many situations where structures are useful.

Specifying a Structure

Here’s an example of a structure

specification:
struct part
{ int modelnumber;
int partnumber;
float cost; };
A structure consists of the keyword struct,
followed by the structure name (also called
the tag) and braces that surround the body of
the structure. It is terminated with a
semicolon. The body of the structure usually
consists of various data items, which may be
of different types. These individual data items
are called members. ( the individual data
items within an array are called elements.)
Figure 15-1 shows the syntax.

Figure 15-1 Syntax of the structure specifier

A structure is quite similar syntactically to a
class. However, structures and classes are
usually used in quite different ways. Typically,
a class contains both data and member
functions, whereas a structure contains only
data. As with a class, a structure specification
does not actually create a structure. It merely
specifies how a structure will look when it’s
created.
Defining Structure Variables

To define variables of type struct part, you

would say something like part cp1, cp2;
Figure 15-2 shows the relation between a
structure specifier and the variables created
by specification as a blueprint.
Figure 15-2 Structures and structure
variables
There’s a shortcut for defining structure
variables. The variable names are telescoped
into the structure specification, like this:
struct part
{
int modelnumber;
int partnumber;
float cost;
} cp1, cp2;
This code specifies the structure and creates
two variables of that structure at the same
time. A peculiarity of this format is that you
can remove the structure name or tag (part);
it’s not needed because the variables already
know what structure they’re based on. This
shortcut format is not as easy to understand
as using separate statements for the
specification and the definition,

Accessing Structure Members

The dot operator is used to access structure
members, just as it’s used to access member
functions from objects. Here’s how that looks:
struct part // specify structure
{
int modelnumber;
int partnumber;
float cost;
};
part cp1; // define structure variable
cout << “Enter model number: ”
cin >> cp1.modelnumber; // access data
member in structure
cout << “Enter part number: ”;
cin >> cp1.partnumber; // access data
member in structure
cout << “Enter cost: ”;
cin >> cp1.cost; // access data member
in structure
The variable name precedes the dot and the
name of the member data follows it:
cp1.cost. Figure 15-3 shows how this looks if
the user enters 6244, 373, and 217.55 for the
model number, part number, and cost; Figure
15-4 shows how the variable name and
member data name are related to what’s
stored in memory.
Figure 15-3 Structure members in memory
Figure 15-4 The dot operator
Initializing Structure Variables

You can provide initial values for structure

variables just as you can for arrays. Here’s
how you would initialize a structure variable
of type part to the same values seen in
Figure 16-4:
part cp1 = { 6244, 373, 217.55 };

Structure Usage

The array that stores data items and the

index to this array (the top of the stack) are
closely related. You might find it convenient
to combine these two data items into a
structure, and then use the structure as a
single data member of the Stack class.
Listing 15-5 shows how this might look.
Listing 15-5 STRUSTAK
// strustak.cpp
// class models a stack, uses struct
for array and index
#include <iostream.h>
struct stackette // structure
{
int arr[20]; // storage array
int top; // index of top of stack
};
class Stack // class
{
private:
stackette st; // structure variable
public:
void init() // initialize index
{
st.top = -1;
}
void push(int var) // place an item on
the stack
{
st.arr[++st.top] = var;
}
int pop() // remove an item from the
stack
{
return st.arr[st.top--];
}
};
void main()
{
Stack s1; // create a stack object
s1.init(); // initialize it
s1.push(11); // push 3 items onto
stack
s1.push(12);
s1.push(13);
cout << s1.pop() << endl; // pop 3
items and display them
cout << s1.pop() << endl;
cout << s1.pop() << endl;
}
Here the structure stackette holds the array
of integers and the index that points to the
top of the stack (the last item placed in the
array).
struct stackette
{
int arr[20]; // storage array
int top; // index of top of stack
};
The only item of instance data in the Stack
class is now a variable of class stackette.
stackette st;
Member functions of Stack now refer to
individual data members of st, using the dot
operator
st.top = -1;
and
st.arr[++st.top] = var;
Notice that main() is identical to the main()
in the STACK1 program. I’ve modified the
class but kept the class interface the same,
so no rewriting is necessary for the functions
that use the class. It’s doubtful whether in
this particular programming example the use
of a structure provides significant
simplification. However, once I discuss
pointers, you’ll encounter examples where
the use of structures as class members can
indeed clarify the workings of a program.

Structures versus Classes

The use of structures is emphasized as

aggregates of data items. This is the way
structures are usually used. With this
emphasis, structures appear quite different
from classes. We might say that a structure is
a passive grouping of data items, whereas a
class is an active combination of data and
functions. Of course, classes are far more
important in C++ than structures are. Classes
form the very basis of object-oriented
programming, whereas structures are a minor
part of C++ usage.
However, these differences obscure the fact
that the syntax of structures and classes is
almost identical. You can install member
functions within a structure just as you can in
a class, and conversely you can remove the
member functions from a class so that it acts
like a structure.
There is only one real syntactical difference
between a structure and a class: The
members of a structure are public by default,
whereas the members of a class are private
by default. That is, if you don’t use the
keywords public or private, class members
are private.
class Foo
{ // no need for keyword, private by
default
int george;
int harry;
public: // public must be specified
void init()
{ }
void display()
{ }
};
For clarity, I’ll always use the keyword
private in class specifications in the
example programs, but in fact it’s optional. In
structures, the situation is reversed.
struct Bar
{ // no need for keyword, public by
default
void init()
{ }
void display()
{ }
private: // private must be specified
int george;
int harry;
};
In structures, you usually want all the data
members to be public, so you normally leave
out this keyword. These syntax distinctions
are all rather academic because in most
situations, using a structure as a class or vice
versa would simply cause confusion. No
doubt, the designers of C++ borrowed the
syntax of C structures when they invented
classes and then—perhaps to make compiler
design easier—augmented structures to make
them as similar as possible to classes.
 Lecture No. 16
Classes and Objects

Specifying a Class

Here’s a complete specification for the

HotDogStand class:
class HotDogStand
{
private:
int HotDogsOnHand; // dogs remaining
int BunsOnHand; // buns remaining
public:
void displayData() // display data
{
cout << “Hot dogs on hand = ”
<< HotDogsOnHand << endl;
cout << “Buns on hand = ”
<< BunsOnHand << endl;
}
void initData() // get initial data
from user
{
cout << “Enter dogs on hand: ”;
cin >> HotDogsOnHand;
cout << “Enter buns on hand: ”;
cin >> BunsOnHand;
}
void SoldOneDog() // adjust data to
reflect sale
{
--HotDogsOnHand;
--BunsOnHand;
}
}; // end of class HotDogStand
The member functions all operate on the
data, but in different ways. The
displayData() function sends the values of
the data (HotDogsOnHand and BunsOnHand) to
cout so they will be displayed. The
initData() function asks the user for values
and inserts these values in to the data
variables. The SoldOneDog() function
decrements both data items by 1 to reflect
the sale of a hot dog (with bun).

Creating and Interacting with Objects

The purpose of a class specification is to

serve as blueprint for creating objects.
Creating Objects from a Class
Specification

As it turns out, you use the same syntax to

create an object that you use to create a
variable of a basic type such as int or float.
This is no accident. In C++, objects are
treated very much like variables and classes
are treated verymuch like data types. Here’s
how to create an object called stand1 of the
class HotDogStand:
HotDogStand stand1;
What happens when this statement is
executed? First, your program finds the
specification for the HotDogStand class It
figures out how large such an object needs to
be and sets aside enough memory to hold it.
It then gives this memory space a name:
stand1. This is exactly what it would do with
a variable of a basic type. However, stand1
is more complicated because it has several
pieces of data and several member functions
as well. You can create as many objects as
you need.
HotDogStand stand1;
HotDogStand stand2;
HotDogStand stand3;

Or you can also use a single statement to

create multiple objects of the same type.
HotDogStand stand1, stand2, stand3;

Sending Messages to Objects

Once an object has been created, you need to

interact with it. To do this, use its member
functions, that is, the functions described in
the class specification. You call an object’s
member function. This is the same as saying
you send a message to the object. A special
syntax is used for this. When you send a
message to an object, there are two things to
consider. First, which object are you
communicating with? In the case of the hot
dog stands, is it stand1, stand2, or another
stand? Second, what message are you
sending to the object? This is the same as
asking which of the object’s member
functions you are calling. Thus, you need a
syntax with two parts: the name of the object
and the name of the member function. Here’s
how you would send a message to stand1
asking it to display its data with
displayData(): stand1.displayData();
The object name and the function name are
connected by the period symbol (.), which is
called the dot operator or, more formally, the
class member access operator. This rather
ponderous name means that the operator
allows you to access an object’s member
functions or data, but let’s stick with the
handier dot operator. Figure 16-1 shows how
this looks.
Figure 16-1 Syntax for sending a message

When this statement is executed, stand1 will

display its data
Hot dogs on hand = 347
Buns on hand = 298
You can send the same message to a
different object, for example, stand2.
stand2.displayData();
It will then display its data (which is probably
not the same as that in stand1).
Hot dogs on hand = 74
Buns on hand = 82
Similarly, you could send a message to
stand3 telling it to get initial data values
from the user.
stand3.initData();
When this statement is executed, stand3 will
call its initData() function and the following
interaction with the user might take place:
Enter hot dogs on hand: 19
Enter buns on hand: 21
where the user enters the 19 and 21. Once
the stand3 object has been given these
initial values, you could call the
SoldOneDog() function every time a hot dog
is sold at this stand.
stand3.SoldOneDog();
This would cause the HotDogsOnHand and the
BunsOnHand variables in stand3 to be
decremented, although nothing would appear
on the screen. If you then executed
stand3.displayData();
you would see
Hot dogs on hand = 18
Buns on hand = 20
In other words, you can call member
functions of specific objects to make the
objects do useful work for us. This is what
OOP is all about.
What’s Really in an Object?

When you assign one object to another, its

instance data is copied into the other object.
Are its member functions copied as well?
Conceptually, it’s probably easiest to think of
them being copied along with the data:
Everything associated with one object is
copied to another. You probably won’t get
into too much trouble if you assume this is
true. However, that’s not exactly what
happens. The truth is, no matter how many
objects of a given class exist, there is only
one image of each member function stored in
memory. This makes sense, because the
member functions are the same for each
object, unlike instance
data, which in general contains different
values for each object. It would waste
memory to duplicate the member functions,
so all objects share the class member
functions, as shown in Figure 16-2.
Figure 16-2 Objects, data, functions, and
memory

When you call a member function for a

certain object, as in
t2.display(); // display t2
you always call the same display()
function, but it operates on different data,
depending on what object called it. In this
case, display() operates on the data stored
in t2.

Member Function with Arguments

There’s more than one way to design a class.

In the airtime class I initialized the values of
an object’s data members by having a
member function request the values directly
from the user. However, I could instead pass
these values as arguments to the member
function. This would shift the responsibility for
getting user input from the class to the
main() function. Revise the set() member
function from the airtime class, as seen in
the TIME1 program, so that it obtains values
as arguments rather than from the user. Let’s
also revise main() to handle user input, as
shown in Listing 16- 3.
Listing 16-3 TIME2
// time2.cpp
// a class that models a time data
type
// uses arguments to the set()
function
#include <iostream.h>
class airtime
{
private:
int hours; // 0 to 23
int minutes; // 0 to 59
public:
void set(int h, int m) // set airtime
value
{ // (values supplied by arguments)
hours = h; minutes = m;
}
void display() // display airtime
value
{
cout << hours << ':' << minutes;
}
};
void main()
{
int hhs, mms; // variables for user-
supplied values
char dummy; // for colon
airtime t1, t2; // two airtime
variables
cout << “For t1, enter time (format
23:59): ”;
cin >> hhs >> dummy >> mms;
t1.set(hhs, mms); // set t1 values
cout << “For t2, enter time (format
23:59): ”;
cin >> hhs >> dummy >> mms;
t2.set(hhs, mms); // set t2 values
cout << “\nt1 = ”;
t1.display(); // display t1
cout << “\nt2 = ”;
t2.display(); // display t2
}
The set() member function now takes two
arguments: h and m. The body of the function
simply sets the hours and minutes instance
data items to the values of these arguments.
void set(int h, int m) // (values
supplied by arguments)
{
hours = h; minutes = m; // set airtime
value
}
Notice the breakdown of effort between the
two parts of this program, the class
specification and main().Compared with the
TIME1 program, the set() function is
simpler, but main() has become more
complicated. Actually, in this particular case,
this is probably a mistake. The idea in OOP is
that classes will be created once but will be
used many times in many different programs.
Thus it makes sense to embed as much
functionality as possible within the class so
that every program that uses the class can be
simpler.

Arguments of Any Type

Arguments may be of any type, and there can

be any number of arguments to a function.
Here’s the skeleton for a member function
that takes three arguments of different types:
class Foo
{
…
void func(int ivar, float fvar, char
cvar) // define function
{
}
…
};
main()
{
Foo foo; // make an object
int iarg = 17; // make some variables
float farg = 6.025e23;
char carg = 'x';
…
foo.func(iarg, farg, carg); // call
the function
…
}
I specify a class Foo with a member function
func() that takes three arguments of three
different types. Then in main(), I create an
object of class Foo and call func() for this
object.
 Lecture No. 17
Objects as function arguments

Objects as Function Arguments

You can write a member function that will

alter one of the data values of an object. Eg
the addhour() function in the HOURADD
program. However, this is not the same as
performing arithmetic on an entire object all
at once. In fact, you can perform arithmetic
on user-defined types just as you can on basic
types like float; this is a powerful capability
of C++. As examples, I’ll show how to add
two airtime values and how to multiply an
airtime value by a number of type float.
Along the way, you’ll see how user-defined
data types can be used in function
arguments.

Adding airtime Values

The add() member function in the airtime
class takes two time values as arguments,
adds these values, and places the result in
the object that called it. That is, if add() is
called like this t3.add(t1, t2);
then t1 will be added to t2 and the result
placed in t3. For example, if t1 is 10:10 and
t2 is 2:30, then the result placed in t3 will
be 12:40. (Technically, this amounts to
adding a time interval, not another time, to a
time. Adding 2 o’clock to 3 o’clock doesn’t
really make much sense, but if you leave
Denver at 10 minutes after 10 and it takes
you 2 hours and 30 minutes to fly to Dallas,
then it does makes sense to say you’ll arrive
there at 12:40.) Listing 17-1 shows TIMEADD.
Listing 17-1 TIMEADD // timeadd.cpp
// a class that models a time data
type
// includes member function to add two
times
#include <iostream.h>
#include <iomanip.h> // for setw(),
etc.
class airtime
{
private:
int minutes; // 0 to 59
int hours; // 0 t0 23
public:
void set()
{
char dummy; // for colon
cout << “Enter time (format 23:59): ”;
cin >> hours >> dummy >> minutes;
}
void display() {
cout << hours << ':'
<< setfill('0')
<< setw(2) << minutes; }
void add(airtime at1, airtime at2)
{
minutes = at1.minutes +
at2.minutes; // add minutes
hours = at1.hours + at2.hours; // add
hours
if(minutes > 59) // if carry,
{
minutes = minutes - 60; // adjust
minutes
hours = hours + 1; // and hours
}
if(hours > 23) // if carry,
hours = hours - 24; // adjust hours
}
};
void main()
{
airtime t1, t2, t3; // create three
airtime variables
char choice;
do
{
cout << “For t1, ”;
t1.set(); // set t1
cout << “For t2, ”;
t2.set(); // set t2
t3.add(t1, t2); // add t1 and t2,
result in t3
cout << “t3 = ”;
t3.display(); // display t3
cout << “\nDo another (y/n)? ”;
cin >> choice;
} while(choice != 'n');
}
Figure 17-2 shows how the function call
t3.add(t1, t2) interacts with the the add()
function.
Figure 17-2 Operation of function call with
arguments

It’s important to notice that you can use

function arguments of types (classes) you’ve
defined yourself (airtime in this case) just as
you can with basic types such as int. Here
the add() member function takes two values
of type airtime as arguments:
void add(airtime at1, airtime at2)
This is a powerful capability. Variables of a
user-defined type can be treated almost
exactly the same way as basic types in every
aspect of C++ programming. The add()
function adds the minutes for the two
airtime values, then adds the hours. If the
sum of the minutes exceeds 59, then 1 hour
is added to hours and 60 is subtracted from
minutes. If the sum of the hours exceeds 23,
then 24 is subtracted from hours. If using
functions such as add() to carry out
arithmetic seems crude, rest assured that you
will eventually learn how to perform
arithmetic operations by overloading the
arithmetic operators such as + and *. This
will make for more natural-looking arithmetic
expressions, like
t3 = t1 + t2;
instead of t3.add(t1, t2);
Arithmetic Is Not for All Classes

It makes sense to add objects of type

airtime because such objects represent a
quantity that is basically numerical: time.
However, addition doesn’t make sense for
objects of all classes. If I add two objects of
the hotdogstand class, for example, it’s not
clear what meaning the “sum” would have.

Access to Private Data

Notice that the add() member function can

access the private data members of the
objects passed to it as arguments. It receives
copies of the data in t1 and t2 when it’s
called in the statement t3.add(t1,
t2); // add t1 and t2, result in t3
These values are copied in the function’s at1
and at2 objects. Statements within the
function can then access individual data
items using the names at1.minutes, and so
on. This is done in the statements
minutes = at1.minutes +
at2.minutes; // add minutes
hours = at1.hours + at2.hours; // add
hours
As you may recall, private data items such as
at1.minutes cannot be accessed by main()
directly. Because they are private, they can
be accessed only by member functions of
their own class. However, member functions
can access the private data, not only of the
object for which they are called (t3 in this
example) but of any object, provided it’s from
the same class (as t1 and t2 are). An
object’s data is private to the outside world,
but not to other objects of its own class.
Figure 17-3 shows how this looks.
Figure 17-3 Accessing other objects

Let’s try some sample interaction with the

TIMEADD program.
For t1, Enter time (format 23:59):
10:10
For t2, Enter time (format 23:59):
10:50
t3 = 21:00
Do another (y/n)? y
For t1, Enter time (format 23:59):
23:59
For t2, Enter time (format 23:59):
0:01
t3 = 0:00
Do another (y/n)? n

Returning a Value from add()

C++ is nothing if not versatile, and there are

often many ways to carry out a given task. As
an example, I’ll rewrite the add() member
function of airtime so that it returns a value
instead of storing the result of its addition in
the object that called it. As you may
remember, add() in the TIMEADD program
was called this way t3.add(t1, t2);
where the values of t1 and t2, passed as
arguments, were added and the result was
stored in t3, the object that called add() in
the first place. However, if I use a version of
add() that returns a value, I can rewrite this
statement in a different way t3 =
t1.add(t2);
This is a mixed blessing in terms of clarity. It’s
more natural to assign t3 the result of the
addition, because that’s closer to the way it
would be written in normal algebra:
t3=t1+t2. However, t1 and t2 are now
treated differently: t1 is the object for which
the function is called and t2 is an argument
to the function. This looks odd, because t1
and t2 play the same kind of role.
Listing 17-4 TIMERET
// timeret.cpp
// a class that models a time data
type
// member function to adds times,
returns time value
#include <iostream.h>
#include <iomanip.h> // for setw(),
etc.
class airtime
{
private:
int minutes; // 0 to 59
int hours; // 0 t0 23
public:
void set()
{
char dummy; // for colon
cout << “Enter time (format 23:59): ”;
cin >> hours >> dummy >> minutes;
}
void display()
{
cout << hours << ':'
<< setfill('0') << setw(2) << minutes;
}
airtime add(airtime at2)
{
airtime temp;
temp.minutes = minutes +
at2.minutes; // add minutes
temp.hours = hours + at2.hours; // add
hours
if(temp.minutes > 59) // if carry,
{
temp.minutes = temp.minutes - 60; //
adjust minutes
temp.hours = temp.hours + 1; // and
hours
}
if(temp.hours > 23) // if carry,
temp.hours = temp.hours - 24; //
adjust hours
return temp;
}
};
void main()
{
airtime t1, t2, t3; // create three
airtime variables
char choice;
do
{
cout << “For t1, ”;
t1.set(); // set t1
cout << “For t2, ”;
t2.set(); // set t2
t3 = t1.add(t2); // add t1 and t2,
result in t3
cout << “t3 = ”;
t3.display(); // display t3
cout << “\nDo another (y/n)? ”;
cin >> choice;
} while(choice != 'n');
}
In the add() function, the program creates
an object, called temp, of class airtime. This
is an automatic variable and it will be
destroyed when the function returns, just as
any automatic variable is. Remember, the
compiler treats all variables the same,
whether they are of a built-in type or a type
defined in the program.
 Lecture No. 18
Array of objects
Arrays as Instance Data

An array, like any other variable, can be used

as instance data in classes. Let’s look at an
example in a class called employee. This
class, as you might have guessed, models
people who are employees of a company. In
this version of the class, the information
about the employees is not very complete; it
is limited to a name and an employee serial
number. A full-scale employee class would
include other data, such as home address,
salary, position, and date of first employment.
In this program, treat a name simply as an
array of individual characters and I input and
output each character separately. This
demonstrates how arrays work and may
provide the motivation for learning how to
handle strings in a more efficient way (by
terminating a string with a zero), Figure 18-1
shows an example of a homemade string
stored in memory.
Figure 18-1 Text stored in a homemade
string

The employee Class

The employee class contains three data

items: an array of type char to hold the
letters of a name, an integer n that specifies
the length of the name (i.e., how many
characters are currently stored in the array),
and another integer for the employee serial
number. The member functions that obtain
and display this data for the user are called
input() and output(), respectively. Listing
18-2 shows EMPLOY1.
Listing 18-2 EMPLOY1
// employ1.cpp
// models an employee
// uses array of type char for name
#include <iostream.h>
#include <conio.h> // for getche()
class employee
{
private:
char name[20]; // name (20 chars max)
int n; // length of name
int serial_number;
public:
void input() // get data from user
{ char ch;
n = 0;
cout << “ Enter name: ”;
do
{ ch = getche(); // get one char at a
time
name[n] = ch; // store in “name” array
++n;
} while(ch != '\r'); // quit if
“Enter” key
cout << “\n Enter serial number: ”;
cin >> serial_number;
}
void output() // display employee data
{ cout << “ Name = ”;
for(int j=0; j<n; ++j) // display one
character
cout << name[j]; // at a time
cout << “\n Serial number = ” <<
serial_number;
} };
void main()
{ employee e1, e2;
cout << “Enter employee 1 data” <<
endl;
e1.input();
cout << “Enter employee 2 data” <<
endl;
e2.input();
cout << “\nEmployee 1” << endl;
e1.output();
cout << “\nEmployee 2” << endl;
e2.output();
}
This source file may elicit warning messages
from the compiler, such as “Functions
containing do are not expanded inline” and
“Functions containing for are not expanded
inline.” The compiler prefers that I use
standalone member functions when the
functions contain loops. The compiler will do
the right thing. In main(), the program
creates two employee objects, gets the data
from the user for each one, and then displays
the data. Some sample interaction with the
program looks like this:
Enter employee 1 data <--User enters
data
Enter name: George Harrison
Enter serial number: 1119
Enter employee 2 data
Enter name: Paul McCartney
Enter serial number: 2229
Employee 1 <--Program displays data
Name = George Harrison
Serial number = 1119
Employee 2
Name = Paul McCartney
Serial number = 2229
Arrays of Objects

Just as there can be objects with arrays in them, there can

also be arrays of objects. This is a particularly useful
construction. You will often want to treat a large number
of objects of the same class in a similar way. For
example, you may want to display the data from 100
employee objects. Placing the objects in an array and
using a loop with a member function in it is a simple way
to carry out this task.

Defining an Array of Objects

The syntax for defining an array of objects is

the same as that for defining an array of a
basic type. Of course, you must place the
class specification in your file before you try
to define any arrays of objects (or single
objects, for that matter). If you have already
created the specification for the Xerxes class,
for example, then you can define an array of
objects of this class, called Xarray, like this:
Xerxes Xarray[5]; // array of 5 Xerxes objects
All the data for each object in the array is
stored contiguously in memory. If you assume
that the specification for the Xerxes class
looks like this:
class Xerxes
{ private:
int ivar;
float fvar;
public: // member functions go here
};
then the elements of the array Xarray, each
of which is an object of the class Xerxes, will
look as shown in Figure 18-3.
Figure 18-3 Elements of Xarray in memory

New Syntax for Access

As it happens, you need to learn a new
syntax, or at least a variation on some old
syntax, to reference member functions of
objects stored in an array. Suppose you have
a specification for a class X like this:
class Xerxes
{ ...
public: void afunc()
{
// does something here
}
};
and further suppose that in main(), you’ve
defined an array to 10 objects of class X
Xerxes xa[10]; // array xa of 10 objects of
class Xerxes
Now the question is, how do you call the
member function afunc() for the object that is
in, say, the third element of the array xa? You
know you can’t say xa.afunc(); // no good; xa
is an array, not a single variable because this
gives no indication of which element in the xa
array is calling the function. You need to mix
array notation with the dot operator, like this:
xa[2].afunc(); // accesses afunc() for the third
object in xa
This syntax is straightforward, although it
looks a little odd at first. Notice that the
subscript operator ([]) has higher precedence
than the dot operator, so the expression is
interpreted as (xa[2]).afunc() and not as
xa([2].afunc()). Let’s see how this syntax is
used in an actual program.

Array of airtime Objects

In main() the program defines an array of

airtime objects, obtains data for as many
such objects as the user wants to type, and
finally, when the user has finished with input,
the program displays all the data. Listing 18-4
shows ARRAYAIR.
Listing 18-4 ARRAYAIR
// arrayair.cpp
// creates array of airtime objects
#include <iostream.h>
#include <iomanip.h> // for setw(),
etc.
class airtime
{ private:
int minutes; // 0 to 59
int hours; // 0 to 23
public:
void set()
{ char dummy; // for colon
cout << “Enter time (format 23:59): ”;
cin >> hours >> dummy >> minutes;
}
void display()
{ cout << hours << ':'
<< setfill('0') << setw(2) << minutes;
} };
void main()
{
airtime at[20]; // array of 20 airtime
objects
int n=0; // number of airtimes in
array
char choice;
do
{ // get time from user
cout << “Airtime ” << n << “. ”;
at[n++].set(); // and insert in array
cout << “Do another (y/n)? ”;
cin >> choice;
} while(choice != 'n');
for(int j=0; j<n; ++j) // display
every airtime
{ // in the array
cout << “\nAirtime ” << j << “ = ”;
at[j].display();
}
}
Some sample interaction with the program
looks like this:
Airtime 0. Enter time (format 23:59):
1:01
Do another (y/n)? y
Airtime 1. Enter time (format 23:59):
23:30
Do another (y/n)? y
Airtime 2. Enter time (format 23:59):
10:00
Do another (y/n)? n
Airtime 0 = 1:01
Airtime 1 = 23:30
Airtime 2 = 10:00
The important statements in ARRAYAIR are
at[n++].set(); // insert data into
object in array
which calls the set() member function so
the user can enter data for the object in the
array at index n (and which subsequently
increments n) and at[j].display(); //
display data from object in array
which calls the display() member function
to display the data for the object stored at
index j.
 Lecture No. 19
Constructors
Parameterized constructors, Multiple constructors in a
class

Introducing Constructors

A constructor is a special member function

that’s used to initialize an object. I have used
a member function called init() when I
wanted to give a certain value to an object
just after it was created.

Initialization

What’s wrong with using init()? First of all,

it’s possible for the class user to forget to call
the init(), thereby leaving an object
uninitialized. Second, initialization should be a
one-step process, just as it is when you define
an external variable and it’s set to zero
automatically. But when you use init(), you
have a two-step process: creating the object
and then initializing it. This may seem like a
theoretical distinction. However, initializing an
object automatically when it’s created can
pay big dividends in making a program more
error free and more understandable. The role
of the user-written constructor, then, is to
carry out any initialization that’s necessary
for the object. When you define an object in
your program, like this:
aClass anObj; // make an object the
compiler arranges for the class constructor to
be called when this statement is executed.

Creation

Whether you’ve written an explicit

constructor or not, the compiler generates the
code necessary to create the object, allocate
memory for it, and perform other kinds of
behind-the-scenes initialization. This happens
automatically, just as it does for variables of
basic types such as int. The term constructor
is often used to refer not only to the user-
written initialization function, but also to this
compiler-generated behind-the-scenes
activity.

Destructors

Every object that is created must eventually

be destroyed. Automatic objects (those
created within the body of a function) are
destroyed (automatically!) when the function
returns. This is true of main(), just as it is
with other functions. Conversely, objects
declared as external or static variables are
destroyed only when the program ends. The
class creator can write an explicit destructor
for a class. This destructor typically takes
care of deallocating whatever was allocated
by the constructor. Think of a destructor as
the object’s last will and testament. Whether
the programmer writes a destructor or not,
the compiler supplies a routine to deallocate
the memory occupied by an object and to
perform other clean-up operations when the
object is destroyed. This code is often
included in the meaning of the term
destructor.

Constructors and Destructors in Action

In this program, objects of the class Omega

have no purpose except to announce when
they are initialized and when they are
destroyed. Listing 19-1 shows CONDEST.
Listing 19-1 CONDEST
// condest.cpp
// demonstrates constructors and
destructors
#include <iostream.h>
class Omega
{
public:
Omega() // constructor
{
cout << "I am the constructor" <<
endl;
}
~Omega() // destructor
{
cout << "I am the destructor" << endl;
}
};
void main()
{
cout << "Starting main()" << endl;
Omega om1, om2, om3; // create three
objects
cout << "Ending main()" << endl;
}

Same Name as the Class

A constructor always has exactly the same

name as the class. Why? Well, it has to be
given a standard and distinctive name. Using
the class name helps avoid name clashes,
because you aren’t likely to use this name for
one of your own member functions. In any
case, that’s how the compiler knows you’re
defining a constructor. The destructor has the
same name as the class, but it is preceded by
a tilde (~).

No Return Value

Constructors have no return value, not even

void. It’s hard to imagine what a constructor
would return, and to whom, because it’s
called automatically. The same is true of
destructors. (Because a destructor is called to
do away with an object, it’s hard to imagine
what message a destructor would return to
the code that called it. Maybe You’ll be
sorry!)

What They Do

In the CONDEST example, the constructor

doesn’t actually initialize anything. It simply
displays a message announcing that it’s
executing. Likewise, the destructor doesn’t
clean up anything, it displays a message.
Here’s the output when you run this program:
Starting main()
I am the constructor
I am the constructor
I am the constructor
Ending main()
I am the destructor
I am the destructor
I am the destructor
Notice that there are no function calls in
main(), or anywhere else, to the constructor
or destructor. They are called automatically.
The constructor is called when each object is
created. This happens three times in the
statement Omega om1, om2, om3;
When main() ends, by dropping through the
closing brace, the three objects go out of
scope and are automatically destroyed. The
destructor is called for each one just before
it’s destroyed, as can be seen from the
output. Notice that, like messages from the
grave, these announcements from the
destructor appear after main() has
terminated.
Initializing Variables

Let’s look at a more realistic example, where

a constructor actually performs a useful
activity. Stack program that uses a
constructor instead of the init() function.
Listing 19-2 shows STACKCON.
Listing 19-2 STACKCON
// stackcon.cpp
// class models a stack; uses a
constructor
#include <iostream.h>
class Stack // a stack holds up to 20
ints
{
private:
int st[20]; // integers are stored in
array
int top; // index of last item pushed
public:
Stack() : top(-1) // constructor
{ }
void push(int var) // place an item on
the stack
{
st[++top] = var;
}
int pop() // remove an item from the
stack
{
return st[top--];
}
};
void main()
{
Stack s1; // create a stack object
// (no need to initialize it)
s1.push(11); // push 3 items onto
stack
s1.push(12);
s1.push(13);
cout << s1.pop() << endl; // pop 3
items and display them
cout << s1.pop() << endl;
cout << s1.pop() << endl;
}
The constructor handles the initialization
automatically, which is a considerable
convenience.

Constructor Arguments

It’s nice to initialize objects to fixed values

when they’re created, but it’s even more
useful to initialize them to values that you
supply when you create them.

A Two-Argument Constructor

Let’s see how to use constructor arguments

to initialize an airtime to any specified value
when it’s created. Listing 19-3 shows
TIMECON.
Listing 19-3 TIMECON
// timecon.cpp
// class models time data type; uses
constructor
#include <iostream.h>
class airtime
{
private:
int hours; // 0 to 23
int minutes; // 0 to 59
public: // two-argument constructor
airtime(int h, int m) : hours(h),
minutes(m)
{
}
void display()
{
cout << hours << ':' << minutes;
}
};
void main()
{
airtime t1(7, 54); // initialize t1
cout << "\nt1 = ";
t1.display(); // display t1
}
The output from this program is
t1 = 7:54
I’ve successfully initialized t1 to an airtime
value. Because an airtime object has both
hours and minutes components, a two-
argument constructor is required. Arguments
look much the same in the constructor
definition as they do in any other function.
The data type is followed by a name and the
arguments are separated by commas:
airtime(int h, int m) // looks like an
ordinary function
Of course, you can tell this is a constructor
because there’s no return type.

Figure 5-2 Arguments used as initializers

“Calling” the Constructor

Now you know how to write the constructor.
However, because the constructor is called
automatically, you can’t use a normal
function call to pass it the argument values.
So how should you pass it the values? By
placing them in the object definition, like this:
airtime t1(7, 54);
This looks like a function call. As with function
arguments, the values are placed in
parentheses and separated by commas.
However, don’t be confused: This is the
definition of an object. It creates the airtime
object t1 and initailizes its hours variable to
7 and its minutes to 54.

A No-Argument Constructor

If you don’t explicitly define any constructors,

the compiler automatically generates a
default constructor for you, that is, a
constructor that takes no arguments. This is
why it’s called the default constructor. For
example, there is no problem saying
employee emp1, emp2;
even if I have not explicitly defined any
constructors at all for the employee class.
However, once you’ve defined even one kind
of constructor, no matter how many
arguments it takes, the compiler will no
longer create the default no-argument
constructor for you. You must do it yourself.
Suppose I rewrite main() in TIMECON this
way, without changing the class:
void main()
{
airtime t2; // can't do this
// without a no-arg constructor
airtime t1(7, 54); // initialize t1
cout << "\nt1 = ";
t1.display(); // display t1
}
This would cause an error like
Could not find a match for
airtime::airtime()
because there isn’t any no-argument
constructor to handle the creation of t2. (The
airtime::airtime() format means “the no-
argument constructor of class airtime.”) The
compiler does not supply a default
constructor because there’s another (two-
argument) constructor. However, it’s easy to
create a no-argument constructor. It could
look like this:
airtime()
{ }
Although it doesn’t do anything, this
constructor tells the compiler that I did not
forget to write the constructor, I know what
I’m doing, and not to worry.
 Lecture No. 20
Copy Constructors

Copy Constructors

Copy constructors provide another way to

create objects: by making a copy of an
existing object. I can use copy constructors
overtly in my own programs, but the compiler
also uses them behind the scenes, sometimes
in unexpected ways.

Copying Variables

sigma sigobj; // create an object of

class sigma
The data in the object is initialized to zero or
other appropriate beginning values. This is
the familiar approach to object creation, but
there’s another one. You can also create an
object that’s a copy of an existing object. Do
this with variables of basic types without
thinking too much about it:
int alpha = 27; // create an int with
value 27
int beta = alpha; // create another
int that's a copy of beta
With basic types, copying means making a
new variable of the same type and giving it
the same value. It’s not too complicated
because there’s only one value to worry
about and it’s always copied as is into the
new object. Remember that in the two
statements above, the equal signs are not
assignment operators. The equal signs in
these statements don’t mean I’m assigning a
value to an existing variable, they mean I’m
initializing a variable—as it’s being created—
to a value. There is an important distinction
between assignment and initialization.

Equivalent Syntax

As I noted, a different but equivalent notation

can be used for copying one variable to
another. I can also say int beta(alpha); //
copy alpha to beta
This has exactly the same effect as
int beta = alpha; // copy alpha to
beta
However, the fact that there is no equal sign
helps avoid confusion between assignment
and initialization. This is sometimes called
functional notation. (It’s also used in
constructors, in the initialization list, as
you’ve seen.)

Copying Objects

You can copy objects as well as variables of

basic types:
sigma sigalpha; // create sigalpha
sigalpha.getdata(); // put some data
in sigalpha
sigma sigbeta(sigalpha); // create
sigbeta by copying sigalpha
Here I create sigalpha and give it some data
by calling the member function getdata().
Then I copy sigalpha to sigbeta. Another
way of saying this is that I create sigbeta
and initialize it with sigalpha. Whatever data
was placed in sigalpha by the getdata()
function is presumably transferred
automatically into sigbeta when it’s
initialized. I could say that I’ve cloned the
sigalpha object.

Not the Normal Constructor

When you create an object from scratch,

sigma sigobj; // create an object of
class sigma
a constructor is invoked to initialize sigobj. It
may take arguments and it may not. But if
you copy an object, sigma
sigbeta(sigalpha); // uses copy
constructor to create sigbeta
what entity is responsible for initializing
sigbeta? This also requires a constructor, but
a very special one with a unique argument
type. It’s called the copy constructor.

The Default Copy Constructor

If you don’t explicitly define your own copy

constructor, the compiler creates one for you.
This default copy constructor carries out
awhat’s called a memberwise copy of all the
data from one object to another. Memberwise
means that the default copy constructor
makes no effort to change or interpret any of
the data; it simply copies the value of each
member into the corresponding member in
the other object.
Many times this memberwise copy is just
what you want and there’s no need to create
your own copy constructor. However, when
you want the new object to be different in
some way from the one it’s copied from or
when you want the act of copying to cause
some other side effect, then you must
explicitly define your own copy constructor.
Passing by Value

Notice that there is no point in using const

for arguments that are passed by value.
Passing by value is already a guarantee that
the original variable is safe because the
original variable isn’t passed at all; the
function has access only to its own copy of
the variable. Using const would be gilding
the lily.

A Simple Example of a Copy Constructor

Now that you know how to use const with

function arguments, you can look at a real
copy constructor. Listing 20-1, COPYCON, is
very simple.
Listing 20-1 COPYCON
// copycon.cpp
// demonstrates copy constructors
#include <iostream.h>
class omega
{
private:
int intvar;
public:
omega(int v) : intvar(v) // one-arg
constructor
{ }
omega(const omega& om) // copy
constructor
{
intvar = om.intvar;
cout << "\nI am the copy constructor";
}
};
void main()
{
omega om1(27); // uses one-arg
constructor
omega om2=om1; // uses copy
constructor
omega om3(om1); // uses copy
constructor
}
There are two constructors for a class called
omega: a one-argument constructor and the
copy constructor. You’ve already seen
examples of one-argument constructors so it
should be familiar, but the copy constructor
has some new features.

Just Another Constructor

The copy constructor is in many ways just

another one-argument constructor. It has the
same name as the class and it has no return
value. However, its argument is always of the
same class the function is a member of. The
argument represents the object to be copied.
COPYCON uses the copy constructor twice:
when it makes om2 and when it makes om3:
omega om2=om1; // uses copy
constructor
omega om3(om1); // uses copy
constructor
Both statements initialize a new object to the
value of om1 by calling the copy constructor.
As I noted, the two syntax are equivalent. The
copy constructor prints a message each time
it’s called. Here’s the output of the program:
I am the copy constructor <--when om2
is created
I am the copy constructor <--when om3
is created
The statement in the copy constructor
intvar = om.intvar; // copy the data
item
is necessary to copy the data from one object
to another. If you don’t define a copy
constructor at all, the compiler will generate a
default constructor that will take care of all
this data copying automatically, using a
memberwise copy. But if you do define a copy
constructor, then you are responsible for
carrying out the copy operation for every data
item yourself. In omega, there’s only one such
item, intvar, so copy it.
If you checked the contents of the new
objects, om2 and om3, following their creation,
you would see that they both have intvar
values of 27. You might wonder, if the
compiler will make copy constructors for you,
why worry about them at all? In this simple
example, the user-written copy constructor
doesn’t accomplish anything the compiler-
generated (default) version would not have.
However, as you’ll see in the next session,
there are times when a “smart” copy
constructor—which does things the default
cannot do—is necessary.

Argument Must Be Passed by Reference

The copy constructor takes as its only

argument an object of the same class as
itself. This argument must be passed by
reference.

Argument Should Be const

The argument to the copy constructor should

be const. There’s seldom any reason for the
copy constructor to modify anything in the
object it’s copying from, and guaranteeing
that it can’t perform such modifications is an
important safety feature. You don’t absolutely
need to use const, but it’s a good idea.

Copy Constructors at Work

First lets look at a situation where defining
your own copy constructor is necessary. Then
you’ll see several examples of how the
compiler arranges for the copy constructor to
be called even when it may not be obvious
that an object is being copied.

Numbering the Objects

Objects of the widget class in this program

numbered themselves as they were created,
using a static member variable to record the
total number of objects created to date.
However, suppose I create one widget object
by initializing it with another:
widget w2(w1); // clone w2 from w1
If I have not written my own copy constructor,
this will result in w2 being given exactly the
same widget number as w1, because the data
is simply copied from one object to another.
Also, the count of all the existing objects
won’t be incremented, because the normal
constructor is not called and the default copy
constructor doesn’t know anything about the
count.

An Intelligent Copy Constructor

To fix this, I must define my own copy

constructor. For this example, I’ll use the
omega class from the COPYCON program in
the last session. Its instance data will include
a serial number and a static count of all
objects, as in the widget class, but it will also
include a string representing a name. The
argument to the one-argument constructor
will be a string that gives each object
whatever name the class user wants.
However, I’ll arrange things so that the copy
constructor copies the name variable—
without alteration—into a new object. The
object’s number variable, on the other hand,
will be handled as it is in the widget class:
Each object will get a new number no matter
how it’s created. An object created with the
copy constructor will therefore have the same
name, but a different number than the object
it was copied from. Listing 20-2 shows
COPYCON2.

Listing 20-2 COPYCON2

// copycon2.cpp
// demonstrates copy constructors,
// using objects that number
themselves
#include <iostream.h>
#include <string.h> // for strncpy()
class omega
{
private:
static const int size = 20;
char name[size];
static int total;
int number;
public: // one-arg constructor
omega(char str[]) : number(++total)
{
strncpy(name, str, size);
cout << "\nI am the 1-arg constructor.
I have "
<< "created object " << name << "-" <<
number;
}
// copy constructor
omega(const omega& om)
{
strncpy(name, om.name, size);
number = ++total;
cout << "\nI am the copy constructor.
I have "
<< "created object " << name << "-" <<
number;
}
};
int omega::total = 0;
void main()
{
omega om1("Harriet"); // uses one-arg
constructor
omega om2=om1; // uses copy
constructor
omega om3(om1); // uses copy
constructor
}
In main(), I create one object of class omega,
called om1, and give it the name Harriet.
Because it is the first object created in the
program, it’s given the number 1
automatically by the constructor.
The second and third objects, om2 and om3,
are created by copying om1 with the copy
constructor. They have the same name
variable as om1 because the copy constructor
simply copies name. However, they have
different number variable values because the
copy constructor does the same things the
one-argument constructor does: It increments
the total count and uses the result for the
new number value. Here’s the output from
COPYCON2:
I am the 1-arg constructor. I have
created object Harriet-1
I am the copy constructor. I have
created object Harriet-2
I am the copy constructor. I have
created object Harriet-3

Why the Copy Constructor Must Use a

Reference Argument

You’re now ready to think about why a copy

constructor must take a reference argument
rather than one passed by value. What
happens when an argument is passed by
value? The copy constructor is called to
create a copy. But if the function I’m calling is
the copy constructor, it must call itself to
create the copy. When it calls itself, a new
copy of the object must be created and the
copy constructor calls itself again to create
the copy. In fact, it calls itself an infinite
number of times, or at least until the
computer’s stack overflows and the program
grinds to a halt, perhaps taking the entire
operating system with it. To avoid this
unfortunate scenario, the copy constructor
avoids making copies by passing its argument
by reference.
 Lecture No. 21
Dynamic initialization of objects, Const objects &
Destructors

Dynamic Initialization of objects

Early binding refers to events that occur at compile time.

In essence, early binding
occurs when all information needed to call a function is
known at compile time. (Put
differently, early binding means that an object and a
function call are bound during
compilation.) Examples of early binding include normal
function calls (including
standard library functions), overloaded function calls, and
overloaded operators. The
main advantage to early binding is efficiency. Because all
information necessary to call
a function is determined at compile time, these types of
function calls are very fast.

The opposite of early binding is late binding. As it relates

to C++, late binding refers
to function calls that are not resolved until run time.
Virtual functions are used to
achieve late binding. As you know, when access is via a
base pointer or reference, the
virtual function actually called is determined by the type
of object pointed to by the
pointer. Because in most cases this cannot be determined
at compile time, the object
and the function are not linked until run time. The main
advantage to late binding is
flexibility. Unlike early binding, late binding allows you
to create programs that can
respond to events occurring while the program executes
without having to create a
large amount of "contingency code." Keep in mind that
because a function call is not
resolved until run time, late binding can make for
somewhat slower execution times.

const Objects

Constant variables provide an important safety feature,

helping to save programmers from themselves when they
inadvertently attempt to modify a value that should
remain fixed.
Perhaps you’ve wondered whether it’s possible to use
const not only with basic types but with objects of user-
defined classes as well. In other words, can you say const
zclass zobj; // declare a constant object of class zclass
This might be useful for the same reason it’s useful to use
const with basic types: You want to guarantee that the
data in an object cannot be changed.
As an example, think about the airtime class, suppose you
want an airtime object called noon that always has the
value {12, 0}, that is, 12:00 in 24-hour time. It would be
nice to guarantee that this noon object could not change
its value.
const airtime noon(12, 0);
This is possible, but to make it work, you must make
some modifications to the class specification. Let’s start
off with a program that defines an airtime object noon but
does not use const. Listing 21-1 shows CONSTA1.
Listing 21-1 CONSTA1
// consta1.cpp
// class models time data type
#include <iostream.h>
class airtime
{
private:
int hours; // 0 to 23
int minutes; // 0 to 59
public: // constructor
airtime() : hours(0), minutes(0)
{ }
// copy constructor
airtime(int h, int m) : hours(h),
minutes(m)
{ }
void display(); // declaration
void get(); // declaration
}; // end class airtime
void airtime::display() // output to
screen
{
cout << hours << ':' << minutes;
}
void airtime::get() // input from user
{
char dummy; // for colon
cout << "\nEnter time (format 12:59):
";
cin >> hours >> dummy >> minutes;
}
void main()
{
airtime noon(12, 0); // create noon
cout << "noon = ";
noon.display(); // display noon
noon.get(); // change noon (bad!)
cout << "noon = ";
noon.display(); // display noon
}
The problem here is that there’s nothing to
stop the class user from calling a member
function that changes noon, as happens in the
line noon.get();
which gets a new airtime value from the
user and inserts it in noon. The output from
the program might be
noon = 12:00
Enter time(format 12:59): 1:23
noon = 1:23
Not so good: Noon should not occur early in
the morning. The most obvious way to fix this
might appear to involve adding a const to
the definition of noon:
const airtime noon(12, 0);
But now every time a member function of
airtime is called in main(), as in
noon.display();
the compiler issues a warning along the lines
of
Non-const function airtime::display()
called for const object.
Apparently, the compiler wants me to use
something called a const function.
const Functions

What is a const function? It’s a member

function that guarantees that it won’t change
the object for which it’s called. Specify such a
function by placing the keyword const in the
definition (and the declaration too, if there is
one) just after the parentheses that follow the
function name. Here’s how that looks for the
display() member function of airtime:
class airtime
{
…
void display() const; // const in
declaration
…
};
void airtime::display() const // const
in definition
{
cout << hours << ':' << minutes;
}
Only member functions that do not change an
object’s data should be made const. In this
example, only display() is const. What
about get()? Well, you should never use
get() with a const airtime object, because
get() is expressly designed to modify the
object. You want an error message if you try
to use get() with a const object, so don’t
make this function const. You might think
you should put the const before the function
name, rather than after it:
const void display(); // not a const
function
but this has a different meaning: It specifies
that the return value of the function is const
(which doesn’t make sense here, because the
return type is void). In the example, I show
the functions defined outside the class
specification. If you define the function within
the
class specification, then there’s only one
place to put the const. However, you must
use const with any declaration because
const becomes part of the function name.
The function void display() const is not
the same as the function void display().
Constructors are never const because the
creation of an object requires const to be
changed
This example shows how the parts of the
program fit together when the display()
function is made const. Listing 21-2shows
CONSTA2.
Listing 21-2CONSTA2
// consta2.cpp
// class models time data type
// demonstrates const airtime objects
#include <iostream.h>
class airtime
{
private:
int hours; // 0 to 23
int minutes; // 0 to 59
public: // constructor
airtime() : hours(0), minutes(0)
{ }
// copy constructor
airtime(int h, int m) : hours(h),
minutes(m)
{ }
void display() const; // declare
constant function
void get(); // declare non-constant
function
}; // end class airtime
void airtime::display() const //
output to screen
{ // can be called for const objects
cout << hours << ':' << minutes;
// hours = 2; // error: can't modify
const object
}
void airtime::get() // input from user
{ // cannot be called for const
objects
char dummy; // for colon
cout << "\nEnter time (format 12:59):
";
cin >> hours >> dummy >> minutes;
}
void main()
{
const airtime noon(12, 0); // create
noon
cout << "\nnoon = ";
noon.display(); // display noon
// noon.get(); // warning: attempt to
change noon
airtime at1; // create at1
at1.get(); // OK: at1 is not a const
object
cout << "at1 = ";
at1.display(); // display at1
}
Two airtime variables are defined in main().
The first one, noon, is const, whereas the
second one, at1, is not. The display()
member function is const, because it does
not modify its object, but the get()
memberfunction does modify its object, so it’s
not const. You can call get() for at1 but not
for noon. Here’s the output from the program:
noon = 12:00
Enter time (format 12:59): 1:30
at1 = 1:30
I can modify the nonconstant object at1 but
not the constant noon. Attempting to call a
non-const function for a const object leads
to a warning from the compiler, as you saw
above. However, I can call a non-const
function for any object, whether const or not.
Within a const function such as display(),
it’s illegal to modify any of the class data. You
can verify this byuncommenting the line
hours = 2;
in the display() function and recompiling.
The compiler will tell you something like
Cannot modify a const object in
function "airtime::display() const" If
the use of const with objects is to be
meaningful, the class creator must have
made const those member functions that are
not intended to modify their object. Then if
the class user attempts to call such a member
function with a const object, a warning
results.

Visualizing Construction and Destruction

The class in the example program contains constructors
and destructors that display data about the objects they’re
creating or destroying.

Two Kinds of Total

I’ve split the total variable from the COPYCON3
program, a static member variable of class omega, into
two kinds of total. One, total_ever, records how
many omega objects have ever been created (since the
program started running). The other, total_now, is the
number of currently existing omega objects. The
total_now variable can be less than total_ever if
objects are destroyed. Both constructors increment both
totals, whereas the destructor decrements total_now
but not total_ever. The total_ever variable is
used to number each object as it’s created, as total did
in COPYCON3. I kept the function func() from
COPYCON3. Calling it demonstrates how arguments
passed by value cause the creation of a local object within
the function. I also created a local object explicitly within
the function. Finally, I defined an omega object as an
external variable. All this leads to interesting activity on
the part of omega’s constructors and destructor.
This is a fairly complex program, but the resulting output
rewards a bit of study. Listing 21-3 shows DESTRU.
Listing 21-3 DESTRU
// destru.cpp
// demonstrates constructors,
destructors,
// and storage classes
#include <iostream.h>
#include <string.h> // for strncpy()
class omega
{
private:
static const int size = 20; // array
size
char obname[size]; // array for obname
string
static int total_now; // objects in
existence now
static int total_ever; // objects ever
created
int snumber; // serial number of this
object
public:
// one-arg constructor
omega(char str[]) : snumber(+
+total_ever)
{
strncpy(obname, str, size);
cout << "\n 1-arg constructor creating
"
<< obname << "-" << snumber
<< ". Total=" << ++total_now;
}
// copy constructor
omega(const omega& om) : snumber(+
+total_ever)
{
strncpy(obname, om.obname, size);
cout << "\n Copy constructor creating
"
<< obname << "-" << snumber
<< ". Total=" << ++total_now;
}
~omega() // destructor
{
cout << "\n Destructor destroying "
<< obname << "-" << snumber
<< ". Total=" << --total_now;
}
}; // end class omega
int omega::total_now = 0;
int omega::total_ever = 0;
omega om0("Adam"); // external object
//////////////////////////////////////
//////////////////////////
void main()
{
cout << "\nmain() starting";
void func(omega); // declaration
omega om1("Jane"); // uses one-arg
constructor
omega om2("Paul");
omega om3(om2); // uses copy
constructor
cout << "\nmain() calling func(om1)";
func(om1);
cout << "\nmain() calling func(om2)";
func(om2);
cout << "\nmain() terminating";
#125;
void func(omega og) // argument passed
by value
{
cout << "\nfunc() starting";
omega om4("Mike"); // object is local
to func()
cout << "\nfunc() terminating";
}
The output from DESTRU looks like this:
1_arg constructor creating Adam-1.
Total=1
main() starting
1_arg constructor creating Jane-2.
Total=2
1_arg constructor creating Paul-3.
Total=3
Copy constructor creating Paul-4.
Total=4
main() calling func(om1)
Copy constructor creating Jane-5.
Total=5
func() starting
1_arg constructor creating Mike-6.
Total=6
func() terminating
Destructor destroying Mike-6. Total=5
Destructor destroying Jane-5. Total=4
main() calling func(om2)
Copy constructor creating Paul-7.
Total=5
func() starting
1_arg constructor creating Mike-8.
Total=6
func() terminating
Destructor destroying Mike-8. Total=5
Destructor destroying Paul-7. Total=4
main() terminating
Destructor destroying Paul-4. Total=3
Destructor destroying Paul-3. Total=2
Destructor destroying Jane-2. Total=1
Destructor destroying Adam-1. Total=0
The indented lines are printed by the constructors and the
destructor. The nonindented lines show what part of
main() or func() is executing. The total shown in
the last column is the value of the total_now variable.
As you can see, it shows how many objects exist at a
given moment. Remember that the object’s name,
obname, is copied without change by the copy
constructor. That’s why several different objects can have
the same name, such as Paul. However, each object’s
serial number, snumber, is set equal to the current
total_ever value, so it is unique. It is only possible
for there to be one number object numbered 3 in the
entire program, although there can be both Paul-3 and
Paul-4 objects. The distinction between
numbers and names makes it easier to follow which
objects are created by the one-argument constructor and
which are created by the copy constructor.

Program Features
Let’s examine some important points demonstrated in
DESTRU.

External Variables

I use the one-argument constructor to define om0, which I

initialize as Adam-1, as an external variable. The output
shows that it’s created before main() starts to execute.
External variables are destroyed after all the variables
defined in main() have been destroyed and after
main() itself has terminated, as can be seen in the last
line of the output.
Variables in main()

Within main(), the one-argument constructor is also

used to create om1 (Jane-2) and om2 (Paul-3). Then the
copy constructor copies om2, creating om3 (Paul-4). All
this is reflected in the output. When main() terminates,
these three variables are destroyed in the opposite order
they were created.

Passing by Value

Passing an argument to a function by value causes the

object’s copy constructor to be called, implicitly, to create
a copy for use by the function. This happens twice in
DESTRU: the two calls from main() to func(). In
the first call, Jane-5 is copied from Jane-2. In the second,
Paul-7 is copied from Paul-2.

Local Variables
The function func() creates a local variable, om4. The
first time it’s called, it creates Mike-6; the second time, it
creates Mike-8. These variables are destroyed as soon as
func() returns so, like the argument variable created by
the copy constructor, they don’t stay around very long.
 Lecture No. 22
Static Data members and Member Functions

Static Class Members

Both function and data members of a class can be made

static. This section explains the consequences of each.

Static Data Members

When you precede a member variable's declaration with

static, you are telling the compiler that only one copy of
that variable will exist and that all objects of the class will
share that variable. Unlike regular data members,
individual copies of a static member variable are not
made for each object. No matter how many objects of a
class are created, only one copy of a static data member
exists. Thus, all objects of that class use that same
variable. All static variables are initialized to zero before
the first object is created. When you declare a static data
member within a class, you are not defining it. (That is,
you are not allocating storage for it.) Instead, you must
provide a global definition for it elsewhere, outside the
class. This is done by redeclaring the static variable using
the scope resolution operator to identify the class to
which it belongs. This causes storage for the variable to
be allocated. (Remember, a class declaration is simply a
logical construct that does not have physical reality.) To
understand the usage and effect of a static data member,
consider this program:
#include <iostream>
using namespace std;
class shared {
static int a;
int b;
public:
void set(int i, int j) {a=i; b=j;}
void show();
} ;
int shared::a; // define a
void shared::show()
{
cout << "This is static a: " << a;
cout << "\nThis is non-static b: " <<
b;
cout << "\n";
}
int main()
{
shared x, y;
x.set(1, 1); // set a to 1
x.show();
y.set(2, 2); // change a to 2
y.show();
x.show(); /* Here, a has been changed
for both x and y
because a is shared by both objects.
*/
return 0;
}
This program displays the following
output when run.
This is static a: 1
This is non-static b: 1
This is static a: 2
This is non-static b: 2
This is static a: 2
This is non-static b: 1
Notice that the integer a is declared both inside shared
and outside of it. As mentioned earlier, this is necessary
because the declaration of a inside shared does not
allocate storage. As a convenience, older versions of C++
did not require the second declaration of a static member
variable. However, this convenience gave rise to serious
inconsistencies and it was eliminated several years ago.
However, you may still find older C++ code that does not
redeclare static member variables. In these cases, you
will need to add the required definitions.
A static member variable exists before any object of its
class is created. For example,
in the following short program, a is both public and
static. Thus it may be directly accessed in main().
Further, since a exists before an object of shared is
created, a can be given a value at any time. As this
program illustrates, the value of a is unchanged by the
creation of object x. For this reason, both output
statements display the same value: 99.
#include <iostream>
using namespace std;
class shared {
public:
static int a;

} ;
int shared::a; // define a
int main()
{
// initialize a before creating any
objects
shared::a = 99;
cout << "This is initial value of a: "
<< shared::a;
cout << "\n";
shared x;
cout << "This is x.a: " << x.a;
return 0;
}
Notice how a is referred to through the use of the class
name and the scope resolution
operator. In general, to refer to a static member
independently of an object, you must
qualify it by using the name of the class of which it is
amember.
One use of a static member variable is to provide access
control to some shared
resource used by all objects of a class. For example, you
might create several objects,
each of which needs to write to a specific disk file.
Clearly, however, only one object
can be allowed to write to the file at a time. In this case,
you will want to declare a
static variable that indicates when the file is in use and
when it is free. Each object then
interrogates this variable before writing to the file. The
following program shows how
you might use a static variable of this type to control
access to a scarce resource:
#include <iostream>
using namespace std;
class cl {
static int resource;
public:
int get_resource();
void free_resource() {resource = 0;}
};
int cl::resource; // define resource
int cl::get_resource()
{
if(resource) return 0; // resource
already in use
else {
resource = 1;
return 1; // resource allocated to
this object
}
}
int main()
{
cl ob1, ob2;
if(ob1.get_resource()) cout << "ob1
has resource\n";
if(!ob2.get_resource()) cout << "ob2
denied resource\n";
ob1.free_resource(); // let someone
else use it
if(ob2.get_resource())
cout << "ob2 can now use resource\n";
return 0;
}
Another interesting use of a static member variable is to
keep track of the number
of objects of a particular class type that are in existence.
For example,
#include <iostream>
using namespace std;
class Counter {
public:
static int count;
Counter() { count++; }
~Counter() { count--; }
};
int Counter::count;
void f();
int main(void)
{
Counter o1;
cout << "Objects in existence: ";
cout << Counter::count << "\n";
Counter o2;
cout << "Objects in existence: ";
cout << Counter::count << "\n";
f();
cout << "Objects in existence: ";
cout << Counter::count << "\n";
return 0;
}
void f()
{
Counter temp;
cout << "Objects in existence: ";
cout << Counter::count << "\n";
// temp is destroyed when f() returns
}
This program produces the following
output.
Objects in existence: 1
Objects in existence: 2
Objects in existence: 3
Objects in existence: 2
As you can see, the static member variable count is
incremented whenever an object is created and
decremented when an object is destroyed. This way, it
keeps track of how many objects of type Counter are
currently in existence.
By using static member variables, you should be able to
virtually eliminate any need for global variables. The
trouble with global variables relative to OOP is that they
almost always violate the principle of encapsulation.
Static Member Functions

Member functions may also be declared as static. There

are several restrictions placed
on static member functions. They may only directly refer
to other static members of the class. (Of course, global
functions and data may be accessed by static member
functions.) A static member function does not have a this
pointer. There cannot be a static and a non-static version
of the same function. A static member function may not
be virtual. Finally, they cannot be declared as const or
volatile.
Following is a slightly reworked version of the shared-
resource program from the
previous section. Notice that get_resource() is now
declared as static. As the program
illustrates, get_resource() may be called either by itself,
independent of any object, by
using the class name and the scope resolution operator, or
in connection with an object.
#include <iostream>
using namespace std;
class cl {
static int resource;
public:
static int get_resource();
void free_resource() { resource = 0; }
};
int cl::resource; // define resource
int cl::get_resource()
{
if(resource) return 0; // resource
already in use
else {
resource = 1;
return 1; // resource allocated to
this object
}
}
int main()
{
cl ob1, ob2;
/* get_resource() is static so may be
called independent
of any object. */
if(cl::get_resource()) cout << "ob1
has resource\n";
if(!cl::get_resource()) cout << "ob2
denied resource\n";
ob1.free_resource();
if(ob2.get_resource()) // can still
call using object syntax
cout << "ob2 can now use resource\n";
return 0;
}
Actually, static member functions have limited
applications, but one good use for them is to
"preinitialize" private static data before any object is
actually created. For example, this is a perfectly valid C+
+ program:
#include <iostream>
using namespace std;
class static_type {
static int i;
public:
static void init(int x) {i = x;}
void show() {cout << i;}
};
int static_type::i; // define i
int main()
{
// init static data before object
creation
static_type::init(100);
static_type x;
x.show(); // displays 100
return 0;
}
Lecture No. 23
Inheritance: Derived classes & Base Classes

Introduction to Inheritance

nheritance is the second central concept behind object-

oriented programing, after classes themselves. In fact,
although conceptually inheritance is secondary to the idea
of classes, practically it is the driving force behind OOP.
Why? Because inheritance makes reusability possible.
Reusability means taking an existing class and using it in
a new programming situation. By reusing classes, you can
reduce the time and effort needed to develop a program,
and make software more robust and reliable. If you
develop software for money, you can’t afford to overlook
the savings made possible by reusability. Inheritance also
plays a major role in OOP design. It allows you to
conceptualize a complex program using a new
relationship between program elements.
Reusability

Programmers have always tried to avoid writing the same

code twice, or “reinventing the wheel.” Inheritance is the
latest solution to this problem, and the most powerful.

Rewriting Code

The earliest approach to reusability was simply rewriting

existing code. You have some code that works in an old
program, but doesn’t do quite what you want in a new
project. You paste the old code into your new source file,
make a few modifications to adapt it to the new
environment, and you’re off and running. Except that the
modifications you made, in all probability, have
introduced new bugs. Now you must debug the code all
over again.

Function Libraries
 To reduce the bugs introduced by modification of code,
programmers attempted to create self-sufficient program
elements in the form of functions. The hope was that
functions could be written that were general enough that
they could be used without modification in a variety of
programming situations. Software companies gathered
groups of such functions together into function libraries
and sold them to other programmers. Function libraries
were a step in the right direction, but, functions don’t
model the real world very well, because they don’t
include important data. All too often, functions require
modification to work in a new environment; it was
common for the purveyors of function libraries to provide
source code to make such modifications easier. But again,
the modifications introduced bugs.

Class Libraries

A powerful new approach to reusability appears in OOP:

the class library. Because a class more closely models a
real-world entity, it needs less modification than
functions do to adapt it to a new situation. More
importantly, OOP provides a way—in effect—to modify
a class without changing its code. This apparent
contradiction is achieved by using inheritance to derive a
new class from the old one. The old class (called the base
class) is not modified, but the new class (the derived
class) can use all the features of the old one and
additional features of its own. Figure 23-1 shows how this
looks.

Inheritance and Program Design

Besides making it easier to modify existing program
components, inheritance has another benefit. It provides a
new way of relating one program component to another.
This new relationship gives added flexibility to program
design and allows program architecture to mirror real-
world relationships more accurately. Inheritance is
sometimes referred to as a “kind of” relationship. To see
what this means, let’s first examine another relationship,
composition,
which you can think of as a “has a” relationship.

Composition: A “Has a” Relationship

Every time you place instance data in a class, you are

creating a “has a” relationship. If there is a class
employee and one of the data items in this class is the
employee’s name, I can say that an employee object
has a name. The employee object may also have a
salary, ID number, and so on. This sort of relationship is
called composition because the employee object is
composed of these other variables.
Similarly, in a Stack class, member data may include
an array (to hold the stack’s data) and an index to the top
of the stack. I can say that a Stack object is composed
of an array and a stack-top index. Class member data can
contain objects of other classes as well as variables of
basic types. I might use airtime objects called
Departure and Arrival in an airline’s
FlightInformation class. Or you can imagine a
bicycle class, in which each bicycle object
includes a frame object, two wheel objects, and a
handlebar
object (among other things). Composition in OOP models
the real-world situation in which objects are composed of
other objects. Old-fashioned procedural languages such as
C and Pascal model this “has a” relationship using
structures. A structure can be composed of variables and
other structures. However, there is another relationship
procedural languages cannot model: the “kind of”
relationship.

Inheritance: A “Kind of” Relationship

Inheritance in OOP mirrors the concept that we call

generalization in the real world. If I have a racing
bicycle, a mountain bicycle, and a child’s bicycle, I can
say that these are all specific instances of a more general
concept called a bicycle. Every kind of bicycle has certain
features: two wheels, a frame, and so on. But a racing
bike, in addition to these general features, has narrow
tires and a low weight. A mountain bike also has all the
features of a bicycle, but in addition has fat knobbly tires
and powerful brakes. Similarly, there may be laborers,
executives, scientists, and clerks on a company’s payroll.
These are all specific examples of a more general
category of employees. We use generalization in our
everyday perception of the world. I know that cats, sheep,
and humans are kinds of mammals; trucks, cars, and
buses are kinds of vehicles; that PCs and Macintoshes are
kinds of computers. This sort of relationship is so
common in ordinary life that it makes sense to model it in
computer programs. That’s what
inheritance does.

Not Exactly a Family Tree

Inheritance is often compared to family relationships;

hence the name. However, inheritance in OOP is not quite
the same thing as inheritance in human families. For one
thing, a class can—and usually does—inherit from a
single parent. Also, derived classes tend to have more
features than base classes, whereas human children, as is
well known, often lack qualities possessed by their
parents.

Inheritance Syntax

The simplest example of inheritance requires two classes:

a base class and a derived class. The base class does not
need any special syntax. The derived class, on the other
hand, must indicate that it’s derived from the base class.
This is done by placing a colon after the name of the
derived class, followed by a keyword such as public
and then the base class name, like this:
class Base
{
// member data and functions
};
class Derv : public Base
{
// member data and functions
};
The colon (like the arrow in inheritance diagrams) means
“is derived from.” Thus, the class Derv is derived from
the class Base and inherits all the data and functions
that Base has (although I don’t show any here). I’ll
leave an explanation of the keyword public until later.
(It’s called an access specifier, and the other possibilities
are private and protected, but public is by far
the most commonly used.) Figure 7-2 shows the syntax
used in inheritance.

Listing 23-1 INHERIT

// inherit.cpp
// skeleton classes demonstrate
inheritance
#include <iostream.h>
class Parent
{
private:
float flov; // Parent's data
public:
void pget() // get Parent's data
{
cout << "\n Enter float value: ";
cin >> flov;
}
void pdisplay() // display Parent's
data
{
cout << "flov=" << flov;
}
};
class Child : public Parent
{
private:
int intv; // Child has its own data
public:
void cget() // get data for Child
{
pget(); // call function in Parent
cout << " Enter integer value: ";
cin >> intv; // get Child-specific
data
}
void cdisplay()
{
pdisplay(); // call function in Parent
cout << ", intv=" << intv; // show
Child-specific data
}
};
void main()
{
Child ch; // make a child object
cout << "Requesting data for child
object";
ch.cget(); // get data for it
cout << "Data in child object is ";
ch.cdisplay(); // display its data
}
The Parent class has a data item intv, along with
pget()and pdisplay() member functions. The
Child class has a data item flov and similar
cget() and cdisplay() functions. In main(), the
program creates an object of class Child, gets data for it
from the user, and then displays the data. Here’s how the
interaction with the program looks:
Requesting data for child object
Enter float value: 456.789
Enter integer value: 123
Data in child object is flov=456.789,
intv=123
This may seem mysterious. Although the object ch of
class Child contains only an integer data item, the
output shows it has successfully stored and retrieved a
float item as well. How does this happen?
Inheriting Attributes

An object of a derived class inherits all the member data

and functions of the base class. Thus the Child object
ch contains not only
a data item intv, but a data item flov as well. The ch
object can also access, in addition to its own member
functions cget() and display(), the member
functions from Parent, which are pget() and
pdisplay().

Accessing Base Class Data

Although an object of a derived class may contain data

defined in the base class, it doesn’t necessarily follow that
this data is accessible from the derived class. Assuming
that I want the cdisplay() function in Child to
display Parent’s flov data as well as its own intv,
could I rewrite cdisplay() this way?
class Child
{
...
void cdisplay()
{
cout << "flov=" << flov; // error:
private Parent member
cout << ", intv=" << intv;
}
};
No, I can’t access flov from the Child class, because
flov is a private member of Parent. As is usual in C+
+, public members (data and functions) can be accessed
from outside the class, but private members cannot. It’s
true that the derived class occupies a strange new position
with regard to the base class. Derived class functions
aren’t actually in the base class, but they are more closely
related to the base class than functions in some
completely unrelated class. Nevertheless, they can’t
access private members of the base class.

Calling a Base Class Function

Fortunately, I don’t need to access the base class data

flov from functions in Child objects directly. Unlike
flov, which is private, the member functions of
Parent are public, so I can call them to handle flov.
From cget() I call pget(), which asks the user to
enter a value for flov. From cdisplay() I call
pdisplay(), which displays the value of flov. The
derived class need never access flov directly.

Function Overloading in Base and Derived Classes

In the INHERIT program, there are separate functions to

get user input in the base and derived classes: pget()
for Parent and cget() for Child. Similarly,
pdisplay() displays the data item in Parent and
cdisplay() displays the item in Child. It’s
somewhat confusing, and not in the spirit of OOP, to use
different function names name would be clearer and
easier to remember (among other benefits). It turns out
that it’s perfectly all right to overload functions in base
and derived classes. If I name both functions
display(), we’ll have a situation like this:
class Parent
{
void display()
{ }
};
class Child : public Parent
{
void display()
{
// display(); // bad: calls display()
in Child
Parent::display(); // good: calls
display() in Parent
}
};
The compiler has no trouble distinguishing the two
versions of display() because they’re in different
classes. However, if I use the name display() in a
derived class function, the compiler assumes I mean the
function of that name in the derived class. That would be
disastrous from within display(), because a function
calling itself over and over would eventually crash the
program. In the derived class, to refer to the version of the
function that’s
in the base class, I must use the scope resolution operator
and the base class name: Parent::display();
This makes it clear to the compiler which function I
mean. Listing 23-2, a revised version of the INHERIT
example, shows how it looks when I overload the
member functions, calling both display functions
display() and both input functions get().
Listing 23-2 INHERIT2
// inherit2.cpp
// skeleton classes demonstrate
inheritance
// uses overloaded functions
#include <iostream.h>
class Parent
{
private:
float flov;
public:
void get()
{
cout << "\n Enter float value: ";
cin >> flov;
}
void display()
{
cout << "flov=" << flov;
}
};
class Child : public Parent
{
private:
int intv;
public:
void get()
{
Parent::get();
cout << " Enter integer value: ";
cin >> intv;
}
void display()
{
Parent::display();
cout << ", intv=" << intv;
}
};
void main()
{
Child ch;
cout << "Requesting data for child
object";
ch.get();
cout << "Data in child object is ";
ch.display();
}
This program operates the same way as INHERIT, but
using overloaded functions makes it easier for the class
user to remember the function names. Table 23-1
summarizes how overloaded and normal functions can be
accessed from base and derived classes. I assume there’s
a basefunc() member function in the base class, a
dervfunc() function in the derived class, and an
overloaded func() in both classes.
Table 7-1 Function accessibility from base and derived
classes
Function Is Member of | Overload Status | To Access
Function from Base Class | To Access Function from
Derived Class
Base class | Different names | basefunc() |
basefunc()
Base class | Overloaded | func() | Base::func()
Derived class | Different names | Function is unknown |
dervfunc()
Derived class | Overloaded | Function is unknown |
func()
If functions are not overloaded, the derived class can
access functions in the base class using their name alone.
For overloaded functions, the derived class must use the
scope resolution operator to access functions in the base
class. Of course, inheritance only works one way. The
base class doesn’t know anything about the derived class
and can’t access any of its members.
 Lecture No. 24
Class Hierarchy

Program Design: The employee Class

I’ll start with the employee class of the EMPLOY1

program. This program emphasizes the program design
aspect of inheritance: that is, using inheritance as a basic
way to relate program components. It is less relevant to
the concept of reusability, which I’ll focus on in the next
session. Suppose I want to program a database of
company employees. It’s common for employees to be
divided into different categories. In this company, I’ll
assume there are managers, scientists, and laborers.

Class Hierarchy

When you encounter a situation in which different

categories of things can be described as kinds of
something else, you’re looking at a situation that can be
modeled in a program as inheritance. Managers,
scientists, and laborers are kinds of employees. Here’s
how that looks in C++ in skeleton form:
class employee
{ ... };
class manager : public employee
{ ... };
class scientist : public employee
{ ... };
class laborer : public employee
{ ... };
The three classes manager, scientist, and
laborer are derived from the employee class. All
employees, no matter what derived class they belong to,
share some common elements. For purposes of the
database, let’s assume that they all have a name and an ID
number. In inheritance, such common elements are placed
“upstream,” in the base class. The derived classes have
their own individual characteristics. The characteristics
that are important
about managers are titles, such as “President” or “Vice-
President,” and golf club dues. For scientists, the
important data is the number of publications for which the
scientist has written scholarly articles. Laborers have no
distinguishing characteristics other than their name and
ID number. (A database program does not always mirror
the diversity of real people, with all their hopes and
dreams.) Figure 24-1 shows how this looks.
The full-scale program is rather lengthy, but the
similarities of the classes make it easier to understand
than it might seem at first sight. Listing 24-2 shows
EMPINH
Listing 24-2 EMPINH
// empinh.cpp
// models employee database using
inheritance
#include <iostream.h>
class employee // employee class
{
private:
enum { LEN=30 }; // maximum length of
names
char name[LEN]; // employee name
unsigned long number; // employee
number
public:
void getdata()
{
cout << "\n Enter last name: "; cin >>
name;
cout << " Enter number: "; cin >>
number;
}
void putdata()
{
cout << "\n Name = " << name;
cout << "\n Number = " << number;
}
};
class manager : public employee //
management class
{
private:
enum { LEN=40 }; // maximum length of
titles
char title[LEN]; // "vice-president"
etc.
double dues; // golf club dues
public:
void getdata()
{
employee::getdata();
cout << " Enter title: "; cin >>
title;
cout << " Enter golf club dues: "; cin
>> dues;
}
void putdata()
{
employee::putdata();
cout << "\n Title = " << title;
cout << "\n Golf club dues = " <<
dues;
}
};
class scientist : public employee //
scientist class
{
private:
int pubs; // number of publications
public:
void getdata()
{
employee::getdata();
cout << " Enter number of pubs: "; cin
>> pubs;
}
void putdata()
{
employee::putdata();
cout << "\n Number of publications = "
<< pubs;
}
};
class laborer : public employee //
laborer class
{
};
void main()
{
manager m1, m2;
scientist s1;
laborer l1;
cout << endl;
cout << "\nEnter data for manager
1"; // get data for
m1.getdata(); // several employees
cout << "\nEnter data for manager 2";
m2.getdata();
cout << "\nEnter data for scientist
1";
s1.getdata();
cout << "\nEnter data for laborer 1";
l1.getdata();
cout << "\nData on manager 1"; //
display data for
m1.putdata(); // several employees
cout << "\nData on manager 2";
m2.putdata();
cout << "\nData on scientist 1";
s1.putdata();
cout << "\nData on laborer 1";
l1.putdata();
}
The member functions of manager and scientist
call base class functions in employee to get the
employee name and number from the user and to display
them. They also handle their own particular data, title,
and dues for managers and number of publications for
scientists. The laborer class relies completely on
employee for all data and member functions.

Abstract Classes

You might think I could simply use employee objects

instead of laborer objects, because they have the
same data and functions. However, this violates the spirit
of the program’s organization. As used here, the
employee class is not one from which actual objects
will be instantiated. The only purpose of employee is
to serve as a general class from which other classes are
derived. All real employees are members of a more
specific category. As an analogy, imagine you own a
specific animal called Toby. If someone asked you what
Toby is, you probably wouldn’t say, “Oh, he’s a
mammal.” Everyone would say, “Yes, but what kind of
mammal?” All real animals must come from a more
specific category than simply mammals. (It turns out
Toby is a hamster.) Mammal is a category that has no
members itself, but serves only as a generalization. A
class from which you don’t intend to instantiate any
objects, but is used only as a base class for other classes is
called an abstract class. One of the advantages of using
an abstract class for employee is that if you decide,
sometime after the employee class hierarchy is
designed, to add a data item to the laborer class, then
you can modify laborer without modifying
employee, which would potentially affect all
employee’s derived classes. Abstract classes are a
powerful concept in OOP, and I’ll return to them later.
Interaction with EMPINH

In main(), the program creates four employees: two

managers, a scientist, and a laborer. It then gets the data
for these four employees from the user and displays it.
Here’s some sample interaction with EMPINH. First the
user enters the data:
Enter data for manager 1
Enter last name: Montegue
Enter number: 111
Enter title: President
Enter golf club dues: 500000
Enter data for manager 2
Enter last name: Blakley
Enter number: 222
Enter title: Vice-President
Enter golf club dues: 100000
Enter data for scientist 1
Enter last name: Lee
Enter number: 333
Enter number of pubs: 99
Enter data for laborer 1
Enter last name: Jones
Enter number: 87647162
Then the program plays it back:
Data on Manager 1
Name = Montegue
Number = 111
Title = President
Golf club dues = 500000
Data on Manager 2
Name = Blakley
Number = 222
Title = Vice-President
Golf club dues = 100000
Data on Scientist 1
Name = Lee
Number = 333
Number of publications = 99
Data on Laborer 1
Name = Jones
Number = 87647162

Constructors and Inheritance

It’s not surprising, therefore, that they play an unusual

role in inheritance. In this session, I’ll examine that role,
show you when you need constructors and when you
don’t, and explain how one constructor can call another
using a special syntax.
The Great Chain of Constructors

When you define an object of a derived class, not only is

its constructor executed but the constructor in the base
class is executed as well. In fact—perhaps surprisingly—
the base class constructor is executed first. This is
because the base class object is a subobject—a part—of
the derived class object, and you need to construct the
parts before you can construct the whole. Figure 24-2
shows the

relationship between objects and subobjects.

The constructors for all the subobjects of an object are
called before the constructor for the object itself. The next
example demonstrates this point. Listing 24-3 shows
INCONDES.
Listing 24-3 INCONDES
// incondes.cpp
// tests constructors and destructors
in inheritance
#include <iostream.h>
//////////////////////////////////////
//////////////
class Parent
{
public:
Parent()
{ cout << "\n Parent constructor"; }
~Parent()
{ cout << "\n Parent destructor"; }
};
//////////////////////////////////////
//////////////
class Child : public Parent
{
public:
Child()
{ cout << "\n Child constructor"; }
~Child()
{ cout << "\n Child destructor"; }
};
//////////////////////////////////////
//////////////
void main()
{
cout << "\nStarting";
Child ch; // create a Child object
cout << "\nTerminating";
}
This program specifies a Parent class and a Child class
derived from Parent. In main(), it then creates an object of
the Child class. I’ve installed explicit constructors and
destructors in both classes that identify themselves when
they execute. Here’s the output from INCONDES:
Starting
Parent constructor
Child constructor
Terminating
Child destructor
Parent destructor
As you can see, the base class constructor is called first;
then the derived class constructor is called. When the
Child object goes out of scope at the end of the program,
the destructors are called in reverse order: The derived
object is destroyed first, then the base class object.
The compiler arranges for all these constructors and
destructors to be called automatically, so you don’t need
to worry about it. Even if you haven’t defined explicit
constructors and destructors as I did here, the compiler
will call the implicit (invisible) ones that actually create
and destroy objects and subobjects. You should be aware
that this activity is taking place, whether or not you write
your own explicit constructors and destructors.
Incidentally, an object’s implicit constructor is always
called before the explicit one you define. When your
explicit constructor starts to execute, your object and all
its subobjects already exist and have been initialized.

When Are Derived Class Constructors Necessary?

You saw in the STACKINH program in the last session

that you don’t need to write a no-argument (default)
constructor for the derived class if the base class already
has such a constructor. It turns out this is about the only
time you can get away without explicitly writing a
constructor in the derived class.
No Arguments

You can’t use a constructor with arguments unless it’s

explicitly defined in the specific class from which you’re
instantiating an object. That is, even if there’s an n-
argument constructor in the base class, you must still
write an nargument constructor in the derived class.
Listing 24-4, CONSINH1, shows how this works.
Listing 24-4 CONSINH1
// consinh1.cpp
// demonstrates constructors and
inheritance
//////////////////////////////////////
//////////////////////////
class Mu // base class
{
private:
int mudata; // data
public:
Mu() : mudata(0) // no-arg constructor
{ }
Mu(int m) : mudata(m) // one-arg
constructor
{ }
};
//////////////////////////////////////
//////////////////////////
class Nu : public Mu // derived class
{ // no constructors
};
//////////////////////////////////////
//////////////////////////
void main()
{
Nu n1; // can use the no-arg
constructor in Mu
// Nu n2(77); // error: cannot use
one-arg constructor
}
You can write the specification for class Nu, which is
derived from Mu, without any constructors; the compiler
doesn’t complain. You can also define an object of Nu if
you don’t use any arguments, as seen in the first
statement in main(). But you can’t define a Nu object
that takes arguments unless there’s an appropriate
constructor in Nu itself. The compiler won’t substitute
the constructor from the base class because it can’t be
sure how you want to handle the arguments.

Arguments
If you add an explicit one-argument constructor to the
derived class Mu, then you must also add a no-argument
constructor, just as you must with any class (assuming
you’re actually going to create objects with this
constructor). Listing 24-5 shows the previous program,
rewritten as CONSINH2, with these additional
constructors.
Listing 24-5 CONSINH2
// consinh2.cpp
// demonstrates constructors and
inheritance
class Mu
{
private:
int mudata; // data
public:
Mu() : mudata(0) // no-arg constructor
{ }
Mu(int m) : mudata(m) // one-arg
constructor
{ }
};
//////////////////////////////////////
//////////////////////////
class Nu : public Mu
{
public:
Nu() // no-arg constructor
{ }
Nu(int n) : Mu(n) // one-arg
constructor
{ }
};
//////////////////////////////////////
//////////////////////////
void main()
{
Nu n1; // calls no-arg constructor
Nu n2(77); // calls 1-arg constructor
}
In main(), the program successfully defines Nu objects
using both the no-argument and the one-argument
constructors. The one-argument constructor passes its
argument along to the constructor in Mu using a new
syntax: the initializer list.

The Initializer List

The derived class constructor Nu(int) calls the base
class constructor Mu(int) using a syntax that may
appear strange and yet familiar:
Nu(int n) : Mu(n) // one-arg
constructor
{ }
Everything following the colon is the initializer list,
where initializations are carried out before the constructor
starts to execute. This is the same syntax used by
constructors to initialize variables of basic types, but here
it’s used to call a constructor. Actually these operations
are conceptually identical, so it’s not surprising they use
the same syntax. In one case, a class object is initialized
and in the other, a variable of a basic type is initialized,
but C++ treats class objects and basic-type variables in
the same way. Here the derived class constructor simply
passes the argument n along to the base class
constructor. It takes no action of its own, so the braces are
empty. This is a common situation in derived classes:
Constructors have an empty function body because all
their work is done in the initialization list.

Adding Functionality to the Derived Class

Constructor
Not all derived class constructors have an empty function
body. Suppose I want to add an additional feature to the
airtime class. I want to prevent the class user from
initializing airtime objects with hours or minutes
values that are too large. Hours should be less than 24,
and minutes should be less than 60. (Of course, they
should both be greater than 0 as well, but I won’t worry
about that now.) That is, if the class user writes
airtime Departure(11, 65);
I want the constructor to complain because minutes can’t
be greater than 59 To add this new feature to airtime,
I’ll derive a new class called airtime2, with the
requisite error-checking code in its two-argument
constructor. Listing 24-6 shows AIRINH.

Listing 24-6 AIRINH

// airinh.cpp
// constructors and inheritance in the
airtime class
#include <iostream.h>
#include <process.h> // for exit()
class airtime
{
protected:
int hours; // 0 to 23
int minutes; // 0 to 59
public:
// no-arg constructor
airtime() : hours(0), minutes(0)
{ }
// two-arg constructor
airtime(int h, int m) : hours(h),
minutes(m)
{ }
void display() const // output to
screen
{ cout << hours << ':' << minutes; }
}; // end class airtime
//////////////////////////////////////
//////////////////////////
class airtime2 : public airtime
{
public: // no-arg constructor
airtime2() : airtime()
{ } // two-arg constructor
airtime2(int h, int m) : airtime(h, m)
{
if(minutes>59 || hours>23)
{ cout << "\nError: invalid airtime
value "
<< hours << ':' << minutes; exit(-
1); }
}
}; // end class airtime2
//////////////////////////////////////
//////////////////////////
void main()
{
airtime2 at0; // ok (no-arg
constructor)
cout << "\nat0 = ";
at0.display();
airtime2 at1(10, 45); // ok (2-arg
constructor)
cout << "\nat1 = ";
at1.display();
airtime2 at2(10, 65); // user error
(2-arg constructor)
cout << "\nat2 = ";
at2.display();
}
In the airtime2 class, I create explicit no-argument
and two-argument constructors. The two-argument
constructor calls the two-argument constructor in the base
class and then checks the values provided to it. If either
hours or minutes is too large, it prints an error message
and causes an exit from the program. In main(), the
program creates three airtime2 objects. The first uses
the no-argument constructor; the second uses the two-
argument constructor with appropriate argument values;
and the third uses the two-argument constructor with a
minutes value that’s too large. Here’s the output from
AIRINH:
at0 = 0:00
at1 = 10:45
Error: invalid airtime value 10:65
As you can see, the airtime2 constructor has
successfully detected the out-of-range minutes value for
at2 and notified the user.