CHAPTER 1

Intro to OOP

hat is object oriented programming (OOP)? This question

W is a little difficult to answer because the computer

industry has a fascination for terminologies and catch
words. Not long ago words like “artificial intelligence”, “gui” and
“net surfing” were used as if they were to offer a path to heavens.
The same overuse seems to be happening to the phrase “object-
oriented”. Since it has been proven that object-oriented techniques
offer a way to write better programs, everybody seems to be
slapping the label “object oriented” on their software products.

So it is important for us to understand what is OOP, why do we

need it, what does it do that traditional languages like C, Pascal
and Basic don’t and what are the principles behind OOP. This

1
 2 Let Us C++

chapter addresses these issues and provides an overview of the

features to be discussed in the rest of the book. What we say here
will necessarily be general and brief. Don’t worry if you don’t
catch everything in this chapter on the first pass; OOP is a
complicated beast and learning about it takes time. We will be
going over these features again in subsequent chapters. There’s lot
of ground to cover here, so let’s get started.

While designing software a guideline that should be followed is

‘The Expression of an algorithm should model the application
domain that it supports’. Or in other words the solution to a
problem should resemble the problem that it solves. That is, the
observer should be able to recognise that purpose of the solution
without necessarily knowing the problem in advance. For example,
when you see a properly designed word processor, you intuitively
understand that the problem being solved is one of receiving and
manipulating text. Similarly, when you see a properly designed
inventory control system, you recognise that its purpose is to
maintain a record of stock quantities and locations. You recognise
those things because the solutions resemble and therefore remind
you of the problems that they solve. In a similar sense the purpose
of a programming language is to express with algorithms the
solution to a data processing problem. The techniques used in that
expression determine how successfully the solution models its
problem domain. Earlier, procedural programming was used for
expression of an algorithm. Of late it is being replaced by object-
oriented programming. To understand why this is so let’s begin by
looking at the history of programming methodologies.

The Beginning...
The earliest computers were programmed in binary. Mechanical
switches were used to load programs. With the advent of mass
storage devices and larger and cheaper computer memories, the
first high-level computer programming languages came into
Chapter 1: Intro to OOP 3

existence. With their arrival, instead of thinking in terms of bits

and bytes, programmers could write a series of English like
instructions that a compiler could translate into the binary
language of computers.

These languages were simple in design and easy to use because

programs at that time were primarily concerned with relatively
simple tasks like calculations. As a result, programs were pretty
short, limited to about a few hundred lines of source code.

As the computers capacity and capability increased, so also did the

ability to develop more complex computer programs. However,
the earlier programming languages were found wanting in
performing the complex programming task. These languages
suffered from the following limitations:

(a) There were no facilities to reuse existing program code.

Wherever the same piece code was required, it was simply
duplicated.

(b) The control was transferred via the dangerous goto statement.
As a result, there was too much jumping around in the
program, often without any clear indication of how, where
and why the control is flowing.

(c) All variables in the program were global. Tracking down

spurious changes in global data in long convoluted programs
was a very tedious job.

(d) Writing, understanding and maintaining long programs

became a programmer’s nightmare.
 4 Let Us C++

Structured Programming
To overcome the limitations mentioned above, a quest began to
develop new languages with new features that would help to create
more sophisticated applications. The breakthrough occurred in late
60’s and early 70’s with the introduction of structured
programming. The long programs that the programmer found
difficult to comprehend could now be broken down into smaller
units of few hundred statements. Functions/subroutines/procedures
were introduced in these languages to make the programs more
comprehensible to their human creators. A program could now be
divided into functions, with each function having a clearly defined
purpose and a clearly defined interface to the other functions in the
program.

A structured program is built by breaking down the program’s

primary purpose into smaller pieces that then become functions
within the program. Each function can have its own data and logic.
Information is passed between functions using parameters and
functions can have local data that cannot be accessed outside the
function’s scope.

By isolating processes within functions, a structured program

minimizes the chance that one procedure will affect another. This
also makes it easier to isolate problems, if any. Structured
programming helps you to write cleaner code and maintain control
over each function. There is less need of global variables, which
are now replaced by local variables that have a smaller and more
controllable scope. All this makes the development and
maintenance of code fast as well as efficient.

A new concept came into existence with structured programming:

Abstraction. Abstraction permitted the programmer to look at
something without being concerned with is internal details. In a
structured program it is enough to know which task is performed
by function. It does not matter to the programmer how that task is
Chapter 1: Intro to OOP 5

performed so long as the function does it reliably. This is called

functional abstraction and is the corner stone of structured
programming.

Structured programming ruled the roost for almost two decades.

With the constant improvement in the hardware and increasingly
more demands from the users for feature-rich programs, the
complexity of programs increased multi-fold and that’s the time
structured programming approach started showing signs of strain.
This occurred because of the weakness in the procedural paradigm
(organising principle) itself. One of the key reasons for the failure
of procedural languages was the role played by data.

In a procedural language, the whole emphasis is on doing things.

Subdivision of a program into functions continued this emphasis.
Functions do things just as single program statements do. What
they do may be more complex, but the emphasis is still on doing.
Data is given a second class status in the procedural paradigm even
though data is the reason for program’s existence. For example, in
a payroll processing application the important part isn’t the
function which displays the data, or the function that checks for
correct input; the important part is the payroll data itself.

In a structured program, data types are processed in many

functions, and when changes occur in data types, modifications
must be made at every location that acts on those data types within
the program. This is a frustrating and time-consuming task for
large-sized programs.

Another problem with structured programming is that its primary

components—functions and data structures—don’t model the real
world very well. For example, suppose you are writing a program
to create the elements of a GUI: menus, windows, etc., there are no
obvious program elements to which a menu or a window would
correspond. This is because the structured programming paradigm
 6 Let Us C++

emphasizes on fitting a problem to the procedural approach of a

language.

Object Oriented Programming

The world and its applications are not organized into values and
procedures separate from one another. Problem solvers in other
crafts do not perceive the world that way. They deal with their
problem domains by concentrating on the objects and letting the
characteristics of those objects determine the procedures to apply
to them. To build a house, grow a tomato, or repair a carburetor,
first you think about the object and its purpose and behavior. Then
you select your tools and procedures. The solution fits the
problem.

The world is, therefore, object-oriented, and the object-oriented

programming paradigm expresses computer programs in ways that
model how people perceive the world. Because programmers are
people, it is only natural that our approach to the work of the world
reflects our view of the world itself.

The object-oriented paradigm is built on the foundation laid by the

structured programming concepts and data abstraction. Data
abstraction does for data what functional abstraction does for
operations. With data abstraction, data structures can be used
without having to be concerned about the exact details of
implementation. For example, floating-point numbers are
abstracted in programming languages. You are not required to
know how a floating-point number is represented in binary while
assigning a value to it. Likewise, you are not bothered how binary
multiplication takes place while multiplying floating-point values.
Abstraction for floating-point numbers has existed in programming
languages since long. However, it is only recently languages have
been developed to define your own abstract data types.
Chapter 1: Intro to OOP 7

The fundamental change in OOP is that a program is designed

around the data being operated upon rather than upon the
operations themselves. This is to be expected once we appreciate
that the very purpose of the program is to manipulate data. The
basic idea behind object-oriented language is to combine into a
single unit, both, the data and the functions that operate on the
data. Such a unit is called an object.

An object’s functions, called member functions in C++, typically

provide the only way to access its data. If you want to create 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 encapsulated into a single entity.

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 which

communicate with each other by calling one another’s member
functions. The organization of a C++ program is shown in Figure
1.1.

Object
8 Let Us C++

Data
Member Function
Member Function

Object Object
Data Data
Member Function Member Function
Member Function Member Function

Figure 1.1

Thus, rather than trying to fit a problem to the procedural approach

of language, OOP attempts to fit the language to the problem.

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 programs can be designed. This results from
the close match between objects in the programming sense and
objects in the real world.

The match between programming objects and real world objects is

the happy result of combining data and functions. The resulting
objects offer a revolution in program design. No such close match
between programming constructs and the items being modelled
exists in a procedural language.

There is more to OOP programming than just binding the data and
functions together. OOP, for example, facilitates creating reusable
code that can eventually save a lot of work. A feature called
polymorphism permits you to create multiple definitions for
operators and functions. Another feature called inheritance permits
 Chapter 1: Intro to OOP 9

you to derive new classes from old ones. As you can see, OOP
introduces many new ideas and involves a different approach to
programming than the procedural programming. In short, instead
of concentrating on tasks, you concentrate on representing
concepts.

Characteristics of Object-Oriented Languages

Object-oriented programming uses a vocabulary that is unfamiliar
to the procedural programmer. Let us now briefly examine this
vocabulary with regards to the major elements of object-oriented
languages.

Objects
In structured programming a problem is approached by dividing it
into functions. Unlike this, in object-oriented programming the
problem is divided into objects. Thinking in terms of objects rather
than functions makes the designing of program easier. Following
are few candidates that can be treated as objects in different
programming situations:
− Employees in a payroll processing system
− Data structures like linked lists, stacks, queues etc.
− GUI elements like windows, menus, icons etc.
− Hardware devices like disk drive, keyboard, printer, etc.
− Various elements in computer games like cannons, guns,
animals, etc.
− Customers, sales persons in a sales tracking system
− Computers in a network model
− Etc.

Classes
10 Let Us C++

Most languages offer primitive data types like int, long and float.
Their data representation and response to arithmetic, assignment
and relational operators are defined as part of the language.
However, the language does not know user-defined data types.
The programmer defines its format and behaviour by defining a
class. For example, there can be a user-defined data type to
represent dates. The compiler and the computer do not know about
dates. Programmers have to define the behaviour of dates by
designing a date class. This class expresses the format of date and
the operations that can be performed on it. The way we can declare
many variables of the primitive type int, we can define many
objects of the date class. A class serves as a blueprint or 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.

Inheritance
OOP permits you to create your own data types (classes) just like
the types built into the language. However, unlike the built-in data
types, the user-defined classes can use other classes as building
blocks. Using a concept called inheritance new classes can be built
from the old ones. The new class referred to as a derived class, can
inherit the data structures and functions of the original, or the base
class. The new class can add data elements and functions to those
it inherits from its base class.

For example, we can build a set of classes that describe a library of

publications. There are two primary types of publication:
periodicals and books. We can create a general publication class
by defining data items for the publisher name, the number of pages
and the accession number. Publications can be retrieved, stored
and read. These are the functions of publication class. Next we can
define two derived classes named periodical and book. A
Chapter 1: Intro to OOP 11

periodical has a volume and issue number and contains articles

written by different authors. Data items for these should be
included in the definition of the periodical class. The periodical
class will also need a function, subscribe. Data items for the book
class will include the names of its author a cover type (hard or
soft) and its ISBN number. As you can see, the book class and the
periodical class share the characteristics of publication class while
having their own unique attributes. This entire scenario is depicted
in Figure 1.2.

Feature A
Feature B
Publication class

Feature A Feature A
Feature B Feature B
Feature C Feature E
Periodical class Book class

Figure 1.2

Polymorphism
Extending the same example of the publication, periodical and
book, let us now understand another important concept. Our base
class, publication, defines methods for storing and retrieving data.
A periodical may be stored in a binder, while a book is usually
placed on a shelf. Furthermore, the way to find a specific
periodical is different from finding a book. Periodicals are located
through a guide to periodical literature, while books are found
12 Let Us C++

using a card catalogue system. Based on this we can design a ‘find

through periodical literature’ function for a periodical and a ‘find
through card catalogue’ function for a book. OOP provides an
elegant facility called polymorphism to handle this situation. In our
example, the retrieval method for a periodical is different from the
retrieval method for a book, even though the end result is same.
Polymorphism permits you to define a function for retrieving a
publication that can work for both periodicals and books. When a
periodical is retrieved, the retrieve function that is specific to a
periodical is used, but when a book is retrieved, the retrieve
function associated with a book is used. The end result is that a
single function name can be used for the same operation
performed on related derived classes even if the implementation of
that function varies from class to class. This concept of
polymorphism (one thing with several distinct forms) can be
extended even to operators, as we would see in later chapters.

Reusability
Object-oriented programs are built from reusable software
components. Once a class is completed and tested, it can be
distributed to other programmers for use in their own programs.
This is called reusability. If those programmers want to add new
features or change the existing ones, new classes can be derived
from existing ones. The tried and tested capabilities of base classes
do not need to be redeveloped. Programmers can devote time to
writing new code instead of wasting time in rewriting existing
code. This way software becomes easier to test since programming
errors can be isolated within the new code of derived classes.

For example, you might have written (or purchased from someone
else) a class that creates a menu system. You are happy with the
working of this class and you don’t want to change it, but you
want to add the capability of displaying context sensitive help for
each menu item. To do this, you simply create a new class that
 Chapter 1: Intro to OOP 13

inherits all the capabilities of the existing one but adds context
sensitive help. The ease with which existing software can be
reused is a major benefit of OOP.

Exercise
[A] State True or False:

(a) Object oriented programming languages permit reusability of

the existing code.

(b) Languages earlier than procedural programming languages

made use of only global variables.

(c) In Object Oriented programming languages the only way to

transfer control from one place in the program to another is by
using the goto statement.

(d) It is easier to write, understand and maintain programs in

Object Oriented languages as compared to Procedural
languages.

(e) Data is given a second class status in Procedural programming

languages.

(f) Structured programming languages do not model the real

world data as well as the Object Oriented programming
languages.

(g) Object Oriented programming languages permit functional

abstraction as well as data abstraction.

(h) A class permits us to build user-defined data types.

(i) Objects are to classes as variables are to data types.

14 Let Us C++

[B] Fill in the blanks:

(a) The two major components of an object are & .

(b) The ability of a function or operator to act in different ways

on different data types is called .

(c) The process of building new classes from existing ones is

called .

(d) If a class A inherits its properties from class B, then A and B

are known as class and class, respectively.

(e) Pascal and C are languages, whereas, C++ is la-

nguage.