LAB MANUAL

OBJECT ORIENTED PROGRAMMING

Lab Instructor: Engr. Shahinza Manzoor

DR. A. Q. KHAN INSTITUTE OF COMPUTER SCIENCES

AND INFORMATION TECHNOLOGY
KAHUTA
 ii

Lab Rubrics

Lab Performance Beginning Developing Accomplished Exemplary

Lab Report The lab report Presents some Presents most Presents all the
does not follow sections of the lab sections of the lab sections of the lab
the guidelines for in the correct in the correct in the correct order
formatting. order. Three or order, one or two with correct
more sections are sections may not formatting: includes
not in the correct be in the correct correct heading,
order; missing order; heading or section headings
heading or title; title missing or and title of lab;
not complete;
Exp. Conduction Experiment Performs some Implemented Experiment is
conduction is not sections of the most of the conducted properly
As per guidelines experiment experiment with correct
and requirements correctly. correctly and implementation and
are not met understands it Output,
well understanding is
good
Team Work Rarely listens to, Often listen to, Usually listen to, Almost always
shares with, and shares with and shares with, and listens to, shares
supports the supports the supports the with and supports
efforts of others. efforts of others, efforts of others. the efforts of
Often is not a but sometimes is Usually respectful others. Tries to
good team not good team and listening keep people
member. member. actively working well
together.
Observation/Demo Minimal Represents little Represents some Represents all data
demonstration is data and presents data appropriately appropriately and
performed. data in a manner and accurately so accurately so that
that makes trends that trends and trends and findings
and finding findings are clear are clear.
unclear
Lab Project Beginning Developing Accomplished Exemplary
Presentation The project The project needs The project has The project is
needs significant improvements in nice design and timely completed
improvement in design, layout and layout. Student with nice design
design, layout neatness presented it well features and good
and neatness presentation with
proper output.
Calculation/Coding Implementation Basic Most of the part is Proper
/Circuit Design of the project implementation is implemented implementation is
needs significant done but properly but still performed with
improvements improvements are some correct procedures.
required to improvements are
achieve the targets required
Outcome/Result Students shows some Provides most of Provides an
provides an outcome correctly, the outcomes accurate output
unclear and no analysis properly and with analysis and
inaccurate performed summary of the correct results
outcome and project is also
analysis provided
Viva Beginning Developing Accomplished Exemplary
Sub. Knowledge Student could not Some concepts are Most of the Demonstrated
demonstrate demonstrated but knowledge is subject knowledge
subject clearly students correct, some well with deep
 iii
knowledge lacks deep further understanding of
understanding understanding and concepts.
improvements are
required
Accuracy Could not Some of the Most of the Demonstrated
provide accurate answers are answers are accurate answers
answers correct correctly provided with analysis
Response Response is not Response to some Mostly correct Logical and correct
confident and of the questions is and accurate response is noted
inaccurate good response is on all the questions.
observed
Presentation Beginning Developing Accomplished Exemplary
Originality The presenter The presenter was The presenter The presenter
was un- some-what kept the attention sustained the
enthusiastic; enthusiastic; kept of the audience interest of the
audience audience attention the whole time audience in clever
attention showed for the most part and the purpose of and innovative
disinterest and and the purpose the presentation ways and achieved
the purpose for for the was achieved the purpose of the
the presentation presentation was presentation
was not achieved mainly achieved
Delivery Presenter was Presenter was Presenter was The presenter is
clearly somewhat well prepared and very well prepared
unprepared to prepared, delivery delivered with and delivers ideas
present to the of the presentation lots of eye in a clear and
audience. was made but with contact. concise manner
Marked lack of string dependence Appropriate voice without depending
eye contact, poor on notes and volume, tone and too much on notes.
voice volume hesitation. Some pacing. Gestures Volume, pacing and
and inappropriate eye contact and supported the gestures contribute
gestures which voice volume, overall maximally to the
detracted from some appropriate presentation presentation.
the presentation gestures.
Structure Presenter did not Presenter gave a Presenter gave a The introduction
give a clear and clear introduction clear and concise and actual
concise of the topic but introduction of presentation were
introduction of the presentation the topic. The exceptionally well-
the topic. The was somewhat flow of the organized and easy
flow of the unclear. For the presentation was to follow.
presentation was most part it was clear and concise
unclear and confusing to and easy to follow
confusing to follow.
follow
Pronunciation Student does not Student Pronunciation is Student pronounces
do any effort pronounces good, but some mostly everything
regarding incorrectly some constructions and correct and clearly
pronunciation terms, mostly terms are
vocabulary of the incorrect
unit

Programming Beginning Developing Accomplished Exemplary

Syntax Program compiles Program compiles Program Program
Ability to and contains no and is free from compiles, but does not
understand syntax errors of the major syntactic contains errors compile or
and follow language. errors. that signal (in a
the rules of misunderstanding dynamic
the of syntax – such language)
programming as the semi- contains
language. colon in if(exp); typographica
{} l errors
leading to
undefined
 iv
names.
Logic Program logic is Program logic is Program logic is Program
Ability to correct, with no mostly correct, but on the right track contains
specify known boundary may contain an with no infinite some
conditions, errors, and no occasional loops, but shows conditions
control flow, redundant or boundary error or no recognition of that specify
and data contradictory redundant or boundary the opposite
structures that conditions. contradictory conditions (such of what is
are condition. as < vs. <=) required
appropriate for (less than
the problem vs. greater
domain. than),
confuse
Boolean
AND/OR
operators,
or lead to
infinite
loops.
Correctness Program produces Program produces Program Program
Ability to correct answers or correct answers or approaches does not
code appropriate results for appropriate results correct answers produce
formulae all inputs tested. for most inputs. or appropriate correct
and results for most answers or
algorithms inputs, but can appropriate
that reliably contain results for
produce miscalculations most inputs.
correct in some cases.
answers or
appropriate
results.
Completeness Program shows Program shows Program shows Program
Ability to evidence of excellent evidence of case some evidence of shows
apply case analysis, and all analysis that is case analysis, but little
rigorous possible cases are mostly complete, but may be missing recognition
case handled may have missed significant cases of how
analysis to appropriately. minor or unusual or mistaken in different
the problem cases. how to handle cases must
domain. some cases. be handled
differently.
Clarity Program contains Program contains Program contains Program
Ability to appropriate some some contains no
format and documentation for all documentation on documentation (at documentat
document major functions, major functions, least the student’s ion, or
code for variables, or non- variables, or non- name and grossly
human trivial algorithms. trivial algorithms. program’s misleading
consumption. Formatting, Indentation and purpose), but has indentation.
indentation, and other other formatting is occasionally
white space aids appropriate. misleading
readability. indentation.
Efficiency The code is fairly The code is The code
The code is efficient without brute force and is huge
extremely efficient sacrificing unnecessarily and
without sacrificing readability and long. appears
readability and understanding. to be
understanding. patched
together.
 v

CLO’s PLO’s

Subject: Object Oriented Programming

Instructor: Engr. Shahinza Manzoor

Program Learning Outcomes (PLO’s):

PLO-01: Engineering Knowledge: An ability to apply knowledge of mathematics, science, engineering

fundamentals and engineering specialization to the solution of complex engineering problems.
PLO-02: Problem Analysis: An ability to identify, formulate, research literature and analyze complex
engineering problems reaching substantiated conclusions using first principles of mathematics, natural
sciences and engineering sciences.
PLO-03: Design/Development of Solution: An ability to design solutions for complex engineering
problems and design systems, components or processes that meet specified needs with appropriate
consideration for public health and safety, cultural, societal, and environmental considerations.
PLO-05: Modern Tool Usage: An ability to create, select and apply appropriate techniques, resources
and modern engineering and IT tools, including prediction and modeling to complex engineering
activities, with an understanding of the limitations.

Course Learning Outcomes (CLO’s):

Upon successful completion of the course the student will be able to:

No. Description Bloom’s PLOS

Taxonomy
Level

1 Explain the concepts of OOP features and C++ C2 1

2 Practice the analysis of system by applying object oriented P3 2

concepts
3 Make a management system using OOP concepts and observe the P4 3
behavior of objects, attributes and interactions of the system
4 Practice the concepts of object oriented programing by P3 5
contemporary complier usage(visual studio)
 vi
Table of Contents

LAB NO Labs CLOS Page no

Lab 1 Functions and Pointers in C++ 1 1

a. Explain the concepts of functions and pointers.
4
b. Recognize how we write a program in visual studio.

c. Practice different C++ program using functions and 2

pointers
Lab 2 Introduction to Classes and Objects 13
a. Explain the concepts of classes object and member 1
function

b. Recognize how we write a program in visual studio. 4

c. Practice C++ program using classes 2

Lab 3 Access Specifiers, Constructors and Destructors 22
a. Discuss what is access specifiers constructor and destructor 1
in classes

b. Practice C++ program which include classes

2
constructor and destructor
Lab 4 Constructor Overloading and Copy Constructors 32
a. Explain the concept of Constructor Overloading and Copy 1
Constructors

b. Practice C++ program using Constructor Overloading and 2

Copy Constructors
Lab 5 Shallow Copy/ Deep Copy and Working with arrays 41

Practice C++ program using Shallow Copy/ Deep Copy and 2

Working with arrays

Lab 6 Friend Functions and Friend Classes 52
a. Explain what is Friend function and friend classes 1

b. Practice C++ program using Friend Functions and Friend

Classes 2
Lab 7 Introduction to Operator Overloading 61
a. Explain the concepts of Operator Overloading. 1

b. Recognize how we write a program in visual studio.

4
c. Practice C++ program using Operator Overloading 2

Lab 8 Inheritance in Object Oriented Programming 72

a. Explain the concepts of Inheritance in Object Oriented 1

Programming
b. Recognize how we write a program in visual studio.

c. Practice C++ program using inheritance 4

2
 vi
i

Lab 9 The Protected Access Specifier and Types of Inheritance 80

a. Discuss the concepts The Protected Access Specifier and Types of 1

Inheritance
b. Practice C++ program which include Protected Access 2
Specifier and Types of Inheritance
Lab 10 Multi-level and Multiple Inheritance 89
a. Explain the concepts of Multi-level and Multiple Inheritance 1

b. Recognize how we write a program in visual studio.

4
c. Practice to write a C++ program using Multi-level and
Multiple Inheritance 2

Lab 11 Function Overloading and Function Overriding 98

a. Discuss the concepts of Function Overloading and Function 1

Overriding
b. Practice to write a C++ program which include Function 2
Overloading and Function Overriding
Lab 12 Polymorphism in Object Oriented Programming 106

a. Explain the concepts of Polymorphism in Object Oriented 1

Programming
4
b. Recognize how we write a program in visual studio.

c. Practice to write a C++ program using Polymorphism in 2

Object Oriented Programming

Lab 13 Function and Class Templates and Exception Handling 115

a. Discuss what is Function and class Template and Exception 1

Handling
2
b. Practice to write a C++ program which include Function
and Class Templates

Lab 14 Open Ended Lab 2

Lab 15 Design a management system 3

 vi
ii

Preface

L earning is a process that requires class instructions and practice labs. If we omit any of
the above then the learning process is clearly flawed. This book is an attempt to standardize
the lab instructions through the development of a lab curriculum that is based on the class
curriculum. This document is intended to be used by lab instructors, course
instructors and students.
The intent of this curriculum is to define a clear lab structure that can be followed by
the lab instructor and the students. In the absence of such curriculum the labs are often run
without any formal structure. Another problem is that there is no grading criteria defined for
each lab which leads to unethical practices. Perhaps one of the greatest problems faced by lab
instructors is that they are unable to keep the students occupied for the entire duration of the
lab due to which the learning process is greatly hampered.
The labs have been developed in a way that there is synchronization between the class
and the lab. The entire book has been divided into 15 labs having duration of 3 hours each.
Students of the course are expected to carefully read the concept map before coming to the
lab. Students come to the lab with a designs/ program that will be handed over to the lab
instructor for further grading. This code/ design is primarily based on previous learning’s and
experiments. Each lab has a detailed walkthrough task which provides a problem statement
and its programmable solution to the students. The students can raise queries about the code
provided and the lab instructor will guide the students on how the solution has been designed.
Thereafter predefined practice questions have been presented such that each question has a
fix duration and grade. Students are graded upon their accomplishments in these practice
tasks. At the end of the lab the lab instructor will assign an unseen task to the students. This
unseen task contains all the concepts taught in the lab. These unseen tasks have a higher level
of complexity and generally have a greater gain in terms of marks.
What sets these labs apart is the fact that a clear grading criteria has been defined for
each lab. Students are aware of the grading criteria and are expected to meet the requirements
for successful completion of each lab.
Lab Manual for Object Oriented Programming
(LAB-01)

Functions and Pointers

Page 1
 Lab 1 - Functions and Pointers

Lab 01: Functions and Pointers CLO (1, 2, 4)

1. Introduction
C++ programming that you studied in the previous semester is purely based on writing a set of instructions in a
particular sequence such that the output is based on the sequence of the written statements. If this sequence of
instructions is modified then it could have a large impact on the resulting program. Often a situation arises where we
intend to use a particular chunk of code again and again in a single program. In this scenario using sequential
programming the programmer is forced to copy-paste the code in various locations of the source file.

Although this is a solution, it is not a practical one because it causes the code to become lengthy, unmanaged, poorly
structured and difficult to understand. In such a situation function handling offers an attractive and easy to
implement alternative that is widely accepted and promoted by programmers of all languages.

This lab is a refresher course on the use of functions, pointers and building logic. The functions that are designed
will receive variables and arrays from the user. The function will perform some processing on the provided data and
return results back to the main program.

The importance of this lab can be highlighted through the fact that functions play a pivotal role in the establishment
of classes, objects and their manipulations. A large portion of object oriented programming is based on manipulating
variables using functions. In the later part of this lab the use of pointers has been emphasized. Concepts relating to
pointers, memory access, using arrays with pointers have been presented.

2. Objective of the Experiment

After completing this lab the student should be able to:
 Understand the purpose/ advantage of creating a function.
 Understand the difference between a function definition and prototype.
 Understand the difference between a parameter and an argument.
 Understand how a function is created and called.
 Understand how values are passed by value and by reference to a function. Returning the values thereafter.
 Use pointers and manipulate variables using pointers.
 Use an array with pointers in a function.

Page 2
 Lab 1 - Functions and Pointers

3. Concept Map

4.1 Reusability/ Modularity of Code

Computer programmers have always devised mechanisms through which they can make their code more
understandable and then reusable. In this regard functions offer a very popular and easy mechanism of introducing
the above goals. Function handling operates on the concept of provision of service/ functionality. We can call the
services of a function by providing the required data and in result getting the promised service from the function.

Reusability of code means devising methods through which you can use code again and again without having to
copy-paste in the source file. Modularity of code means dividing the code into small, manageable and easy to
understand segments.

4.2 Function Prototype and Function Definition

The creation of a function is based on two similar yet distinct statements called a function definition and function
prototype.

A function prototype explains only how a function will be called and what data type it will return. A function
definition on the other hand matches the function prototype and also includes a function body.

For example the following is the function prototype of a function that finds the sum of two integers passed to it:

void addtwo (int, int);

The following is the function definition of the above defined function:

void addtwo (int a, int b)

int c=a+b;

cout<<”The sum is ”<<c;

4.3 Function Arguments and Parameters

There are two types of variables a function is related with; namely function arguments and function parameters.
Function arguments are those variables that are provided to a function. These variables are passed whenever a
function is called.
Function parameters are those variables that are created and initialized when parameters are passed to a function.
The scope of a function parameter is always within the body of the function. It should be pointed out here that any
variable that is created in a function body has a local scope and cannot be accessed outside the function body.
The data type of arguments must match the parameters of a function.

In the following example, variables a and b are parameters of the function addtwo( ).

void addtwo (int a, int b);

Page 3
 Lab 1 - Functions and Pointers

int c=a+b;

cout<<c;

Now suppose we are calling the same function from within the main().

void main( )

int x=3, y=4;

addtwo(3,4);

4.4 Returning a Value from a Function

To increase the practical use of functions, a programmer may want the result of a function to be given back after
processing. This process is called returning a value from a function. It is important to remember that functions can
only return a single value (of any data type). If a function will not return a value then it is necessary to write void
before the function name in the prototype and the definition. It is not necessary for a function to return a value.

For example the following function does not return a value hence the void keyword is used

void addtwo (int a, int b);

int c=a+b;

cout<<c;

The following function returns an integer value hence the keyword int is used.

int addtwo (int a, int b);

int c=a+b;

return (c);

The value being returned can be displayed by using the following statement from where the function is being called.

Page 4
 Lab 1 - Functions and Pointers

cout<<addtwo(x, y);

4.5 Pass by Value and Pass by Reference

All the functions we have discussed until now are pass by value. Pass by value is an argument passing technique in
which the function receives a parameter and works with a copy of the value being provided. This means if a change
is made to the parameter value then still no change will not be reflected in the argument.

On the other hand pass by reference is an argument passing technique in which the function works with the exact
variable that is being passed as an argument. This means that even the smallest change in a parameter will be exactly
reflected in the arguments. This further implies that the arguments and the parameters are tightly coupled.

4.6 Pointers
Pointers are special kind of variables that are allowed to hold the address of another variable. Because of their
pointing ability pointers are considered very powerful in C++. Pointers can hold the address of another variable and
this is called referencing the memory location. When we attempt to extract values from a memory location then this
is called dereferencing a pointer.

Page 5
 Lab 1 - Functions and Pointers

Figure 1: The working of a pointer (image courtesy of Wikipedia)

In the figure provided above there is a pointer variable called “a”. This variable is pointing to the memory address of
variable b. The memory address of variable b is 1008. In this diagram you will also note that the pointer “a” has its
own memory address. This is a very important fact because pointers themselves also require a space in memory.
When we write a code on our compilers remember that every computer has its own memory and the availability of
memory space. Our compilers take the help of a memory manager and allocate space in a memory slot that is
available to the system. This means every time we run the code we may get a different memory allocation.
Consider the code provided below:

Figure 2: The various operations that can be performed with a pointer. Output is also provided. Memory addresses
may be different depending on the hardware environment

In the code above first a simple integer variable is created. Then an integer pointer is created because we intend to
point to an integer variable. The pointer is then given the address of variable x by using the address operator. Then
we use the dereference operator (*) that directs us to the memory location where the pointer is pointing to.

4. Home Work Before Lab

5.1 Problem Solution Modelling

Write the pseudo-code of the following task. You are required to bring this code with you and submit to your

Page 6
 Lab 1 - Functions and Pointers

lab instructor.

5.1.1 Problem description CLO(2,4)

Practice to write pseudo-code for a program that will find the factorial of a number. Your task is to also perform
checks on the number entered by the user because the factorial can only be found of an integer and a positive
number. Incorporate these two conditions in you pseudo-code.

5.2 Practices from home

5.2.1 Task-1 CLO(2,4)

In The field of Physics you are aware of the concept of force and acceleration. Your task is practice to write a
program to find the force if the mass and the acceleration of a body is given. Write a function to perform the
calculation. Your task is to provide the mass and acceleration as arguments to the function and then display the force
without returning a value.

5.2.2 Task-2 CLO(2,4)

cylinder is provided. The function should return the value of area. The area of a cylinder is 𝜋 𝑟2 ℎ. Consider the
Practice to Write a program that creates a function to find the area of a cylinder if the radius and height of the

figure below for further clarification.

r

5. Procedure & Tools

6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008 [Expected time = 5 mins]

Setup Visual Studio and make a project named “FindAverage”.

6.3 Walkthrough Task [Expected time = 25 mins]

Write a C++ program that creates (in main function) an array of type int having 6 elements. Now write a function
called arr_avg( ) that will find the average of all the elements of the array. This function should return the average
back to the main( ) function. Also write another function called arr_display() that will display all the elements of the
array.

Page 7
 Lab 1 - Functions and Pointers

6.3.1 Writing Code

In the source file created in the project “FindAverage” write following C++ code:

Figure 3: Function for finding average of values in an array

In the code above note that the two functions use different mechanisms for passing/ using an array. You can choose
the method that suits your code/ situation. The size is passed in both functions because without the size the functions
can easily cross the array bounds. Hence passing the array size is a good practice.

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

Page 8
 Lab 1 - Functions and Pointers

6.3.3 Executing the Program

A sample output after running the program is shown below. Also run the code with other possible inputs.

Figure 2: Final output of FindAverage program.

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab01

7.1 Practice Task 1 CLO(2,4)

Practice to write a program that contains a function to find twenty odd numbers starting from a particular number
provided by a user.

7.2 Practice Task 2 CLO(2,4)

Practice to Write a program to find the power of a number if the base and exponent is provided in the main
function. Use pass by reference mechanism to compute the power. Your function should not return a value.

7.3 Practice Task 3 CLO(2,4)

Practice to Write a program that has an integer array having 20 elements. The program should have a function that
can receive the array and then return the sum of all the elements of the array. Use pointers to demonstrate the
iteration through the array.

7.4 Practice Task 4 CLO(2,4)

Practice to Write a program that finds the factorial of a non negative number provided by the user. Since the user
can enter a floating point number hence your input should accommodate floats and ints. To find the factorial of the
entered number you will need to design three functions as follows:
 Function to determine if a number is a whole number or not
 Function to determine if the number is positive or not
 Function to find the actual factorial
Remember that to find the factorial the number must of positive and a whole number. So if any of these conditions
are not met then you cannot determine the factorial.

7.5 Outcomes
After completing this lab, students will be able to use functions and also understand the concept of parameters,
arguments and returning of values. Students should also be comfortable with pointers and their use in functions.
Page 9
 Lab 1 - Functions and Pointers

7.6 Testing
Test Cases for Practice Task-1
Sample Inputs Sample Outputs
Number: 3 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, …

Test Cases for Practice Task-2

Sample Inputs Sample Outputs
Base: 4 Result = 4194304
Exponent: 11
Check that the function works with pass by reference

Test Cases for Practice Task-3

Sample Inputs Sample Outputs
Array having all entries 1 Sum = 20

Check that pointers have been used to iterate the array

Test Cases for Practice Task-4

Sample Inputs Sample Outputs
Number: -5 Invalid Input

Number: 5.5 Invalid Input

Number: 5 120

Table 2: Confirmation of practice tasks T1, T2, T3, T4

Practice Tasks Confirmation Comments

T1
T2
T3
T4

Page 10
Lab Manual for Object Oriented Programming
(LAB-02)
Introduction to Classes and Objects

Page 13
 Lab 2 - Introduction to Classes and Objects

Lab 02: Introduction to Classes and Objects CLO(1,2,4)

1. Introduction
The programming that you have understood in your computer programming course, allows you to design a program
by assembling a sequence of instructions. This is the way in which traditional programming works, but now there is
clear paradigm shift towards an object based approach. The new object oriented approach allows you to model your
program in a way in which objects, their relationships and the functions that they operate are clearly visible to the
programmer.
Perhaps the greatest advantage of this approach is that it gives an extended modular concept in which the interface is
made public while the implementation details are kept hidden. This allows the program to grow in size without
becoming too cumbersome. Previously, when a program grew beyond a certain size it became almost impossible to
understand and extend especially when the programmer had forgotten the minor concepts constructing the program.
Here, it should be understood and acknowledged that programs are not disposable entities they have a life beyond
what is normally expected. Hence designing a program that can be easily extended, modified and interfaced with
other systems is a very important characteristic of any well written program.
This lab has been designed to give in-depth knowledge of how to make classes, objects and their interrelations. The
concept map provides all the crucial details that are required for the completion of this lab.

2. Objective of the Experiment

After completing this lab the student should be able to:
 Clearly understand the purpose and benefits that OOP has to offer.
 Understand the concept of a class and objects.
 Develop a basic class with fundamental data members.
 Develop a basic class with a number of member functions.
 Use a constant member function.
 Separate the implementation section of a function.
 Use the class objects and member functions to provide and extract data from an object.
 Experiment with classes and objects.

Page 14
 Lab 2 - Introduction to Classes and Objects

3. Concept Map

4.1 Object

In OOP an object is a very much like a real world object. An object can be defined as a collection of state and
behaviour. For example, consider the example of a cat. A cat is has both a state and behaviour. The state of a cat is
its attributes namely colour, breed, gender, age, weight, height, etc. Whereas the behaviour of a cat is its sound,
eating, sleeping, yawning, walk, etc. Hence a cat can be completely identified by its unique characteristics and
behaviours.

In programming an object is a collection of variables and functions that together have a unique purpose of
identifying a distinctive entity.

4.2 Data Members

Again referring to the concept of an object and the example of a cat. The cat had a number of characteristics or
attributes that can be used to identify a cat. In programming these attributes can be programmed by using regular
variables that are called data members. A class can be composed of a number of data members of various types. The
data members of a class are private by default i.e. they are not directly accessible outside the class.

Here it is important to point out that often people casually refer to these as variables, which is a wrong terminology.
These should only be called data members or class variables.

4.3 Member Functions

Again referring to the concept of an object and the example of a cat. The cat had a number of behaviours or things
that a cat does. In programming these behaviours can be programmed by using functions that are called member
functions. A class can be composed of a number of member functions of various types. Overloading of member
functions is also permitted in C++. The implementation section of member functions can be separated whereby the
body of the function is created outside the class but the function prototype has to exist in the body of the class. The
implementation section is separated by writing the return type followed by class name. This is further followed by
scope resolution operator :: and then the remaining function definition.

using namespace std; class myclass

{
int datamember;

int memberfun(int);
// Function prototype
};

int myclass :: memberfun (int x)// Note the scope resolution operator
{
...// Function body
}

void main( )
{

Page 15
 Lab 2 - Introduction to Classes and Objects

4.4 Constant Member Functions

A constant member function is just like a conventional function except it is a read only function. This means that the
function cannot modify anything related to the object. But the member function can still perform all reading
activities related to the object. Such type of functions are generally created when the programmer wishes to only
read/ display the data members on the screen. Given below is the syntax for creating these constant member
functions.

void addtwo ( ) const //Note the keyword const

cout<<”The sum is= ”<<s;

4.5 Class

A class is a collection of data members and member functions. A class is used to define an abstract data type. This
abstract data type is used in the construction of an object which is used to access all the data members and member
functions. A class has to be created before it can be used. Provided below are the syntax for creating a class.

using namespace std; using namespace std;

class myclass class myclass;
{
int datamember; void main( )
{
void memberfun (int)
{ }
...
} class myclass
}; //Semicolon is necessary {
int datamember;
void main( )
{ void memberfun (int)
{
} ...
}
}; //Semicolon is necessary

4.6 Encapsulation
Encapsulation is a very important design goal because of which OOP is preferred over conventional programming.
Encapsulation is a quality because of which data and function are stored in a single unit commonly known as a class.
This unit/ bundle ensures that the data is not openly accessible to the outer world. The access is provided by the
functions that are part of the unit/bundle. This means that the functions work like doors in a room. You can prevent
thieves from breaking in. Only those people can enter who come through the door.

Page 16
 Lab 2 - Introduction to Classes and Objects

4. Home Work Before Lab

5.1 Problem Solution Modelling

Design the following problem by listing down the data members and the member functions. You are required to
bring this task with you and submit to the lab instructor.

5.1.1 Problem description

List down the data members and member functions of a class that will identify a vehicle. You are allowed to
suppose the data members and the member functions of the class. Also create a single member function that will
display the entire class data members. You will be graded on the quality and clarity of your design.

5.2 Practices from home

5.2.1 Task-1
Identify the data members and member functions for a pizza class. The class should have all the relevant attributes
and qualities required for a pizza object. Try to be imaginative in your design. For example consider various sizes,
toppings, base thickness, etc.

5. Procedure & Tools

6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008

Setup Visual Studio and make a project named “cylinder”.

6.3 Walkthrough Task CLO(2,4)

Practice to Write a program that creates a class called cylinder. The data members of the class are radius and height
of the cylinder is provided. Write two functions that set the respective values and then write a single constant
function that will read the values.

Page 17
 Lab 2 - Introduction to Classes and Objects

6.3.1 Writing Code

In the source file created in the project “cylinder” write the following C++ code:

Figure 1: Class for creating a cylinder with its relevant data members

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below. Also run the code with other possible inputs.

Figure 2: Final output of cylinder program.

Page 18
 Lab 2 - Introduction to Classes and Objects

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab02

7.1 Practice Task 1 CLO(2,4)

Practice to Write a C++ program that creates a class called laptop. The data members of the class are brand (string),
model (string), serial (int), colour (string), price (float), processor speed (float), RAM (int), screen size(float).
Create member function that will set the individual values. Since the RAM can be upgraded therefore create a
function that allows you to upgrade the RAM only. In the end, create a function that will display all the data
members.

7.2 Practice Task 2 CLO(2,4)

Practice to Write a class called rectangle. Your task is to store the length and width of the rectangle. Write a
member function called increment that will add 1 to the value of length and width. Also write a function that will
compute the area of the rectangle. Finally write a constant function that will display the length, width and area of the
rectangle.
Demonstrate the use of the object in the main function. Make sure that the function names are meaningful and self
descriptive.

7.3 Practice Task 3 CLO(2,4)

Practice to Write a program that creates a class called number. Your class will have two data members namely num
(float) and result (int). To find the factorial of the entered number you will need to design three functions as follows:
 Function to determine if a number is a whole number or not
 Function to determine if the number is positive or not
 Function to find the actual factorial
 Function to display the number and its factorial
Remember that to find the factorial the number must of positive and a whole number. So if any of these conditions
are not met then you cannot determine the factorial.

7.4 Outcomes
After completing this lab, students will be able to design a basic class with data members and member functions.

7.5 Testing
Test Cases for Practice Task-1
Sample Inputs Sample Outputs
Set the following values Brand = DELL
Brand = DELL Model = 1565D
Model = 1565D Serial = 123456
Serial = 123456 Colour = Silver
Colour = Silver Price = 64500.5
Price = 64500.5 Processor = 2.8
Processor = 2.8 RAM = 3
RAM = 2 Screen = 15.6
Screen = 15.6

Then Modify the RAM to 3

Test Cases for Practice Task-2

Sample Inputs Sample Outputs

Page 19
 Lab 2 - Introduction to Classes and Objects

Length: 4 Length = 5
width: 10 Width = 11
Area = 55

Page 20
 call the increment function Check the use of constant function for display

Test Cases for Practice Task-3

Sample Inputs Sample Outputs
Number: -5 Invalid Input

Number: 5.5 Invalid Input

Number: 5 Number = 5
Factorial = 120

Table 2: Confirmation of practice tasks T1, T2 and T3

Practice Tasks Confirmation Comments

T1
T2
T3

Lab Manual for Object Oriented Programming

(LAB-03)
Access Specifiers, Constructors and Destructors

Page 22
 Lab 3 - Access Specifiers, Constructors and Destructors

Lab 03: Access Specifiers, Constructors and

Destructors CLO(1,2,4)

1. Introduction
Programming that you studied in the previous semester does not strongly support programming practices like
encapsulation and data hiding. In fact these features are almost nonexistent in sequential programming. Object
Oriented Programming is purely based on these practices and enforces these practices through various techniques. In
this regard access specifiers play a very important role because they are the first line of defence in secure
programming.
This lab is designed to teach three very basic yet essential concepts of OOP namely access specifiers, constructor
and destructors. Access specifiers provide a technique through which we can restrict access to data members and
member functions. After enforcing access it is important to reduce our reliance on too many member functions.
Constructors offer a very attractive and easy to implement technique through which we can take steps call
procedures whenever an object is created. The use of constructors is preferred over the use of member functions
because constructors are called automatically and hence they can invoke further functions whereas simple member
functions have to be called sequentially and explicitly one by one every time an object is created.
Similarly this lab also focuses on the use of destructors that are called whenever an object goes out of scope. In this
the lab the students will be familiarized with the use of access specifiers, constructors and destructors.

2. Objective of the Experiment

After completing this lab the student should be able to:
 Clearly understand the purpose and importance of access specifiers.
 Develop a class by correctly using/ enforcing access specifiers.
 Differentiate between the public and private access specifier.
 Understand the importance of constructors.
 Understand the importance of destructors.
 Use a basic constructor.
 Use a basic destructor.

Page 23
 Lab 3 - Access Specifiers, Constructors and Destructors

3. Concept Map

4.1 Access Specifiers – Public and Private Access

Access specifier also known as access modifier provides a technique for enforcing access control to class members
(data members and member functions). The use of access specifiers enforces encapsulation and data hiding. C++
provides three access specifiers i.e. public, private and protected. In this lab we will only cover the public and the
private access specifier. The protected specifier is left for future discussions.

The public access specifier is the one that provides unrestricted access to the class members. While the private
access specifier provides a very strict/ restricted access to class members. All the class members that are written
under the public access can be accessed both inside and outside the class without any restriction. On the other hand
all the class members written as private are accessible inside the class but are not accessible outside the class. The
best and most common way of accessing private data members is through the use of a public functions.

When we are discussing access specifiers it must be pointed out that by default classes are private whereas
structures are public. Hence if you do not write private then your listed class members are considered private in a
class.

The correct convention for the use of access specifiers is that data members are kept private whereas functions are
kept public. Hence you are providing a public interface for accessing restricted items in a class.

using namespace std; class myclass

{
private:
int datamember; public:
int memberfun(int); //Private data member
};
// public member function

// This
int myclass :: memberfun (int x) because itsfunction isis
prototype still public
public
{
datamember=x;
}

void main( )
{
myclass obj; myclass::datamember=10; obj.memberfun(10);
} //Syntax Error: private member

4.2 Constructors
A constructor is a function that is automatically called when an object is created. This function can exhibit the
regular behaviour of any function except that it cannot return a value. The reason why constructors are needed is that
unlike regular functions which need to deliberately called, a constructor will be automatically called when an object
is created. Every constructor has a body from where we can call regular member functions.

Page 24
 Lab 3 - Access Specifiers, Constructors and Destructors

A very important question which is often asked is that how does the compiler know that the constructor function
needs to be called automatically? The answer is very simple. A constructor is a function that has the same name as
the class. Whenever an object is created the compiler searches for a function having the same name as the class i.e.
the constructor. Given below is a sample code that shows the class constructor. Generally the constructor is defined
as public. Also the constructor can be overloaded like a regular member function. An important point regarding a
constructor is that it cannot return a value. In fact writing the keyword void is strictly prohibited.

using namespace std; class myclass

{
private:
int datamember; public:
myclass( ); //Private data member
{
//Class constructor

cout<<”Hello you have called the class constructor”;

}
};

void main( )
{
myclass obj;
}

4.3 Destructors
Constructors are designed to help initialize/ create an object. Destructors on the other hand do exactly the opposite.
Destructors are called whenever an object goes out of scope. When this happens it is necessary to perform cleanup
procedures especially when you have used dynamic memory or you have been working with pointers in your code.
The destructor function can be used to free up memory that you have allocated or dereference pointers that were
referenced. The rules for a destructor are as follows:
 They have the same name as the class just simply preceded by a tilde (~)
 They can take no arguments
 They cannot return anything, not even void.

using namespace std; class myclass

{
private:
int datamember; public:
myclass( ); //Private data member
{
//Class constructor

cout<<”Hello you have called the class constructor”;

}
~myclass( );//Class constructor
{
cout<<”Hello you have called the class destructor”;
}
};

Page 25
 Lab 3 - Access Specifiers, Constructors and Destructors

4. Home Work Before Lab

5.1 Practices from home

Your task is to carefully understand the code provided. Analyze the code and suggest any corrections that may be
needed. There are both syntax and logical errors in the code so consider both when designing the correct solution.
Submit the correct code to the lab instructor.

class student
{
int age;
int cnic;
int semester;
char name;
public:
int setall(int a, int c, int s, int sem, char n) const;
{
age=a;
c=cnic;
semester=s;
name=n;
}
}

int myclass :: displayall ( )

{
cout<<”The entered data is”<<student.data;
}

void main( )
{
Student obj;
obj::setall( );
obj.displayall( );
obj.setage( );
Student anotherobj;
Student::anotherobj::setall( );
}

5. Procedure & Tools

6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008

Setup Visual Studio and make a project named “pizza”.

6.3 Walkthrough Task CLO(2,4)

Practice a Write a program that creates a class called pizza. The data members of the class are size, toppings, price,
thickness, extra toppings. Through the use of a constructor initialize the class object. Determine what is public and
private in the class.

Page 26
 Lab 3 - Access Specifiers, Constructors and Destructors

6.3.1 Writing Code

In the source file created in the project “pizza” write the following C++ code:

class pizza
{
private:
int size, price, thickness;
string topping;
public:
void setsize()
{
cout<<"Enter size of pizza: ";
cin>>size;
}
void setprice()
{
cout<<"Enter price of pizza: ";
cin>>price;
}
void setthickness()
{
cout<<"Enter thickness of pizza: ";
cin>>thickness;
}
void settopping()
{
cout<<"Enter toppings of pizza: ";
cin>>topping;
}
void display() const
{
cout<<"The ordered pizza details are: ";
cout<<"\nSize: "<<size;
cout<<"\nPrice: "<<price; cout<<"\
nTopping:"<<topping; cout<<"\
nThickness:"<<thickness<<"\n";
}
pizza() //class constructor: cannot have a return type
{
setsize();
setprice();
setthickness();
settopping();
}
};
void main()
{
pizza obj;
obj.display( );
}

Figure 1: The pizza class demonstrating the use of a constructor

Page 27
 Lab 3 - Access Specifiers, Constructors and Destructors

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below. Also run the code with other possible inputs.

Figure 2: Final output of pizza program.

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab03

7.1 Practice Task 1 CLO(2,4)

Practice to Write a C++ program that creates a program for a new ice cream vendor called LeCream. The
management of LeCream has decided that they are going to sell their ice cream in 7 different flavours namely
chocolate, vanilla, strawberry, mango, tutti fruit, almond crunch and coffee. Carefully design the program by
observing the following rules.
 LeCream is charging Rs 100 for two scoops and Rs 150 for three scoops. Hence you will need a function to
determine the number of scoops and based on that the price. If a user enters more than three scoops your
program should display invalid input and it should exit.

 LeCream allows its customers to purchase a vanilla wafer with their ice cream. If the customer wants to
purchase the wafer he will have to pay an additional Rs 10. This amount should be added to the total
amount payable by the user.

 If the customer asks for chocolate flavour then he will have to pay an additional amount i.e. Rs 120 for two
scoops and Rs 180 for three scopes. Design a function that will be called if the customer chooses flavoured
ice cream.

 The program should show a menu that asks the customer for his requirements and then displays the final
payable amount with full details about the flavour, number of scoops and wafer

Page 28
  In the end create a class destructor that displays a thank you message to the user.

Design your program using sound OOP practices. Carefully determine the data members, member functions, access
specifiers, activities to be performed in the constructor. Make sure that you use good naming conventions in your
code. A good design can earn you higher marks.

7.2 Outcomes
After completing this lab, students will be able to design a class that correctly implements class members by
observing access specifiers. The students will also be familiar with the use of a constructor and destructor.

7.3 Testing
Test Cases for Practice Task-1
Sample Inputs Sample Outputs
Flavour = chocolate Your choice of ice cream is as follows
Wafer required = yes Flavour = chocolate
Number of scoops = 3 Number of scoops = 3
Wafer is required
Total price is 190

Thank you for visiting LeCream!

Flavour = Almond crunch Your choice of ice cream is as follows

Wafer required = No Flavour = Almond Crunch
Number of scoops = 2 Number of scoops = 2
Wafer is not required
Total price is 100

Thank you for visiting LeCream!

Flavour = Coffee Your choice of ice cream is as follows

Wafer required = yes Flavour = Coffee
Number of scoops = 3 Number of scoops = 3
Wafer is Required
Total price is 160

Thank you for visiting LeCream!

Flavour = Mango Invalid Input

Wafer required = No
Number of scoops = 4 Thank you for visiting LeCream!

Table 2: Confirmation of practice tasks T1

Practice Tasks Confirmation Comments

T1

Page 32
 Lab Manual for Object Oriented Programming
(LAB-04)
Constructor Overloading and Copy Constructors
Lab 04: Constructor Overloading and Copy
Constructors CLO(2,4)

1. Introduction
In the previous lab a detailed practice session was conducted that focused on access specifiers and constructors.
Constructors are special functions that are automatically called when an object is created. This lab is geared towards
an extended use of constructors through overloading. Another flavour of constructors is the copy constructor which
creates an object by using a previously implemented object. This can be accomplished through the use of a copy
constructor.

2. Objective of the Experiment

After completing this lab the student should be able to:
 Develop a constructor and then overload it
 Understand the difference between a parameterized constructor and non parameterized constructor
 Develop a copy constructor and facilitate the copying of data from one object to the other.

3. Concept Map

4.1 Function Overloading

Function overloading is an advanced concept in modern languages where two function can have the same name. The
question that arises here is that how does a compiler know which function to call. The simple answer is that the

Page 33
function calling is determined based on the type of parameters/ the number of parameters being passed/ order of
parameters being passed. Hence two function can have the same name but there must be a difference in the number
of parameters, type of parameters or the order of parameters. For example in the function prototypes below the
function fun( ) has been overloaded and its different flavours are presented.

int fun (int, float, float);

int fun (int, float);

Page 34
 Lab 4 - Constructor Overloading and Copy Constructors

int fun (float, float, int);

It is important to highlight here that if two functions have a different return type then it does not mean that they are
overloaded. For a function to be overloaded it is necessary for the function to exhibit changes in the parameters.

4.2 Constructor Overloading – Parameterized and Nullary Constructors

Constructors are designed to help initialize/ create an object. A constructor is a special function that is automatically
called upon the creation of an object. The important fact that needs to be communicated is that constructors do not
have a return type. In fact using the keyword void is also prohibited.
Constructors are of two types namely:
 Nullary Constructors / Parameterless Constructors – Those constructors that do not need a parameter to be
called.
 Parameterized Constructors – Those constructors that require parameters for their calling
Inside a class C++ allows us to overload a constructor just like any other function. This means in the same class you
can have a nullary constructor alongside a parameterized constructor. Consider the code below for further reference.
class example
{
private:
int one; int two;
float three; public:
example( )
{
... //Nullary constructor
}

example (int on, int tw, float th) //Overloaded Constructor:

parameterized ->1
{
...
}

example (int on, float th, int tw) //Another overloaded Constructor
: Parameterized ->2
{
...
}
};
int main()
{
example obj;//Creation through nullary constru
example obj2(1, 2, 3.3);//Creation through first parameterized constru example obj3(1

4.3 Copy Constructors

Copy constructors provide a function through which you can create a new object from an existing already created
object. This feature is commonly used in simple programming and hence its need can arise at any time when
working with objects. C++ provides a default copy constructor that will assist in the copying of simple objects. For

Page 35
 Lab 4 - Constructor Overloading and Copy Constructors

example objects that do not use pointers or arrays. Although the default copy constructor will copy any type of
object but it is strongly recommended that the copy constructor be used only for objects that have non pointer data
members. The default copy constructor performs a member by member copy i.e. the copy constructor creates an
exact copy where data members are copied one by one to the new object. Always remember that in copy
constructors the original object is maintained in its original state and the copy changes are only exhibited in the
newly created object. In this lab we will just restrict ourself to the use of the default copy constructor.
The default copy constructor can be explicitly called as follows:

clss obj2(obj1); // Function calling notation

clss obj2 = obj1; //Assignment statement notation

Both statements create an object of the clss class. Of course any of the above statements can be used for copying an
object into another object.
Caution: The copy constructor is always called at the time of creating a new object. If at any time after the creation
of objects you copy contents of one object to the other then the copy constructor is not called. We will discuss more
on this in future lectures.

4. Home Work Before Lab

Provided below is a statement for a program which you will code and submit to your lab instructor.

5.1 Practices from home

Your task is to create a class called examination. The class has data members duration, credit_hours, course title,
month, date, year and time. Your task is to create the individual member functions and call them using the class
constructor. Be very vigilant in determining the access specifiers for the data members and member functions.

5. Procedure & Tools

6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008

Setup Visual Studio and make a project named “student”.

6.3 Walkthrough Task CLO(2,4)

Practice to Write a program that creates a class called student. The data members of the class are name and age.
 Create a nullary constructor and initialize the class object.
 Create a parameterized constructor that can set the values being passed from the main function.
 Create a display function called showall( ) which will be used to show values that have been set.
Use the default copy constructor to show that copying of simple objects can be accomplished through the use of the
default copy constructor.

6.3.1 Writing Code

In the source file created in the project “student” write the following C++ code:

Page 36
 Lab 4 - Constructor Overloading and Copy Constructors

class student
{
private:
string name;
int age;
public:

student() //Nullary constructor

{
cout<<"Enter name ";
cin>>name; cout<<"\
nEnter age ";
cin>>age;
}
student(string n, int a) //parameterized Constructor
{
name=n;
age=a;
}
void showall()
{
cout<<"\nName= "<<name;
cout<<"\nAge= "<<age;
}
};
int main()
{
student s1; //Creation through nullary constructor
student s2("Ali", 30); //Creation through parameterized constructor
s1.showall();
s2.showall();
student s3(s1); //Calling copy constructor for s3
s3.showall();
return 0;
}

Figure 1: The student class demonstrating the use of a parameterized and nullary constructor. Also note the default
copy constructor being used

Page 37
 Lab 4 - Constructor Overloading and Copy Constructors

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below. Also run the code with other possible inputs.

Figure 2: Final output of student program.

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab04

7.1 Practice Task 1 CLO(2,4)

VISION is a world leader in manufacturing LCD Televisions. The company has decided that it will allow its
customers to give the dimensions of the TV (in length and width). Once the length and width are ordered the
company will manufacture the TV according to your requirements. In this regard they want you to create a program
that will assist them. Carefully read all the instructions and follow the requirements.
 Create a class called vision
 Create three constructors as follows:
- A nullary constructor that calls the setlength( ) and setwidth( ) function.
- A parameterized constructor that will receive the length and width as integers
- A parameterized constructor that will receive the length and width in float
 By using a special function calculate the area of the TV
 Create a function to calculate the price of the TV by multiplying the area with Rs. 65.
 Create a display( ) function to show the details of the purchased TV.

In the main you will construct three objects that demonstrate the use of the three constructors. After calling the
constructor it will take over and will handover control to the area function, and then the price calculation function.
Remember that the user should not have access to modifying the price.

Determine the access specifiers, data members and member functions. Also note that each constructor can / will
have a distinct functionality in its body. Hence do not try to copy code from one constructor to the other. Focus on
the design clarity and quality of your code.
Page 38
7.2 Practice Task 2 CLO(2,4)
Once you have completed the above task you are also required to use the default copy constructor to show that
values have been copied to the new created object. Use the display( ) function to show the individual objects.

7.3 Outcomes
After completing this lab, students will be able to construct a class object by using parameterized constructors. The
students will also be familiar with the use of a constructor and destructor.

7.4 Testing
Test Cases for Practice Task-1
Sample Inputs Sample Outputs
Using Nullary constructor Your LCD purchase details are:
Length = 48
Length = 48 Width=30
Width = 30
Price=93600

Using parameterized constructor (integer) Your LCD purchase details are:

Length = 48
Length = 48 Width=30
Width = 30
Price=93600

Using parameterized constructor (float) Your LCD purchase details are:

Length = 48
Length = 40.5 Width=30
Width = 30.5
Price=80291.25

Test Cases for Practice Task-2

Sample Inputs Sample Outputs
Initialize only one of the objects and use it for Call the display function using the new object;
copying values into another object by using the
copy constructor The new object will contain the values of the previous object.

Table 2: Confirmation of practice tasks T1, T2

Practice Tasks Confirmation Comments

T1
T2

Page 41
Lab Manual for Object Oriented Programming
(LAB-05)
Shallow Copy / Deep Copy
Working with Arrays

Page 42
 Lab 5 - Shallow Copy/ Deep Copy, Working With Arrays

Lab 05: Deep Copy / Shallow Copy and Arrays in

Classes CLO(1,2,4)

1. Introduction
In the previous lab a very basic introduction to copy constructors was presented. The purpose of a copy constructor
is to assist in the creation of exact copy of an object when it is being created. From the perspective of a beginner this
is enough but when we investigate the concept of copying we find that the default copy constructor is not enough.
Hence we need to define our own copy constructor. In this lab the creation of a copy constructor with details about
deep copy and shallow copy will be presented.
Arrays play an important role in any program. Arrays can be used in many forms in OOP for example arrays as data
members, arrays of objects, using static and dynamic arrays and finally the relationing arrays and constructors. All
these aspects of arrays will be discussed in detail in this lab.

2. Objective of the Experiment

After completing this lab the student should be able to:
 Understand the difference between a shallow copy and deep copy constructor.
 Explain why a deep copy constructor is needed
 Program a customized copy constructor (both deep and shallow)
 Create an array of objects
 Create and initialize an array of objects.
 Create and use an array as a data member.
 Use both static and dynamic arrays in classes.

3. Concept Map

4.1 Creating a customized copy constructor

Although C++ provides you with a basic copy constructor, but still there are occasions when you need to design you
own copy constructor. Given below are some of the reasons why you might want to create a copy constructor.

 You need to copy only some of the data members to a new object.
 Your objects contain pointers.
 Your objects contain dynamic data members.

Page 43
 Lab 5 - Shallow Copy/ Deep Copy, Working With Arrays

There may be other numerous reasons why you might want to create a customized copy constructor. Before you
begin you must familiarize yourself with the syntax of a copy constructor. A copy constructor always receives an
object as a parameter and hence we can extract the data from the parameterized object and place the data in the
newly created object. Presented below are the two syntax for copy constructors:

MyClass (MyClass& other ); // A copy constructor prototype for a class

called MyClass

MyClass (const MyClass& other ); //const copy constructor prototype for

class called Myclass

In the above prototypes the object which will be copied is called “other”. By writing the const keyword a copy of an
object can be created without any change to the inherent data members. Although only some of the data members
can be copied.

4.2 Shallow Copy Constructor

A shallow copy constructor is a copying function that does a member by member copy of one object to another. The
copy constructor provided by default is a shallow copy constructor. If a class does not have any dynamic members
then only a shallow copy constructor is needed.
Consider another case in which you want to create a partial copy of an object i.e. you only want to copy some of the
static data members then we need the help of a shallow copy constructor.
class example
{
private:
int a; int b;
public:
example (example & parame)
{ //shallow copy constructor
a=parame.a; b=parame.b;
}
void showall( )
{
cout<<"\na="<<a; cout<<"\nb="<<b;
}
example( )
{
a=10; b=20;
}
}; //Simple constructor
int main()
{
example obj1; example obj2(obj1); obj1.showall(); obj2.showall(); return 0;
}

Page 44
 Lab 5 - Shallow Copy/ Deep Copy, Working With Arrays

In the above code when object obj1 is created the nullary constructor is called and hence values 10 and 20 are
allocated to data members a and b respectively. Now when object obj2 is being created obj1 is passed to the copy
constructor as an argument. While creation of obj2 control is never shifted to the basic constructor because we are
attempting to make a new object by copying.

4.3 Deep Copy Constructor

A deep copy constructor is a constructor that has been designed to handle pointers and dynamic data members.
Although a shallow copy constructor will also copy pointers but it does so in an incorrect way. Hence it is logically
wrong to use a shallow copy constructor for dynamic data members.
The problem with shallow copy constructors:
The problem with shallow copy constructors is that suppose you have a class that has a pointer as a data member and
you want to create a copy of this class object. When you call the shallow copy constructor it will copy the pointer
data member to the new object. You might think this is what we want but in fact it is wrong because copying a
pointer means that you have copied the data and the address to which the pointer is pointing. Hence you have on
hand two objects that are pointing to the same memory location. Always remember that two objects should have
their own distinct identity and distinct memory.
Memory Copy of Object 1
Object 1

(a)
Memory
Copy of Object 1
Object 1

(b)

Figure 1: The effect of copy constructors on a pointer data member (a) using shallow copy (b) Using deep copy
In the code snippet below a deep copy constructor has been provided that creates a copy of a char array. The data
member len is being used to hold the length of the array.

class example
{
private:
char *str;
int len;
public:
example( ); // one normal constructor
example(char *s); // another normal constructor
example(const example &st) //Deep copy constructor
{
len = st.len;
str = new char [len + 1];
strcpy(str, st.str);
}
// other stuff
};

Page 45
 Lab 5 - Shallow Copy/ Deep Copy, Working With Arrays

When working with copy constructors it is important to remember that the copy constructor function prototype is the
same for both shallow copy and deep copy. Hence the difference lies in the fact that dynamic data members are
being handled or not. To determine if a deep copy or shallow copy constructor is being used you have to study the
copy constructor body.

4.4 Working with Arrays

As explained earlier, arrays are of very importance in every program. The main reason for their importance is that
they provide contiguous memory locations that can be accessed with a simple iterative mechanism like loops. When
it comes to classes we have many options relating to arrays. All the possibilities related to arrays are part of this lab.
Given below is a class named example that contains a simple (static) floating point array “a”. This array can be
initialized with a constructor or with a simple member function as follows.

class example
{
private:
float a[10]; public: //array as a data member
example()
{ // normal constructor

for(int i=0; i<=9;i++)

{
a[i]=0; // put the value 0 in all locations
}
}
// other stuff
};

Given below is a class named example that contains a dynamic floating point array “a”. This array can be initialized
with a constructor or with a simple member function as follows. Since this code works with a dynamic array
therefore the size of the array can be provided at run time. In this particular code since the size is not passed there
may be a possibility that the programmer crosses the array boundary.

class example
{
private:
float *a; public: //Dynamic array as a data member
example()
{ // normal constructor
a=newfloat[10];
//size can be passed from main to constru

for(int i=0; i<=9;i++)

{
a[i]=0; // put the value 0 in all locations
}
}
// other stuff
};

Given below is a class named example that contains a dynamic floating point array “a”. This array can be initialized
with a constructor or with a simple member function as follows. Since this code works with a dynamic array

Page 46
 Lab 5 - Shallow Copy/ Deep Copy, Working With Arrays

therefore the size of the array can be provided at run time. In this particular code since the size is not passed there
may be a possibility that the programmer crosses the array boundary.
Another option which is very popular among programmers is that the size of the array can be stored as a data
member.

class example
{
private:
float *a; public: //Dynamic array as a data member
example(int size)
{
a=newfloat[size]; to the constructor
//The size is passed from the main

for(int i=0; i<=9;i++)

{ a[i]=0;
} // put the value 0 in all locations

}
void showall (example arr[ ], int size)
//Size is passed to restrict from crossing array boundary
{
for(int i=0; i<size; i++)
{
for(int j=0; j<size; j++)
{
cout<<arr[i].a[j];
}
}
}
};

int main()
{
const int size=10;
example obj1[size]=example(size);
//array of objects initialized with parameterized constructor
example obj2;

obj2.showall( obj1, size ); return 0;

}

4. Home Work Before Lab

Provided below is a statement for a program which you will code and submit to your lab instructor.

5.1 Practices from Home CLO(1,2,4)

Constructors of a class can be both public and private. Explain why you would create a private constructor. Create a
simple class with a single data member of your choice. Create a private constructor.
In your code demonstrate how a private constructor is called and how the object is created using a private
constructor.

Page 47
 Lab 5 - Shallow Copy/ Deep Copy, Working With Arrays

5. Procedure & Tools

6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008

Setup Visual Studio and make a project named “english”.

6.3 Walkthrough Task CLO(2,4)

Try to Write a program that creates a class named “english”. The class has a string data member called sentence
and another called size that shows the number of characters of the string. Create a constructor that initializes the
class objects. Also create a copy constructor that copies the data of one object to the other.

6.3.1 Writing Code

In the source file created in the project “english” write the following C++ code:
class english
{
private:
string sentence; int size;
public: example()
{
cout<<"Enter your sentence: "; getline(cin,sentence); size=9; size=sentence.length();
}
example (example & tempobj)
{
size = tempobj.size; sentence=tempobj.sentence;
}
void showall()
{
cout<<"\nSentence: "<<sentence; cout<<"\nCharacters: "<<size<<"\n";
} };
int main( )
{
english obj1; english obj2=obj1;
cout<<"Object one contains data"; obj1.showall();
cout<<"Copied object contains data"; obj2.showall();
return 0;
}

Figure 1: The english class

Figure 1: The “english” class demonstrating the use of a constructor and a copy constructor.

Page 48
 Lab 5 - Shallow Copy/ Deep Copy, Working With Arrays

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below. Also run the code with other possible inputs.

Figure 2: Final output of “english” class

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab05

7.1 Practice Task 1 CLO(2,4)

Lamborghini is an international luxury sports car developer stationed in Italy. The company has a reputation for
producing cars that are extremely expensive, powerful and rare. Lamborghini has developed a brand new model
called the Diablo. The company produces a very limited number of Diablo’s each year. The company is producing
the Diablo in only one colour called the “Hot Red”.
When the company has produced a Diablo, the car has a number of attributes like colour, cubic capacity, number of
seats, year of manufacture, engine number, frame number and owner name. Out of these attributes the attributes that
remain the same for all Diablo’s being produced are colour, cubic capacity and number of seats.
Suppose you are working on a system specially designed for the Lamborghini Diablo try to write a c++ program.
Follow the instructions below for creating the class and objects:
 Store the owners name as a dynamic array data member.
 Create an object named “obj1” and initialize the object.
 Create a copy constructor that can copy all those attributes that remain the same for all cars.
 Generate another object named “obj2” that is created by copying only those attributes that are the same from
“obj1”.
 Initialize the remaining attributes with values of your own.

7.2 Practice Task 2 CLO(2,4)

Your task is to create a class that contains an integer pointer data member. Create a single object named “one” in the
Page 49
main and assign values to the data member of the object. Then create another object named “two” that is a copy of
the “one”. Create a shallow copy constructor and then demonstrate that both objects share a common memory i.e.
modifying one object in fact modifies the other. Create a display function that will show the values of the object.

7.3 Outcomes
After completing this lab, students will be able to conveniently use a copy constructor in both deep copy and
shallow copy mode. Further the students will have the ability to comfortably use arrays in their various forms both
inside and outside the class.

7.4 Testing
Test Cases for Practice Task-1
Sample Inputs Sample Outputs
Colour = Hot Red After selective copying only the permanent attributes contain
Owner = Ali Raza values.
Year of manufacture = 2013 Colour = Hot Red
Seats = 2 Owner =
Cubic Capacity = 5700 Year of manufacture =
Engine number = 123456 Seats = 2
Frame number = 987654 Cubic Capacity = 5700
Engine number =
Frame number =

Test Cases for Practice Task-2

Sample Inputs Sample Outputs
Initialize only object “one” and use it for Upon calling the display function of object “one” the modified
copying values into object “two” by using the values will be displayed
copy constructor.
Make a modification in object “two”. Upon calling the display function of object “two” the same
Call the display function of object “one”. modified values will be shown.

Table 2: Confirmation of practice tasks T1 and T2

Practice Tasks Confirmation Comments

T1
T2

Page 52
Lab Manual for Object Oriented Programming
(LAB-06)
Friend Functions and Friend Classes

Page 53
 Lab 6 - Friend Functions and Friend Classes

Lab 06: Friend Functions and Friend Classes CLO(1,2,4)

1. Introduction
In object oriented programming one of the basic goals was to enforce encapsulation and data hiding. This is a
feature that ensures that class members are not accessible openly. We want to provide access to class members
through a regulated mechanism in which all accesses are accountable and legal.
Friend functions and friend classes provide a technique through which you can relax the access specifiers and
provide direct access. Although this seems an attractive technique but it is not liked by hardcore programmers
because of its over relaxing attitude. The concept of friend functions is still important because they need to be used
in operator overloading which will be practiced in the next lab. Hence this lab attempts to build new concepts which
will be used in the next lab.

2. Objective of the Experiment

After completing this lab the student should be able to:
 Understand the difference between a regular function and a friend function
 Explain the concept of a friend function.
 Develop a friend function.
 Explain the concept of a friend class.
 Develop a friend class.

3. Concept Map

4.1 Friend Functions

Before going to the syntax of friend functions it is important that we highlight why they are needed. Friend functions
provide a relaxing mechanism through which we can access the private data members of a class directly without any
question being asked. This does not mean that we have relaxed the access specifiers. A friend function provides
access to the private and public data members of a class from only within its body. Friend functions are needed
because sometimes if we have multiple classes and we want to manipulate the class members through a single
function.

Page 54
 Lab 6 - Friend Functions and Friend Classes

Another similar scenario is when we want a regular function (that is not member of a class) to access private
members of a class. The final scenario is the use of friend functions in operator overloading (will be discussed in lab
7).

Always remember that friend functions are not members of a class they are just regular functions with special
privileges. In order to make a friend function you have to specify that a particular function is a friend function. This
can be achieved through the following syntax:

class second; class first //Forward Declaration

{
private:
int member1; int membern;
public:
friend void fun( first , second );
};
//Friend function prototype

class second
{
private:
int mem1; int mem2;
public:
friend void fun( first, second );
}; //Friend function prototype

void fun( first o1, second o2) //Note that friend is not written
{
cout<<o1.member1<<o1.membern; cout<<o2.mem1<<o2.mem2;
}
void main( )
{
first obj1; second obj2;

fun( obj1,obj2);//Simple calling. Cannot use the dot operator

}

In the syntax above it must be understood that access specifiers are not applicable on friend functions i.e. whether
you write the function in public or private it has no effect. Another important thing to always remember is that it is
compulsory to write the keyword friend with the function prototype but writing the friend keyword in the function
definition will result in a syntax error. In the above code the friend function is bridge between two classes using a
single function. Creating this environment is purely the programmers choice. It is not necessary that you have a
function working like a bridge. You can always have a single friend function inside a single class.

When discussing friend functions one must remember that friend functions are never part of a class. They are written
in the class to show that they have a friendship with the class. Friend functions are not called using the dot notation
or by using the scope resolution. Friend functions are called like a conventional function. Now when using the friend
function we can access both public and private data members directly as if there is no such thing as an access
specifier.

Page 55
 Lab 6 - Friend Functions and Friend Classes

An important note regarding friend functions is that these functions should not be used to relax the access specifiers.
Secondly the friendship of a function is one sided i.e. the function can access the class members but the class cannot
access deceleration that are made inside the function.

4.2 Friend Classes

A friend function has access to those classes with which it is friend. Sometimes a situation arises when we want to
make two classes friends with each other. This means that a class can access the public and private members of
another class directly. To achieve this you must right the friend class statement in the befriending class.
class first
{
private:
friend class second; //Declaration of friend class
int member1; int membern;
public:
first()
{
member1=10; member2=20;
}
};

class second
{
private:
int mem1; int mem2;
public:
void fun( first o1)
{ //Friend function prototype
cout<<o1.member1<<o1.membern; cout<<mem1<<mem2;
}
};

void main( )
{
first obj1; second obj2;
obj2.fun( obj1);//cannot call using obj1! Obj1 does not contain a function called fun
}

4. Home Work Before Lab

Provided below is a descriptive problem. Your task is to read the question carefully then research the claims and
submit the answer to your lab instructor.

5.1 Practices from Home CLO(2,4)

Many programmers argue that friend functions and friend classes are against the ideology of OOP. Explain why
they think this is the fact. What qualities of OOP are affected by friend functions and friend classes. Explain in detail
and submit your written work to the lab instructor. There is no need to write any code for this task.

Page 56
 Lab 6 - Friend Functions and Friend Classes

5. Procedure & Tools

6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008

Setup Visual Studio and make a project named “series”.

Find the sum of 𝑎1 + 𝑎2 + 𝑎3 + ⋯ + 𝑎𝑛 arithmetic series. In an arithmetic series the difference between two
6.3 Walkthrough Task CLO(2,4)

consecutive numbers is the same throughout the series. Your class is composed of four data members i.e. the first
𝑛
n terms which has the formula 𝑆 = 𝑎 + 𝑎 . Use a friend function to compute the sum of the series.
entry of the series, last entry of the series, total number of entries for which sum is required and finally the sum up to
𝑛 2 1 𝑛

6.3.1 Writing Code

In the source file created in the project “series” write the following C++ code:

class series
{
friend class sum; int first; //Friend class declaration
int nterm; int entries; int sumn;
//First number
//Last number
//Total number of entries
//Sum up till n terms

public:
series(int f, int n, int e)
{
first=f; nterm=n; entries=e;
}
friend void display(series);
};
//Simple friend function

class sum
{
public:
void series_sum(series &obj)
{
obj.sumn=(obj.entries)*(obj.first+obj.nterm)/2;
}
};

void display(series obj) //Friend Function body

{
cout<<"The sum of series is "<<obj.sumn<<endl;
}

Page 57
 Lab 6 - Friend Functions and Friend Classes

int main()
{
series obj1(6,96,31); sum obj2; obj2.series_sum(obj1);
//(first term, last term, totaldisplay(obj1);
number of terms)
system ("pause"); return 0;
}
//Call the friend function

Figure 1: The series class and the sum friend class. The display function is a friend function.

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below. Also run the code with other possible inputs.

Figure 2: Final output of series project

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab06

7.1 Practice Task 1 CLO(2,4)

nd
As you know in mathematics the quadratic equation is a very popular 2 degree equation. Although there are many

The quadratic equation is 𝑎𝑥2 + 𝑏𝑥 + 𝑐 = 0 and its roots can be determined using the quadratic formula as
possible methods of solving the quadratic equation, a very popular method is through the use of quadratic formula.

−𝑏 ± 2 − 4𝑎𝑐
follows:

Page 58
 Lab 6 - Friend Functions and Friend Classes

2𝑎 where 𝑎 ≠ 0

Page 59
 Lab 6 - Friend Functions and Friend Classes

Your task is to create a class named equation which will have the data members a, b and c which are the
coefficients of the quadratic equation. The class will have two more data members namely proot and nroot which
stand for the positive root and negative root of the equation. Suppose that variables a, b and c are integers. Where
proot and nroot are floats.
 Construct the class objects by using a nullary constructor.
 Then design a friend function which will determine the proot and nroot of the equation.
 Create another friend function which will display the values of proot and nroot.

7.2 Practice Task 2 CLO(2,4)

Your task is to create two classes namely number and computation. The computation class is a friend of the number
class.
The number class will be composed of three floating point data members namely a, b and c. The class will also be
composed of a friend function display that can display all the data members.
The computation class is responsible for performing operations on the number class and hence it has three functions

 A function to compute the square of sums i.e. 𝑎 + 𝑏 + 𝑐 2 = 𝑎2 + 𝑏2 + 𝑐2 + 2𝑎𝑏 + 2𝑏𝑐 + 2𝑐𝑎

as follows:

 A function to compute the square of difference i.e. 𝑎 − 𝑏 − 𝑐 2 = 𝑎2 + 𝑏2 + 𝑐2 − 2𝑎𝑏 − 2𝑏𝑐 −

2𝑐𝑎
 A function to compute the mean of the three numbers

7.3 Practice Task 3 CLO(2,4)

Create a class called matrix that will find the sum of two matrices. To perform this task you will need to create
three private array data members that will hold the original arrays and an array to hold the sum of the matrices.
Suppose that the size of the matrices is 3x3.
Create a friend function which will add the matrices and store the result in the sum matrix. The sum of two matrices
is the sum of corresponding entries.

7.4 Outcomes
After completing this lab, students will be able explain the difference between a member function and a friend
function. The students will be able to create friend functions and friend classes. Further they will be comfortable
with the manipulation of objects using both friend functions and classes.

7.5 Testing
Test Cases for Practice Task-1
Sample Inputs Sample Outputs
a =1; proot= 1
b =2; nroot = -3
c =-3

Test Cases for Practice Task-2

𝑎 + 𝑏 + 𝑐 2 =36
Sample Inputs Sample Outputs

𝑎 − 𝑏 − 𝑐 2 = 16
a=1
b=2
c=3 Mean = 2

Page 60
 Test Cases for Practice Task-3
Sample Inputs Sample Outputs
Create the following entries for 3x3 arrays Results should be as follows.

𝐴= 4 5 6
1 2 3

𝐴 + 𝐵 = 8 10 12
2 4 6
7 8 9
14 16 18
𝐵= 4 5 6
1 2 3

7 8 9

Table 2: Confirmation of practice tasks T1, T2 and T3

Practice Tasks Confirmation Comments

T1
T2
T3

Lab Manual for Object Oriented Programming

(LAB-07)
Introduction to Operator Overloading
Lab 07: Introduction to Operator Overloading CLO(1,2,4)

1. Introduction
In object Oriented Programming perhaps the most exciting and interesting feature is the adaptation of operators

Page 61
according to our class. We are all familiar with the use of different operators with primitive data types. But when it
comes to abstract data types we have to define each operator individually. The greatest advantage of defining each
operator is that we can adapt/ modify an operator according to our class and the objects.
As the name indicates, operator overloading is a basically an operator function whose functionality has been
overloaded. In this lab we will explore the concept of operator adaptation and their overloading. Later on we will
overload some operators for problems related to real world. This lab will explain how friend functions for
overloading stream operators.

2. Objective of the Experiment

After completing this lab the student should be able to:
 Express the need for operator overloading.
 Develop an operator overloading function for both unary and binary operators.
 Demonstrate the use of simple arithmetic operators.
 Demonstrate the use of prefix and postfix operators.
 Use friend functions to overload stream operators.
 Explain the difference between the assignment operator and the copy constructor.
 Use operators with class objects.

3. Concept Map

4.1 Introduction to Operator Overloading

Operator overloading is an attractive feature offered to programmers using classes and objects. It allows you to
create class objects and then manipulate them using operators just like variables of primitive data types. For
example we can add two integers by using the plus operator, but what happens when we apply the plus operator to a
class object. Without the help of operator overloading we cannot manipulate class objects using mathematical and
logical operators.

Page 62
 Lab 7 – Introduction to Operator Overloading

Some people have the opinion that operator overloading only makes your class complex and less understandable.
Another opinion which people have is that we do not need operator overloading because we can use typical member
functions to achieve a similar solution. Both of these opinions are greatly flawed, first of all operator overloading
does not increase the complexity of your code because it provides increased understandability and clarity to the
programmer. The second and most important fact is that you could always use regular member functions to create a
similar mechanism but C++ provides you with a proper technique for incorporating operators in your code. Operator
overloading has an added benefit that it allows the user to manipulate objects using proper operator symbols. This
feature cannot be achieved using member functions.

4.2 Which Operators Can Be Overloaded

C++ provides an extended range of operators that can be overloaded. These operators include the conventional
unary operators, mathematical operators, logical operators, stream operators, parenthesis operators and many more.
Because C++ provides such a wide range of operators that can be overloaded, therefore this feature of the language
is widely liked and adopted by programmers.

4.3 Operator Overloading – General Rules

Operator overloading allows the programmer to create an operator function that can be used just like any other
function. This means instead of having a textual name for a function your operator function will have a name that is
an operator symbol like +, -, *, / etc.
Before we begin with operator overloading one must memorize some standard rules. The rules are as follows
 Only those operators can be overloaded that have been defined by C++. This means you cannot create
your own operators. For example  will not qualify as an operator.
 It is not necessary that you overload the entire set of operators for a class. You only overload those that will be
used in your program.
 In a single expression you can use multiple operators but the order of precedence defined by the language
cannot be changed.
 If an operator is unary by nature then it cannot be converted to binary and vice versa.
 When you overload an operator it is purely your choice what comes in the operator function body. This means
you may be using the + operator but in the function body you can perform the / operation. Of course this is a
logical wrong and such things should be prevented. Hence defining the operator is purely up to the programmer.

4.4 Operator Overloading – Syntax

As explained previously, operator overloading is basically a function that has an operator symbolic name. The
operator function is created inside the class and it is used basically in the main. The code snippet below shows the +
operator being overloaded. The parameter is actually an object of the class because this operator is a binary operator
that requires one calling object and one object being passed as an argument. The return type of this function is
dependent on what you wish to return. If you are computing an expression having more than two objects then you
will need to create a temporary object and return the object for further computing of the expression . Refer to the
walkthrough task in this lab.
int operator + (classname obj) //The plus operator
{
. . .
}
Similarly the code snippet below shows the pre increment operator being overloaded.
int operator ++ ( ) //The pre increment operator
{
. . .}
Similarly the code snippet below shows the post increment operator being overloaded. The parameter is in fact never
passed; it is just an indicator to show that this function is a post increment operator. Hence whenever there is an
operator with a unary operator then it indicates that you are referring to a post increment operator.
int operator ++ (int n) //The post increment operator
{
. . . }
Page 63
 Lab 7 – Introduction to Operator Overloading

4.5 Stream Insertion and Extraction Operators

C++ allows its programmers to overload the stream insertion (<<) and stream extraction (>>) operators so that they
work with abstract types. Stream insertion and extraction operators already work with conventional data types but
when it comes to abstract data types the compiler is not aware of what to do if we use a class object with cout or cin.
The stream insertion and extraction cannot be overloaded without the help of friend functions. Friend function
provide input or output support with direct access to public and private members of the class.

class DoB
{
private:
int month, day, year;

public:
DoB( )
{
cout <<“Nullary constructor";
month = day = year = 0;
}
~DoB ( )
{
cout << ”Destructor called";
}
friend ostream & operator << ( ostream & os, DoB &d );
friend istream & operator >> ( istream & is, DoB &d );
};

ostream & operator << ( ostream & os, DoB &d )

{
os << d.day << "." << d.month << "." << d.year;
return os;
}
istream & operator >> ( istream & is, DoB & d )
{
cout << "\n\n Enter day of birth: ";
is >> d.day;
cout << "Enter month of birth: ";
is >> d.month;
cout << " Enter year of the birth: ";
is >> d.year;
return is;
}
void main(){
DoB date;
cout << "\n\n Enter your date of birth";
cin >> date;
cout << "\n Entered date is: " << date;
}

Page 64
 Lab 7 – Introduction to Operator Overloading

4.6 The Assignment Operator and the Copy Constructor

A very important operator that can be overloaded is the assignment operator(=). A very confusing question is the
difference between an assignment operator and the copy constructor. The simple logical answer is that copy
constructor provides an initializing mechanism where a new object is created by copying contents of another object.
On the other hand the assignment operator is used after an object is created. As the name says the assignment
operator will assign values to an object that has already been created.
Your compiler is aware of this difference and hence you cannot call the copy constructor when the assignment
operator is need. The vice versa of this is also true.

4. Home Work Before Lab

Provided below is a statement for a program which you will code and submit to your lab instructor.

5.1 Practices from Home CLO(1,2,4)

Create a class called book. The class will contain data members for name, publisher, author and price. Your task is
to create class objects in the main and provide different values to each object. Then design two functions as follows:
 add( ) – A function that will find the sum of prices of two book objects.
 compare() – A function that will tell the user which book has more price.
5. Procedure & Tools
6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008

Setup Visual Studio and make a project named “tolltax”.

6.3 Walkthrough Task CLO(2,4)

Create a class called “toll”. The class represents the toll tax of a vehicle. According to government policy the toll
tax of a vehicle is the number of wheels of vehicle multiplied by 6. Your class should have data members as follows:
wheels, tax, fine. Suppose the fine of a vehicle is 1 rupee. The + operator should work with multiple objects in main.
 Overload the stream insertion and extraction to input and output data of the objects
 Use the + operator to find the total tax collected in a day.
 Create the ++ operator to fine a particular car.

Page 65
 Lab 7 – Introduction to Operator Overloading

6.3.1 Writing Code

In the source file created in the project “tolltax” write the following C++ code:

Page 66
 Lab 7 – Introduction to Operator Overloading

Figure 1: The “toll” class demonstrating the use of various overloaded operators

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below. Also run the code with other possible inputs.

Page 67
 Lab 7 – Introduction to Operator Overloading

Figure 2: Final output of toll class

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab07

7.1 Practice Task 1 CLO(2,4)

Ali Raza is a frequent long distance driver. He wants to compute how much distance he covers over a number of
days. Ali also wants to know the average distance travelled.
To perform this task you will need to create a class called distance. The class will contain the fuel price in liter and
also the distance he has travelled. To find the average and the distance travelled you will need to overload two
operators as follows:
 + operator to compute the total distance travelled.
 / operator to compute the average distance travelled.
In the main( ) you will create six objects and then you will write a single expression that will demonstrate the use of
+ and the / operator. Your expression should resemble the following:
obj1+obj2+obj3+obj4+obj5+obj6 / 6

7.2 Practice Task 2 CLO(2,4)

Your task is to create a class called fraction. This class will have two integer data members namely numerator and
denominator. To make the task simple suppose that all fraction have the same denominator i.e. 5. Follow the
requirements given below:
 Create a fraction object called sum that will hold the sum of two fractions by using the + operator.
 Create a fraction object called difference that will hold the difference of two fractions by using the – operator
 Create a fraction object called multiple that will hold the product of any two fractions by using the * operator
 Overload the + operator so that it works with a fraction class object.
 Overload the – operator so that it works with a fraction class object.
 Overload the * operator so that it works with a fraction class object.
In the end create a display function through which you can display your fractions.

7.3 Practice Task 3 CLO(2,4)

A decimal number is composed of an integral part and a fractional part. The number appearing before the decimal
point is the integral part while the number appearing after the decimal point is called the fractional part. For example
if our number is 1.2 then 1 is the integral part while 2 is the fractional part. Using this concept develop the following
class.
Page 68
 Lab 7 – Introduction to Operator Overloading

Your task is to overload the prefix and postfix increment operators for a class called roundoff. The roundoff class
has a floating point data member called number. Overload the operators as follows.
 Overload the stream insertion and extraction operators to input/ output the data.
 Prefix increment – When this operator is called there will be an increment in the integer part of the number. For
example if our original number is 3.5 then after prefix increment the result will be 4.5
 Postfix increment - When this operator is called there will be an increment in the fractional part of the number.
For example if our original number is 3.5 then after postfix increment the result will be 3.6.

7.4 Outcomes
After completing this lab, students will be able to customize an operator so that it works with their classes. Students
will be able to redefine familiar mathematical operators and also the stream insertion and extraction operators.

7.5 Testing
Test Cases for Practice Task-1
Sample Inputs Sample Outputs
obj1= 10 The average distance covered is 23.33
obj2= 20
obj3= 40
obj4= 20
obj5= 30
obj6= 20
Provide any value for fuel

Obj1+obj2+obj3+obj4+obj5+obj6/6

Test Cases for Practice Task-2

Sample Inputs Sample Outputs
obj1.numerator = 1 4
obj1.denominator = 2 Sum = obj1 + obj2 =
2
obj2.numerator = 3 -2
obj2.denominator = 2 Difference = obj1- obj2 =
2
3
Product = obj1*obj2 =
4

Test Cases for Practice Task-3

Sample Inputs Sample Outputs
Number = 9.5 After post increment result is 9.6
First call the post increment
After pre increment result is 10.6
Then call the pre increment
Check the overloading of stream insertion and extraction

Table 2: Confirmation of practice tasks T1, T2 and T3

Practice Tasks Confirmation Comments

T1
T2
T3

Page 69
Lab Manual for Object-Oriented Programming
(LAB-08)
Inheritance in Object Oriented Programming

Page 72
Lab 8 - Inheritance in Object Oriented Programming

Page 73
 Lab 8 - Inheritance in Object Oriented Programming

CLO(1,2,4)
Lab 08: Inheritance in Object Oriented Programming
1. Introduction
Object-Oriented Programming (OOP) strongly supports reusability and in this regard inheritance is perhaps the
strongest way of reusing the features of a class i.e. attributes (data member) and behaviors (functions). Following the
OOP paradigm, C++ allows the inheritance among classes so that the characteristic(s) of one class is/are inherited by
the other class(es). Hence, you can say that the derived classes receive some their attributes from which the derived
class is inherited. A major advantage of inheritance is that it allows the reusability of code. Hence, the programmer
can simply create new (child) class(es) by using other (parent) class(es).

While considering the advantages of commonality between classes, in C++, you are able to manage your classes in a
way that a class (child/sub class) can extend the functionality by inheriting the attributes and behaviors of an
existing class commonly known as base/super class. In simple words, you can define a class with certain data fields
and/or member functions and then identify other class(es) that can share these data fields and functions. In typical
C++ inheritance, a class or classes known as derived class(es), subclass(es) or child class(es) is/are able to inherit
certain attributes and behavior of pre-existing class(es) that are known as base class(es), superclass(es), or parent
class(es). In practice, base classes are more general while derived classes are specialized version of base classes and
due to this reason, it is said that inheritance maintains generalization and specialization. With inheritance, you can
greatly save the time and lessen the effort to write duplicate code.

Concerning inheritance syntax in C++, if you have a base class named person inherited by a derived class named
student then you have to write code in the following way

class Person
{
//code statements go here
};
class Student: public Person
{
//code statements go here
};

In case of derived class’s object instantiation, default/no-argument constructor for the base class(es) are
automatically called first and are followed by calling derived class’s constructors. If base class(es) is/are without
default/no-argument constructor, then it is must to call explicitly any base class’s constructor even if there is no need
to call a constructor.

Regarding syntax, other details are given in the section 6.3.

Page 74
 Lab 8 - Inheritance in Object Oriented Programming

2. Objective of the Experiment

After completing this lab, the student should be able to:
 get basic understanding of inheritance concept in OOP
 derive class(es) from other base class(es) through inheritance
 understand the constructor and destructor chaining in inheritance hierarchy
 know how to invoke the base class’s constructors within derived class(es)

3. Concept Map
Inheritance is one of the most important building blocks of OOP. The concept of reusable classes is helpful to
manage objects. You can create new classes (derived classes) that are able to inherit certain attributes and behavior
of their ancestor or base class(es). Prior to working with inheritance, it is important to consider the following aspects
of inheritance.

 Inheritance represents “is-a” relationship in OOP i.e. any specific object is a type of a more general class
of object. For example, Train is a type of Vehicle
 By design, a derived class should inherit all attributes and behaviors of its base class(es)
 While declaring its own data fields a derived class can extend the features of its base class(es)
 While defining new functionality, a derived class can modify the behavior provided by the base class(es)

Inheritance in OOP saves a lot of work and time. You can save additional work as some of the object
definitions(class) already exists. Time saving is due to the reason that much of the code has already been written and
tested.

4. Homework before Lab

5.1 Problem Solution Modeling

Draw the UML diagram for the following task. You are required to bring this design with you and submit to
your lab instructor.

5.1.1 Problem description:

Design a class named Person and its two derived classes named Student and Teacher.

The Person class has

 Attributes i.e. name, age, phone number, and e-mail address
 Behavior i.e. work something

The Student class has

 Attributes i.e. registration ID, department, number of completed credit hours
 Behavior i.e. pay course registration fee

The class named Teacher contains the following

 Attributes i.e. staff ID, salary
 Behavior i.e. teach course(s)

Draw UML diagram for each class and show inheritance relationship among all classes.

Page 75
 Lab 8 - Inheritance in Object Oriented Programming

5.2 Practices from Home

5.2.1 Task-1 CLO(2,4)
Try to Create a class named Trigon inherited from the class GeometricShape (containing a single data member
named shapeName (a string) and a member function named setShapeName(shapeName). The class Trigon is
required to hold:
 Three data members i.e. base, perpendicular, and hypotenuse of type double
 A no-arg constructor that initializes all data members with value 1.0
 A parameterized constructor to initialize all data fields with user-defined values
 The setter functions for all three data fields
 The accessor functions for all three data fields
 A function named displayArea() that shows the area of a certain Trigon object

In the main() function make three objects of class Trigon while considering the shapeName as “threeangle” for
each object. In addition, it is required to invoke all the functions of Trigon class.

5.2.2 Task-2
Try to create a clasas of bank account: CLO(2,4)
The BankAccount class has the following attributes i.e.
 accountNumber, accountHolderName, and balance
 A parameterized constructor to initialize data fields with user-defined values

Create two derived classes i.e. CheckingAccount and SavingsAccount. Both these classes have
 A three argument constructor to initialize base class’s data fields
 Two functions i.e. deposit(amount) to deposit certain amount and witdraw(amount) to withdraw certain
amount

The withdraw function of CheckingAccount class has an overdraft limit but SavingsAccount cannot be overdraft.

In the main() function, create an object of both SavingAccount and CheckingAccount class. Moreover, test the
functionality of their respective deposit(amount) and withdraw(amount) functions while passing different amounts
as parameter.

5. Procedure & Tools

6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008 [Expected time = 5 mins]

Setup visual studio and make a project named “Inheritance”

6.3 Walkthrough Task [Expected time = 30 mins]

In this task, you are required to write a C++ code which would elaborate inheritance in OOP. The following lines
show the output of basic inheritance concept.

6.3.1 Writing Code

In the source file, which is created in the project “Inheritance” write following C++ code:

Page 76
 Lab 8 - Inheritance in Object Oriented Programming

.
Figure 1: Base and Derived Classes

Figure 2: Main function for classes of Figure 1

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below. Also run the code with other possible inputs.

Page 77
 Lab 8 - Inheritance in Object Oriented Programming

Figure 3: Final Output

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab08

7.1 Practice Task 1 CLO(2,4)

Try to create a class of employee.Consider a base class named Employee and its derived classes HourlyEmployee
and PermanentEmployee while taking into account the following criteria.
 Employee class has two data fields i.e. a name (of type string) and specific empID (of type integer)
 Both classes (HourlyEmployee and PermanentEmployee) have an attribute named hourlyIncome
 Both classes (HourlyEmployee and PermanentEmployee) have three-argument constructor to initialize
the hourlyIncome as well as data fields of the base class
 Class HourlyEmployee has a function named calculate_the_hourly_income to calculate the income of an
employee for the actual number of hours he or she worked. One hour income is Rs. 150
 Similarly, PermanentEmployee class has function named calculate_the_income to calculate the income of
an employee that gets paid the salary for exact 240 hours, no matter how many actual hours he or she
worked. Again, one hour salary is Rs. 150.

Implement all class definitions with their respective constructors to initialize all data members and functions to
compute the total income of an employee. In the main() function, create an instance of both classes (i.e.
HourlyEmployee and PermanentEmployee) and test the working of functions that calculate total income of an
employee.

7.2 Practice Task 2 CLO(2,4)

Try to create a class of Bank account:
Consider a class BankAccount that has
 Two attributes i.e. accountID and balance and
 A function named balanceInquiry() to get information about the current amount in the account

Derive two classes from the BankAccount class i.e. CurrentAccount and the SavingsAccount. Both classes
(CurrentAccount and SavingsAccount) inherit all attributes/behaviors from the BankAccount class. In addition,
followings are required to be the part of both classes
 Appropriate constructors to initialize data fields of base class
 A function named amountWithdrawn(amount) to withdraw certain amount while taken into account the
following conditions
o While withdrawing from current account, the minimum balance should not decrease Rs. 5000
o While withdrawing from savings account, the minimum balance should not decrease Rs. 10,000
 amountDeposit(amount) to deposit amount in the account

In the main() function, create instances of derived classes (i.e. CurrentAccount and SavingsAccount) and invoke
their respective functions to test their working.

Page 78
7.3 Outcomes
After completing this lab, student will be able to understand the implementation and design of Inheritance in C++.

7.4 Testing

For both Practice Tasks, lab instructor must examine

 the implementation of above mentioned classes

 the creation of instances of specified classes
 the invocation of specified functions

Table 2: Practice Tasks Confirmation

Practice Tasks Confirmation Comments

T1
T2

Lab Manual for Object-Oriented Programming

(LAB-09)
The protected Access Specifier and Types of Inheritance

Page 80
 Lab 9 - The Protected Access Specifier and Types of Inheritance

Lab 09: The protected Access Specifier and Types of

Inheritance in C++ CLO(1,2,4)

1. Introduction
So far, you have learned the importance and use of two (public and private) access specifiers within class(es) of C+
+. You know that a class’s member functions are able to access class’s data fields having public or private
accessibility for all times. However, externally created object(s) can only access public data members of that class
and private data members are restricted to be accessed outside the class. For example, consider the following class:

class Examp
{
private:
int attribute;
public:
void show()
{
cout<<attribute;
}
};

Any externally created instance (e.g. Obj) of class Examp would not be able to access data member(s) directly while
using the dot (.) operator. Hence, in the main() function, the statement Obj.attribute is not legal but the statement
Obj.show() is legal.

It is sufficient to know about public and private access specifiers/modifiers in the absence of inheritance. However,
in case of inheritance, sometimes it is required to access data member(s) of base class in derived class(es) but not
outside these classes. In this situation, you must make access protected for that data member(s) rather than private or
public. Protected access will ensure access of data members only within inheritance hierarchy.

Another important use of access specifiers is their role in the inheritance process. Considering access specification in
C++, inheritance can be private, protected, or public. Each type of inheritance has specific rules to access base
class’s data member(s), which have been explained below.

Public Inheritance:
Syntax: class Student: public Person { };

If a class is derived from a base class with public specifier, then all public/protected member(s) of base class
become public/protected member(s) of derived class. However, private member(s) of base class are never accessible
from derived class directly.

Protected Inheritance:
Syntax: class Student: protected Person { };

If a class is derived from a base class with protected specifier, then all public/protected member(s) of base class
become protected member(s) of derived class. However, private member(s) of base class are never accessible from
derived class directly.

Private Inheritance:
Syntax: class Student: private Person { };

If a class is derived from a base class with private specifier, then all public/protected member(s) of base class
become private member(s) of derived class.

Page 81
 Lab 9 - The Protected Access Specifier and Types of Inheritance

2. Objective of the Experiment

After completing this lab, the student should be able to:
 get basic understanding of inheritance in OOP
 develop a derived class from a base class through inheritance
 understand the use of protected access specifier with class’s data members
 understand public, private, and protected types of inheritance

3. Concept Map
Inheritance is one of the most important building blocks of OOP. The concept of reusable classes is helpful to
manage objects. You can create new classes (derived classes) that are able to inherit certain attributes and behavior
of their ancestor or base class(es). Prior to working with inheritance, it was important to consider that data
member(s) should have private access and only through public member functions, you can access data members of a
class. However, with inheritance, it is sometimes required to have an intermediate level of accessibility to class’s
data member(s) that exists only within inheritance class hierarchy but not outside these classes.

C++ provides intermediate level of accessibility through protected access specifier. Data member(s) of a base class
with protected accessibility are only be directly accessible within base class and all of its derived classes but not in
other parts of the program. Nevertheless, you should be careful while making data field(s) protected. Use protected
access only where you think that derived classes will use base class data field(s). The access of protected data
members in the derived classes make them less secure than private data members.

Moreover, access specifiers also play their role in the inheritance process. Considering access specification in C++,
inheritance can be private, protected, or public. The effects of access specifiers in inheritance process on derived
class’s member(s) are different as illustrated in Table 2.

Table 2: Inheritance access specifiers and their effect on derived class members

Access Specifier with Inherited class

Private Protected Public
Private Inaccessible Inaccessible Inaccessible
Access Specifier with Data Protected private Protected protected
Member in Base class Public private Private Private

Page 82
 Lab 9 - The Protected Access Specifier and Types of Inheritance

4. Homework before Lab

5.1 Problem Solution Modeling

Draw UML class diagrams of the following task. You are required to bring this design with you and submit to
your lab instructor.

5.1.1 Problem description: CLO(2,4)

Design a class named Rectangle that includes

 data members for the length and width of a rectangle,
 respective mutator and accessor functions to set and get values of length and width, and
 a member function named recArea() to compute the area of rectangle (length x width)

From the Rectangle class, derive a class named Cuboid that contains
 a data field named height in addition to length and width,
 two functions named setHeight and getHeight() to set and get value of height data field, and
 a member function named cuboidArea() to calculate the area of a cuboid (length x width x height)
Draw UML diagram for each class and show inheritance relationship between these classes.

5.2 Practices from Home

5.2.1 Task-1
Try to create a class of Graduate course: CLO(2,4)
Consider a class named GraduateCourse that includes
 Three data members i.e.
o courseID (e.g. CS2133),
o courseName (e.g. OOP),
o creditHours (e.g. 3 or 4), and
o courseFee (e.g. Rs. 10,000).
 A parameterized constructor to initialize data members with values specified by the user

Derive a class named ResearchCourse from Course class, which contains

 An additional data field named experimentFee
 A parameterized constructor to initialize its own data member along with data members of the base class
inherited in derived class
 ResearchCourse class also contains a member function named setExperimentFee to modify the value of
its own data field
 A function named display to show the values of its own attribute along with the attributes of its base class
 A function named totalFee to display the value of aggregated fee (course fee + experiment fee) for a
particular course object

Implement both classes and in the main() function, create an instance of ResearchCourse class. Invoke appropriate
functions to display all attribute values as well as the total fee for this particular instance.

5.2.2 Task-2

Representing a point in the plane, a class named PlanePoint has CLO(2,4)

 Two data members i.e. X and Y (correspond to x and y coordinates) of integer type,
 Two accessor functions named as getX() and getY() to get values of data members X and Y
 A function named planeDistance() that calculates and returns the distance between two points in a plane

Derive a class named SpacePoint to imagine a point in a three-dimensional space and has following additional
features:
 A data member Z of type integer to represent the z-coordinate of a point in space

Page 83
 Lab 9 - The Protected Access Specifier and Types of Inheritance

 A no-argument constructor that constructs a point with coordinates (0,0,0)

 A constructor with three arguments that constructs a point with three specified coordinate values
 An accessor function, which returns the value of data field Z
 A function named spaceDistance to return the distance between two points in the space

Implement both the classes and in the main() create two points with different dimensions and invoke appropriate
function to display the distance between these two points.

5. Procedure & Tools

6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008

Setup visual studio and make a project named “InheritanceSpecifier”

6.3 Walkthrough Task CLO(2,4)

In this task, you are required to Practice TO write a C++ code which would elaborate protected access specifier
concept. The following lines show the output of basic Inheritance concept with protected data fields:

6.3.1 Writing Code

In the source file, which is created in the project “InheritanceSpecifier” write following C++ code:

Figure 1: Base and Derived Classes

Page 84
 Lab 9 - The Protected Access Specifier and Types of Inheritance

Figure 2: Main function for Figure 1

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below. Also run the code with other possible inputs.

Figure 3: Final Output

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab09

7.1 Practice Task 1 CLO(2,4)

NoteBook is the base class that holds
 data fields named manufacturerID (of integer type) and manufacturerName (of string type)
 A two-argument constructor to initialize data-fields with user-defined values
 Appropriate accessor and mutator functions to set and get values of data fields

Try to Derive two classes from the NoteBook class:

 ENotebook, which contains an attribute size of integer type and a setter member function to set size value
 PaperNoteBook, which contains an instance variable named totalPages along with a member function to
set total number of pages in a certain paper notebook object
 Both derived classes have function display to show all data field values (including values inherited from the
base class).

In the main() function, create objects of ENoteBook and PaperNoteBook classes and show the advantages of using
protected access specifier.

Page 85
 Lab 9 - The Protected Access Specifier and Types of Inheritance

7.2 Practice Task 2 CLO(2,4)

Try to create a class Music, which contains
 Three data members i.e. songTitle (of string type), singerName (of string type), and singingYear (of
integer type)
 A no-argument constructor to initialize all data members with default values i.e. “---”, “---”, and 0,
respectively
 A parameterized constructor to initialize all data members with user-defined values
 Three setter functions to set values for all data members individually

Derive a class named FolkMusic that contains

 A data field provinceName to hold the name of the province (of string type)
 A no-argument constructor to assign default value as “---” to provinceName
 A four argument constructor to assign user-defined values to songTitle, singerName, singingYear, and
provinceName
 A setter function to set the name of the province
 A function named show() that displays all data member values of invoking object

Write a main() function that instantiates objects of FolkMusic class and test the functionality of all its member
functions.

7.3 Practice Task 3 CLO(2,4)

A class named CafeService contains

 Two data members i.e. the orderID and the price of food item(s) served by
 A no-argument constructor to initialize both data fields with default values of “ord#0”, 0.0
 A parameterized constructor to initialize all data fields with user-defined values

Try to Derive a class named StaffService from the class CafeService that holds the following:
 Two data members i.e.
o serviceFee,
o the cabinNumber to which the service has been made

 A function named totalCharges that returns total cost of an order (including serviceFee + price of food
item(s) served)
 A parameterized constructor, which requires arguments for all of its own data fields as well as for the data
fields of base class
 A member function named display() to show all the details of an order including orderID, price, and
totalCharges

In the main() function, instantiate an object of class StaffService object and test the implementation of both classes
through this object.

7.4 Outcomes
After completing this lab, student will be able to understand the implementation and design of inheritance as well as
the use of protected access specifier in inheriting classes.

7.5 Testing

For all Practice Tasks, lab instructor must examine

 the implementation of all mentioned classes
 the creation of instances of specified classes
 the invocation of specified functions

Page 86
 Table 3: Practice Tasks Confirmation

Practice Tasks Confirmation Comments

T1
T2
T3

Lab Manual for Object-Oriented Programming

(LAB-10)
Multi-level and Multiple Inheritance

Page 89
Lab 10 - Multi-level and Multiple Inheritance

Page 90
 Lab 10 - Multi-level and Multiple Inheritance

Lab 10: Multi-level and Multiple Inheritance CLO(1,2,4)

1. Introduction
In the previous labs i.e. in [Lab 08] and [Lab 09], you have already learned that the inheritance in object-oriented
programming (OOP) is the ability to transfer attributes and behaviors from base/parent class(es) to derive/child
class(es). As a next step, it is essential to learn the types of inheritance on the basis of class hierarchies. Following
different class hierarchies, inheritance in OOP can be categorized as

 Single Inheritance: a single child class derived from a single base class
 Hierarchical Inheritance: multiple child classes derived from a single base class
 Multi-level Inheritance: a single derived class inherited from another derived class
 Multiple Inheritance: a single derived class inherited from more than one base classes
 Hybrid Inheritance: any legal combination of more than one type of inheritance

In particular, the main focus of this lab is concerned with the understanding of multi-level and multiple inheritance.
Multi-level represents the scenario of inheriting attributes and behavior of a class that is already inheriting attributes
and behaviors from other class(es). The syntax of writing C++ code to implement multi-level class hierarchy is
given as under:

class X
{
// code statements go here
};
class Y: public X
{
//code statements go here
};
class Z: public Y
{
//code statements go here
};
...

There is no limitation on the number of levels in multi-level inheritance.

Multiple Inheritance represents where a single class inherits attributes and behaviors from more than one class. The
syntax to write C++ code for multiple inheritance is given as under:

class X
{
// code statements go here
};
class Y
{
//code statements go here
};
class Z: public X, public Y
{
//code statements go here
};

2. Objective of the Experiment

After completing this lab, the student should be able to:
Page 91
 Lab 10 - Multi-level and Multiple Inheritance

 develop multiple level class hierarchies

 derive a child class from multiple base classes
 understand the advantages of multi-level inheritance and multiple inheritance

3. Concept Map
Inheritance is one of the most important building blocks of OOP. The concept of reusable classes is helpful to
manage objects because occasionally it happens that a class may have some features that it can derive from already
existing class(es). Hence, with inheritance, it is sometimes crucial to build multi-level class hierarchies or to derive
class(es) from multiple existing classes. To grasp the concept and need of multi-level and multiple inheritance,
consider the following class hierarchy
Person

Employee Student

Administration Academic

Dean/HOD
Figure 1: Class Hierarchies showing Multi-level and Multiple Inheritance

A person can be an employee or a student. An employee may have rights of admin officer or of academic officer.
These class hierarchies represent multi-level inheritance. However, a Dean or Head of Department (HOD) may have
rights to modify the status already defined by an admin or academic officer. This type of relationship between
classes is an example of multiple inheritance.

C++ facilitates users while supporting the implementation of both multi-level and multiple inheritance. There is no
limitation on the number of levels in multi-level inheritance and there is no limitation on the number of parent
classes from which a child can be derived. Nevertheless, as a good practice, it is recommended to restrict levels and
number of base classes to two in multi-level and multiple inheritance.

Page 92
 Lab 10 - Multi-level and Multiple Inheritance

4. Homework before Lab

5.1 Problem Solution Modeling

Draw UML class diagrams of the following task. You are required to bring this design with you and submit to
your lab instructor.

5.1.1 Problem description: CLO(2,3,,4)

Design a class named Staff that includes

 A data member named staffID
 A parameterized constructor to initialize staffID
 A getter function to get the value of staffID
Derive a class named Professor inherited from Staff class and contains
 Two additional data members i.e. departmentID and departmentName
 A parameterized constructor to initialize its own data fields along with the inherited data field
 Two getter functions that return the departmentID and departmentName, respectively
Derive a class named VisitingProfessor inherited from class Professor and has
 A data field named no_of_courses
 A data field named salary_per_course
 A function named totalSalary that returns total payment for all courses (i.e. no_of_courses *
salary_per_course)
 A member function named display to show total salary of visiting professor

Draw UML diagram for each class and show inheritance relationship between these classes.

5.2 Practices from home

5.2.1 Task-1 CLO(2,4)

Consider the problem description of section 5.1.1 of this lab that deals with three classes i.e. Staff, Professor, and
VisitingProfessor. Implement all these classes and in the main function, Try to create an object of class
VisitingProfessor and invoke its member function display to show total income of a visiting professor.

5.2.2 Task-2 CLO(2,4)

Try to Consider four classes named Animal, Mammal, Bird, and Bat.
 class Animal that includes the functionality of eating and breathing
 class Mammal derived from Animal class and has additional functionality of giving birth but not
hatching
 class Bird derived from Animal class and has specific functionality of flying
 class Bat derived from both Animal and Bird classes while inheriting the functionality of both these classes

Draw UML diagram for each class and show inheritance relationship between these classes. Moreover, illustrate the
implementation of these classes in C++.

5. Procedure & Tools

6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008 [Expected time = 5 mins]

Setup visual studio and make a project named “MultipleInheritance”

Page 93
 Lab 10 - Multi-level and Multiple Inheritance

6.3 Walkthrough Task [Expected time = 30 mins]

In this task, you are required to write a C++ code which would elaborate multiple-inheritance concept. The
following lines show the output of a basic multiple-inheritance concept:

6.3.1 Writing Code

In the source file, which is created in the project “MultipleInheritance” write following C++ code:

#include<iostream>
using namespace std;

class Student
{
protected:
int registrationNum,marks1,marks2;
public:
void getMarks()
{
cout<<"Enter the Registration number: ";
cin>>registrationNum;
cout<<"Enter the marks: ";
cin>>marks1;
cin>>marks2;
}
};
class SportActivity
{
protected:
int sportsmarks;
public:
void getSportsMarks()
{
cout<<"\nEnter the marks for sports: ";
cin>>sportsmarks;

}
};
class MarksStatment:public Student,public SportActivity
{
int totalMarks,averageMarks;
public:
void ShowStatement()
{
totalMarks=(marks1+marks2+sportsmarks);
averageMarks=totalMarks/3;
cout<<"\ntRegistrattion Number: "<<registrationNum<<"\nTotal marks: "
<<totalMarks;
cout<<"\nAvergae marks : "<<averageMarks;
}

};

Figure 1: Multiple Inheritance

Page 94
 Lab 10 - Multi-level and Multiple Inheritance

Figure 2: Main function for Figure 1

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below:

Figure 3: Final Output

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab10

7.1 Practice Task 1 CLO(2,4)

Try to Consider the following details of all classes for class hierarchy shown in Figure 1 of this lab.

 Class Person holds

o Two attributes i.e. name and year_of_birth
o A two-argument constructor to initialize its data members with user-defined values

 Class Student has

o Two attributes i.e. studentID and enrolledSemester
o A four-argument constructor to initialize its data members (including inherited data members)
o A function named display() to show the values of all attributes (including inherited attributes)

 Class Employee contains

o Five attributes i.e. employeeID, joiningYear, jobTitle (designation of an employee), courseID, and
courseTitle

Page 95
 Class Administration has
o A parameterized constructor to receive five arguments to initialize inherited attributes from class
Employee
(Concerning courseID and courseTitle, only null value is allowed to set for an admin officer)
o Two functions i.e. setJobTitle(employee) and getJobTitle(employee) to set and get job title of an
employee

 Class Academic has

o A parameterized constructor to receive five arguments to initialize inherited attributes from class
Employee
(Concerning employeeID, joiningYear, and jobTitle, only null value is allowed to set)
o Two functions i.e. setCourseID() and setCourseTitle()

 Only an instance of class DeanHOD should be able to modify values for employeeID, designation of an
employee, ID and name of a particular course.

Implement all these classes and within the main function, create instances of all classes (except class Employee) and
test the described working of all these classes.

7.2 Outcomes
After completing this lab, student will be able to understand the implementation and design of Multi-level and
Multiple Inheritance in C++.

7.3 Testing
 For Practice Task 1, while inspecting implementation of classes, lab instructor must ensure that student has
taken hold the concept of multi-level and multiple inheritance. Furthermore, it is required to check the
invocation of all functions with the created instances of all mentioned classes.

Table 3: Practice Tasks Confirmation

Practice Tasks Confirmation Comments

T1

Page 98
 Lab Manual for Object-Oriented Programming
(LAB-11)
Function Overloading and Function Overriding
CLO (1,2,4)
Lab 11: Function Overloading and Function
Overriding
1. Introduction
Earlier in Lab-09, you have already studied that a sub/derived class is able to access all non-private data members
and member functions of the base/parent class. Moreover, besides inheriting attributes and behaviors from base
class(es), the derived class also contains its own data members and member functions.

Function overloading is the availability of various functions within a class that differ from each other in function
signature i.e. various functions share same name with different parameter types or number of parameters.
Inheritance is not necessarily required to overload functions within a program.

On the other hand, in function overriding, there must exists inheritance relationship between classes (i.e. base and
derived) and functions’ signature are also required to be same in both parent and child class(es). However, derived
class(es) redefine function(s) having signature similar to base class’s function(s).

Following code provides an example where both concepts (function overloading and overriding) have been
elaborated:

class Base
{
protected:
void myFunc()
{
cout<<"Base Class’ Function";
}
};

class Derived: public Base

{
public:
void myFunc()
{
cout<<"Derived Class’ Function";
}
void myFunc(int a)
{
cout<<"Derived Class’ Function with Parameter Value" <<a;
}
};

Page 99
In the given example (above),
 At first, the class Derived shows function overloading while containing two functions differ from each
other in function signature (i.e. functions myFunc() and myFunc(int))
 Secondly, it also shows function overriding as it holds two function implementations with same signature
(i.e. besides myFunc() of its own, it also contains myFunc() inherited from the Base class.

2. Objective of the Experiment

After completing this lab, the student should be able to:
 Understand function overloading within a class
 Understand function overriding concerning inheritance class hierarchy
 Differentiate between function overloading and function redefining

3. Concept Map
Function overloading and function overriding are the two key concepts of a number of modern computer
programming languages.

Overloaded functions provide specific functionalities while taking into account the type/number of parameter(s) they
receive and the fundamental advantage is the cleanliness of code. For example, in the absence of overloading, a
computer program may have several functions with different names to calculate the area of a geometric shape as
shown below:

class GeometricShape{
public:
int squareArea(int sideLength);
int reactangleArea(int length, int width);
int triangleArea(int side1, int side2, int side3);
};

However, the same code with function overloading would be as

class GeometricShape{
public:
int area(int sideLength);
int area(int length, int width);
int area(int side1, int side2, int side3);
};

On the other hand, function overriding is the ability of redefining a specific behavior (function) of a base class
within derived class(es). Besides the provisioning of a specific modified implementation of a base class function,
function overriding is used to perform runtime polymorphism.

4. Homework before Lab

5.1 Problem Solution Modeling

Draw UML class diagrams of the following task. You are required to bring this design with you and submit to
your lab instructor.

Page
100
 Lab 11 - Function Overloading and Function Overriding

5.1.1 Problem description: CLO(2,3,,4)

Design a class named Automobile that includes

 A data member named currentSpeed
 A setCurrentSpeed function to set currentSpeed of an automobile
 A getCurrentSpeed function to get currentSpeed of an automobile

Derive a class named Car inherited from Automobile class and contains
 An additional data member named color
 A parameterized constructor to initialize its own data fields along with the inherited data field
 Two functions named setColor and getColor to set and get the color of a Car object, respectively

Derive a class named Limousine inherited from class Car and has its own functions (i.e. setCurrentSpeed,
getCurrentSpeed, setColor and getColor) to set/get speed and color for each of its specific instance

Draw UML diagram for each class and show inheritance relationship between these classes.

5.2 Practices from home

5.2.1 Task-1 CLO(2,4)

Practice a class named Calculator with typical four specific functionalities i.e. addition, subtraction,
multiplication, and division. Implement these functionalities as four functions with two parameters. It is also
required to overload all these functions for int and double data types. In the main function, create an object of class
Calculator and invoke its member functions while passing parameters of int and double type.

5.2.2 Task-2 CLO(2,4)

Try to Consider a class named Animal having typical function named eat that accepts a parameter of type string.
Three classes i.e. Herbivore, Carnivore, and Omnivore have been inherited from Animal class. All these classes i.e.
Herbivore, Carnivore, and Omnivore must have their own (overridden) eat function.

a) Draw UML diagram for each class and show inheritance relationship between these classes.
b) Implement all these classes
c) In the main function, create instances of Herbivore, Carnivore, and Omnivore classes and invoke eat
function with appropriate string parameter to display the liking of that animal in eating.

5. Procedure & Tools

6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008 [Expected time = 5 mins]

Setup visual studio and make a project named “FunctionOverloading”

6.3 Walkthrough Task [Expected time = 30 mins]

In this task, you are required to write a C++ code which would elaborate function overloading. The following lines
show the output of a basic function overloading concept:

6.3.1 Writing Code

In the source file, which is created in the project “FunctionOverloading” write following C++ code:

Page 101
 Lab 11 - Function Overloading and Function Overriding

Figure 1: Function Overloading

Figure 2: Main( ) function for Figure 1

Page 102
 Lab 11 - Function Overloading and Function Overriding

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below:

Figure 3: Final Output

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab11

7.1 Practice Task 1 CLO(2,4)

Practice to Create a class named GeometricShape containing
 Two data fields i.e. shapeType (a string) and area (of type double)
 A no-argument constructor to initialize all data fields with default values “NoShape” and 0.0
 A member function named computeArea() with returning value of area data field
 A member function named show() to display the details associated with an instance of this class

Derive a class named Rectangle from class GeometricShape that includes

 data members for the length and width of a rectangle,
 respective mutator and accessor functions to set and get values of length and width, and
 overriding function named computeArea() to compute the area of rectangle (length x width)
 overriding function named show() to display the details associated with an instance of class Rectangle

From the Rectangle class, derive a class named Cuboid that contains
 a data field named height in addition to length and width,
 two functions named setHeight and getHeight() to set and get value of height data field, and
 an overriding function named computeArea() to calculate the area of a cuboid (length x width x height)
 overriding function named show() to display the details associated with an instance of class Cuboid

Implement these classes and in the main() create instances of each class and test the functionality of overridden
member functions with these instances.

7.2 Practice Task 2 CLO(2,4)

 Try to Consider a class MusicalInstrument that contains
o A data member named as instrumentName of string type
o A data member named price of type double
o A member function displayPrice(MusicalInstrumentObject) that shows the price of the instrument
while evaluating the name of the instrument object that it accepts as a reference parameter
 Derive two classes named Flute and Guitar from the class MusicalInstrument that contain

Page 103
 Lab 11 - Function Overloading and Function Overriding

o A parameterized constructor to initialize data members that they inherit from the class
MusicalInstrsument

In the main(), create instances of MusicalInstrument, Flute and Guitar classes. Invoke displayPrice() with
MusicalInstrument object while passing references of Flute and Guitar instances.

7.3 Outcomes
After completing this lab, student will be able to understand the difference between function overloading and
function overriding within a class or class hierarchies.

7.4 Testing
 For Practice Task 1, lab instructor must confirm the implementation of classes i.e. GeometricShape,
Rectangle, and Cuboid. With instances of each class, test the invocation of proper overridden function.

 For Practice Task 2, lab instructor ensures the invocation of displayPrice() function with the
MusicalInstrument instance while receiving references of the instances of Flute and Guitar classes.

Table 3: Practice Tasks Confirmation

Practice Tasks Confirmation Comments

T1
T2

Page 104
 Lab 11 - Function Overloading and Function Overriding

Lab Manual for Object-Oriented

Programming
(LAB-12)
Polymorphism in Object Oriented Programming

Page 105
Lab 12 - Polymorphism in Object Oriented Programming

Page 107
 Lab 12 - Polymorphism in Object Oriented Programming

Lab 12: Polymorphism in Object Oriented

Programming CLO(1,2,4)
1. Introduction
In general, polymorphism means „various shapes‟ and within the context of an object-oriented programming (OOP)
language, it is the ability of an object to acquire various forms while referencing various instances of the different
classes in inheritance hierarchy. In OOP, a significant characteristic is the type compatibility of a derived class
pointer to its base class pointer. Taking advantage of this useful aspect, polymorphism establishes a new way of
programming.

To realize polymorphism in C++, you need

 A virtual function and
 A pointer of base class type

A member function of a base class can be made a virtual function if it is probable to redefine (override) this function
in the derived class. The significance of making a function virtual becomes evident when you want to invoke
function of derived class from a pointer of base class referencing derived class‟s object. Following code provides an
example of polymorphism mechanism in C++.

class Base
{
public:
virtual void func()
{
cout<<”Base Class Function”;
}
};

class Derived: public Base

{
public:
void func()
{
cout<<”Derived Class Function”;
}
};
void main()
{
Base *bPtr;
Derived dev;
bPtr = dev;
bPtr->func();
}

Upon calling func() with bPtr, Derived class func() will be invoked and output would be “Derived Class
Function”. In the absence of virtual keyword, func() of base would be called each time. Hence, it can be concluded
that virtual keyword allow a pointer of base class to call appropriate function of any of its derived class to whom it
is referencing. In this way, each time a different function will be invoked with the same function call. With
polymorphism, compiler does not know which function to call at compile and thus appropriate function call is
deferred to runtime. At runtime, the type of object that a base class pointer is pointing is recognized to call proper
function. This is known as dynamic or late binding.

Virtual keyword can also be used with destructors and classes. However, virtual keyword possesses different
meanings when used with destructor and classes as explained below.
Page 108
 Lab 12 - Polymorphism in Object Oriented Programming

Virtual Destructors:
In practice, it is always recommended to make the base class destructor as virtual. In the absence of virtual keyword
with base class destructor, upon deletion of any derived class‟s object only destructor of base class would be called.

Virtual Base Classes:

Virtual base classes can be used to avoid diamond problem of multiple inheritance that is explained as under.

class Base
{
protected:
void func()
{ cout<<”A Base Class Function”; }
};
class Derived1: public Base{ };
class Derived2: public Base{ };
class Derived3: public Derived1, public Derived2
{ };

In the code above, both (Derived1 and Derived2) classes contain a copy of func(), which is inherited from class
Base. Upon the invocation of func() with an object of Derived3 class, compiler would be unable to decide which
copy to use.

To overcome this situation, it is required to use virtual keyword with base class inheritance. Hence, the above code
would be implemented as

class Base
{
protected:
void func()
{ cout<<”A Base Class Function”; }
};
class Derived1: virtual public Base{ };
class Derived2: virtual public Base{ };
class Derived3: public Derived1, public Derived2
{ };

Pure Virtual Function and Abstract Class:

You may have observed that with any class hierarchy in OOP, derived class(es) become more specific version of
base class(es) which are more general or abstract. It is sometime good in practice to make the base class as abstract
class that contains only the most common features of all of its derived classes. In C++, you can make base class an
abstract class by declaring a pure virtual function in it. The syntax is given as under:

class Base
{
protected:
virtual void func() = 0;
};

Instantiation of an abstract class is not possible and you should override pure virtual function in derived class(es).

2. Objective of the Experiment

After completing this lab, the student should be able to:
 Distinguish between static binding and dynamic binding
 Understand polymorphism and dynamic binding while using virtual functions
 Declare abstract classes with pure virtual function
Page 109
 Lab 12 - Polymorphism in Object Oriented Programming

3. Concept Map
Following encapsulation and inheritance, polymorphism is the third important capability of OOP paradigm. The
fundamental inspiration behind polymorphism is that of dynamic binding. In this way, at compile time, compiler
knows nothing about which function to call. On the contrary, decision is made at runtime. Polymorphism helps
programmer to make program in general rather than specific. In simple words, it provides a single interface with
different implementations. Moreover, polymorphism facilitates program extensibility while permitting new derived
classes and functions to be added to an inheritance hierarchy without modifying application programs that already
utilize various interfaces of that inheritance hierarchy. However, for beginners, it is difficult to grasp and implement
the concept of polymorphism, dynamic binding, and abstract classes.

4. Homework before Lab

5.1 Problem Solution Modeling

Draw UML class diagrams of the following task. You are required to bring this design with you and submit to
your lab instructor.

5.1.1 Problem description: CLO(2,3,4)

Try to Design a class named Record that includes

 A data member named rollNo for student roll number
 Two data fields i.e. course1Name and course2Name of type string
 A parameterized constructor to initialize rollNo, course1Name, and course2Name data fields
 Three getter functions to get the value of rollNo, course1Name, and course2Name, respectively

Derive a class named CourseRecord inherited from Record class and contains
 Two additional data members i.e. marksCourse1 and marksCourse2
 A parameterized constructor to initialize its own data fields along with the inherited data fields
 Two getter functions that return the value of marksCourse1 and marksCourse2, respectively

Derive a class named CourseResult inherited from class CourseRecord and has
 A data field named totalMarks
 A function named marksObtained that returns totalMarks (i.e. marksCourse1 + marksCourse2) of a
student
 A member function named display to show rollNo, course1Name, course2Name, marksCourse1,
marksCourse2, and totalMarks

Draw UML diagram for each class and show inheritance relationship between these classes.

Page 110
 Lab 12 - Polymorphism in Object Oriented Programming

5.2 Practices from home

5.2.1 Task-1 CLO(2,4)

Try to Consider four classes i.e. Person, Staff, Professor, and Researcher with the following inheritance

hierarchy: Class Researcher is derived from both Staff and Professor classes that are ultimately derived from

class Person. Class Person has two attributes i.e. name and age and one member function display() to show its

attribute values. Class Staff has two attributes i.e. staffID and department.

Class Professor has two attributes i.e. courseID and courseName for the course he/she is teaching.

Class Researcher has additional attributes named labID and experimentNo for laboratory and experiment under his
supervision.

Draw UML diagram for each class and show inheritance relationship between these classes.

5.2.2 Task-2 CLO(2,4)

Illustrate the implementation of classes that have been specified in Task-1 using C++ compiler in a way that avoid
diamond problem of multiple inheritance.

5. Procedure & Tools

6.1 Tools

Visual Studio 2008.

6.2 Setting-up Visual Studio 2008 [Expected time = 5 mins]

Setup visual studio and make a project named “Polymorphism”

6.3 Walkthrough Task [Expected time = 30 mins]

In this task, you are required to write a C++ code which would elaborate polymorphism concept. The following lines
show the output of a basic polymorphism concept:

6.3.1 Writing Code

In the source file, which is created in the project “Polymorphism” write following C++ code:

Page 111
 Lab 12 - Polymorphism in Object Oriented Programming

Figure 1: Polymorphism

Figure 2: Main( ) function for Figure 1

Page 112
 Lab 12 - Polymorphism in Object Oriented Programming

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below:

Figure 3: Final Output

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab12

7.1 Practice Task 1 CLO(2,4)

Practice an abstract class Computer having
 Two fields (i.e. companyName, price) and
 A single function named show()

A class named Desktop inherits Computer class and adds fields representing
 color, monitor size, and processor type and
 Override function named show() to display values of its all attributes

A class named Laptop inherits Computer class and adds fields representing
 color, size, weight, and processor type and
 Override function named show() to display values of its all attributes

Write a main() function that instantiates objects of derived classes to access respective show() function using
dynamic binding.

7.2 Practice Task 2 CLO(2,4)

Practice to Create a class named Person, which contains
 A pure virtual function named print()
 Two data fields i.e. personName and age

A class named Patient inherits Person class, which contains

 Two data fields i.e. diseaseType and recommendedMedicine
 Overridden function print() to display all details relevant to a patient

A class named MedicarePatient inherited from class Patient, which holds

 A data field representing the name of the hospital
 A data filed representing the name of the ward
 A data field representing room number
 Overridden function print() to display all details relevant to a patient

Page 113
In the main function, create instances of derived classes to access respective print() function using dynamic
binding.

7.3 Outcomes
After completing this lab, student will be able to implement the concepts of virtual functions, dynamic binding, pure
virtual function, and abstract classes.

7.4 Testing
 For Practice Task 1, it is required to check the assignment of derived class instances to base class
pointer. Moreover, (while considering the dynamic binding) test the invocation of respective show()
function.

 For Practice Task 2, it is required to check the assignment of derived class instances to base class
pointer. Moreover, (while considering the dynamic binding) test the invocation of respective print()
function.

Table 3: Practice Tasks Confirmation

Practice Tasks Confirmation Comments

T1
T2
 Lab Manual for Object-Oriented Programming
(LAB-14)
Function and Class Templates

Page 123

Lab 14: Function and Class Templates CLO(1,3,2,4)

1. Introduction
In general, a template is used to represent a pattern. In programming, occasionally, a group of functions and/or
classes differ from each other simply in terms of parameter types or types of data members, respectively. In these
situations, templates are used to avoid redundant coding and can be practiced in two ways i.e. with functions and
with classes. In C++, templates facilitate the programmer to define a generic function or class that is able to perform
the same task with variables of different data types (including objects of different classes). The syntax of writing a
generic function in C++ is given as under:

template<class T> or template<typename T>

T functionName(T value)
{
return value * value;

}
You can call this function in different ways i.e. with parameters of types int, long, float, double as:

int var1= 10; long var2 = 125321; double var3 = 10.0;

functionName(var1);
functionName(var2);
functionName(var3);

Similarly, the syntax of writing a generic class is given as under:

template<class T> or template<typename T>

class TemplateExample
{
private:
T var;
public:
TemplateExample(T var)
{
this.var = var;
}
};
In order to create two objects containing data members of different data type, you have to write:

TemplateExample<int> TE1;
TemplateExample<double> TE2;

It is clear from above examples that prior to coding a function template or class template you have to provide
template definition statement starting with the keyword template. This template reserved word in C++ informs the
compiler that programmer is going to define a function or class template. Further, the variable with reserved word
class or typename within angle brackets (< >) is known as the template argument. This template argument is
replaced with specific data type with each function call statement.

2. Objective of the Experiment

After completing this lab the student should be able to:
 declare the template function with type parameters.
 use multiple parameters in function templates.
 understand the benefits of templates.
 create function templates with multiple data types.
 develop generic classes using class templates.
 learn the use of standard template libraries (STL).

3. Concept Map
To deal with overloaded functions and various classes (that differ from each other in terms of the types of data
fields), C++ assists programmer to define generic functions and classes while using the concept of templates. It is
important to mention here that templates do not save the amount of memory to be used by different functions or
class objects. However, template approach (that is a very special kind of code reusability) saves the time of writing
multiple functions and classes with same logical task. In this way, later on, modification(s) can be performed easily
while changing code at one place instead of multiple places.

The statement of template definition in C++ code by itself is not able to generate any code. Code generation for a
specific template function takes place at the time of function invocation. This is due to the fact that upon function
invocation compiler comes to know about the type to substitute template parameter. This is known as instantiating
the function template.

Concerning class templates in C++, it is important to point out here that C++ provides a powerful and versatile
collection of functions and classes for common data structures i.e. vector, stack, queue etc. This collection of classes
is known as Standard Template Library (STL). Functions and classes in STL provides well-organized and extensible
framework to develop certain applications.
4. Homework before Lab

5.1 Practices from Home

5.1.1 Task-1 CLO(2,4)

A function named exchange that takes two values as its parameters and is responsible to swap these values. It is
required from you to implement exchange function as a template. In the main function, test the working of
exchange function by invoking it with parameters of int, long, double, and char data type.

5.1.2 Task-2 CLO(2,4)

Try to Consider a class named Calculator that contains

 Two data members i.e. num1 and num2

 Lab 14 - Function and Class Templates

 A parameterized constructor to assign values to both data members

 Four functions i.e. addition(), subtraction(), multiplication(), and division() to perform their respective
functions on data members and return result in double

Make the class Calculator into a template and in this way, a user would be able to instantiate it using different data
types for the data members. In the main function, instantiate two objects of Calculator class with data members of
type integer and float, respectively and invoke all functions of class Calculator.

5. Procedure & Tools

6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008

Setup visual studio and make a project named “TemplateExample”

6.3 Walkthrough Task CLO(2,4)

In this task, you are required to Practice to write a C++ code which would elaborate templates concept. The
following lines show the output of a basic template example using class templates. The program finds the minimum
number from two numbers using templates concept:

6.3.1 Writing Code

In the source file, which is created in the project “TemplateExample” write following C++ code:

Figure 1: Find minimum number using Class Template

Page 118
 Lab 14 - Function and Class Templates

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below:

Figure 2: Final Output

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab14

7.1 Practice Task 1 CLO(2,4)

Try to Write a generic function minimum() that returns the value of the minimum element in an array. The function
arguments should be the address of the array and its size. Make this function into a template so it will work with an
array of any data type i.e. int, long, double.

7.2 Practice Task 2 CLO(2,4)

Try to Write two generic functions (overloaded) named area(). Create function template for the first area() function
that it is able to receive the radius of a circle as its parameter and returns area of circle as of same data type.
Similarly, create function template for the second area() function that it is able to receive two parameters as length
and width of a rectangle and returns the area of rectangle as of same data type.

7.3 Practice Task 3 CLO(2,4)

Try to Create a class template for a class named GeneralStack that holds

 A single data member as an array named stack of size 50 to store certain elements
 A constructor to initialize stack with value 0 or 0.0 at all its indexes
 Three member functions i.e. push(type) to add elements in the Stack, pop() to remove elements from the
stack, and currentStatus() to check whether the array is filled or not. (A filled array is an array that has
non-zero value at all of its indexes).

In the main() function, create three objects with different data types of class GeneralStack and test the functionality
of member functions for various values of data members for these objects.

Page 119
 Lab 14 - Function and Class Templates

7.4 Outcomes
After completing this lab, student will be able to understand the use and working of function and class templates in
C++.

7.5 Testing
 Test cases for Practice Lab 1

Sample Inputs Sample Outputs

int arr = {101, 29, 40, 90,45} 29
minimun(arr, 5)
double arr = {10.11, 2.99, 1.40, 90.99} 1.40
minimun(arr, 4)

 Test cases for Practice Lab 2

Sample Inputs Sample Outputs

area(5.0) 78.5
area(5) 78
area(20.0,10.0) 200.0
area(20,10) 200

 For Practice Lab 3, lab instructor should check the creation of three instances of GeneralStack class while
each having an array of different data type. Moreover, check the required functionality of member
functions with these instances.

Table 3: Practice Tasks Confirmation

Practice Tasks Confirmation Comments

T1
T2
T3

Page 130
Lab 14 - Function and Class Templates

Page 130
Lab Manual for Object-Oriented Programming
(LAB-15)
Exception Handling

Page 131
 Lab 15 - Exception Handling

1. Introduction
Lab 15: Exception Handling CLO(1,2,4)

Page 132
 Lab 15 - Exception Handling

Exceptions are runtime errors in a programming language that change the regular flow of program execution. A
typical example of exception is division by zero during a program execution; however, there are a number of
situations that can cause exceptions i.e. array index out-of-bounds, file opening fail, and running out of memory.
The response to the occurrence of an exception (or runtime error) is known as exception handling. Different
languages provide specific functions called exception handlers to deal with exceptions. These specific functions are
a kind of built-in code to handle the known exceptions.

C++ provides try-catch block to handle exceptions. You have to place the exception suspected code in the try block.
In the absence of exception occurrence, programs continue to follow the normal flow of execution. However, upon
the generation of exceptions within try block, control is transferred to the exception handling block i.e. known as
catch block. It is must to place the catch block immediately after the try block. The syntax of the exception handling
in C++ is given as under:

try
{
// code statements here
}
catch (type e)
{
//code to handle the exception(s)
}

Usually, statements in the try block run without throwing any kind of exception, however, infrequently various types
of exceptions can occur. A single catch block is able to handle only a specific type of exception. Therefore, in order
to handle any kind of expected runtime error, C++ permits to use multiple catch blocks with a single try block. The
syntax to use multiple catch blocks with a single try block is given as under:

try {
// code statements here
}
catch (int param) { // code to handle int type of exception }
catch (char param) { // code to handle char type of exception }
catch (...) { // code to handle any kind of exception }

2. Objective of the Experiment

After completing this lab, the student should be able to:
 understand the limitations of conventional error-handling techniques.
 understand various types of exceptions and exception handling mechanism.
 use of try-catch blocks to handle exceptions.
 use of multiple catch blocks with a single try block.
 understand the benefits of exception handling.
 know how to deal with exceptions using C++ standard exception classes.

3. Concept Map
To deal with anomalous or exceptional situation in the running code, programming languages facilitate programmers
with the provisioning of exception handling mechanism. At present, C++ provides try-catch block to handle
exception. However, to handle exceptions, older C++ programs use the logic with decision statements (i.e. if-else or
switch statements). As an example, pseudocode to exception handling in older C++ is given as under:

Execute statement(s)
If error occurs, do some error processing
Else execute next statements
If error occurs, do some error processing
Else execute next statements

Page 133
 Lab 15 - Exception Handling

...
Due to a number of reasons, this type of approach has various shortcomings as explained under:
 error detection/handling logic is intermingled with the program logic
 it is difficult to read the program
 due to constant decision testing for rare exceptional circumstances, program execution becomes
less efficient

Although, exception handling mechanism using try-catch block is an advantage over if-else construct but it is not a
recommended practice to use try-catch block for simple errors that are already expected within a program. These
types of errors should be handled locally. Hence, you should not overuse catch block because usually exceptions are
permitted to propagate up the call stack. It is also important to consider the order of exceptions that are defined in
catch blocks. It is essential to use a catch block with a derived class type before the catch block with base class type.

4. Homework before Lab

5.1 Problem Solution Modeling

Draw class diagrams of the following task. You are required to bring this design with you and submit to your
lab instructor.

5.1.1 Problem description:

Design a class named Registration that holds

 the registration number (of type string) and
 the registration fee (of type float) of a particular student
 a two argument constructor to initialize data fields

Create another class named RegException that should hold a member function named exceptionCause with an error
message. In Registration class, it is required to throw an exception of type RegException if user enters invalid
registration number (string with more than five characters) or registration fee (if given in characters). Upon
catching exception, invoke function of RegException class to display the error message.

Draw class diagrams of both classes and show interaction between these classes.

Page 134
 Lab 15 - Exception Handling

5.2 Practices from Home

5.2.1 Task-1 CLO(2,4)

Try to Create a class named Fan. It contains two data fields i.e.

 companyName of string type and

 price of float data type

A member function named getValues is required to get values for both data fields. If the entered price would be less
than Rs. 2000 or greater than Rs. 8000, then entered price will be thrown as an exception. Exception must be caught
within the getValues function to show some appropriate message. In the main() function, create three objects of
Fan class and test the code for entries of all three objects.

5.2.2 Task-2 CLO(2,4)

Try to Create a class RealEstate that contains

 A char type data member named hLocation to store value i.e. „S‟, „N‟, „W‟, or „E‟
 A float type data member named housePrice that stores the price of the house
 An int type data member named roomCount representing the number of total rooms within a specific house
 A parameterized constructor that takes values for all data members
 Three functions named setHLocation, setHousePrice, and setRoomCount to modify the values for house
location, house price, and number of rooms
 A show() function to display the current values of the data members associated with a particular object

The main() function must catch all exceptions (i.e. invalid house location if it is any character other than S, N, W, or
E, invalid house price if it is less than Rs. 100,000, and invalid roomCount for any value less than equal to zero)
generated from setter functions (i.e. setHouseNo, setHousePrice, setRoomCount).

5. Procedure & Tools

Tools
Visual Studio 2008.

6.1 Setting-up Visual Studio 2008 CLO(2,4)

Setup visual studio and make a project named “ExceptionHandling”

6.2 Walkthrough Task CLO(2,4)

In this task, you are required to practice to write a C++ code which would elaborate exception handling concept.
The following lines show the output of a basic exception handling concept: The example concentrates on exception
when a division by zero occurs and the program throws exception.

6.3.1 Writing Code

In the source file, which is created in the project “ExceptionHandling” write following C++ code:

Page 135
 Lab 15 - Exception Handling

Figure 1: Exception Code

Figure 2: Main function for Figure 1

6.3.2 Compilation
After writing the code, compile your code according to the guidelines mentioned. Remove any errors and warnings
that are present in your code.

6.3.3 Executing the Program

A sample output after running the program is shown below:

Page 136
 Lab 15 - Exception Handling

Figure 3: Final Output

6. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to finish the
tasks in the required time. When you finish them, put these tasks in the following folder:
\\dataserver\assignments$\OOP\Lab15

7.1 Practice Task 1 CLO(2,4)

In class MyWork, define an inner class named MyException having a function why() with display statement
“Because of Exception”. Throw an exception of inner class type in a function named myFunction() in the outer
MyWork class. Test this type of exception handling in the main() function.

7.2 Practice Task 2 CLO(2,4)

Define a custom exception class named SecureArray having array of int type as single data member and let the
insert and delete functions of this class to throw OutBoundException (your own defined exception class) if the
array is already full or already empty, respectively. In the main() function, write a try-catch block to handle this
type of exception.

7.3 Practice Task 3 CLO(2,4)

Try to Create a class named LCD with
 data members for modelNo (of string type), screenSize (of int type), and itemPrice (of float type)
 a no-argument constructor that initializes all three data members with values “empty”, 0, and 0.0,
respectively
 an inner class named AnExcep containing a member function what() with an appropriate message
providing information about exception type
 three member functions namely setModelNo, setScreenSize, and setItemPrice to modify the values for data
members
 three member functions namely getModelNo, getScreenSize, and getItemPrice that returns modelNo,
screenSize, and itemPrice, respectively.

In the main() function, create three objects of type LCD and test the class implementation for various values of data
members for these objects. Exceptions of inner class types would be thrown and caught in main() while following
the criteria that if model number is not started with character „V‟, if screen size entered is not between 30 and 55, or if
the price entered is a negative number or a value greater than Rs. 90,000.

7.4 Outcomes
After completing this lab, student will be able to throw and handle exceptions (using try-catch block) in a C++
program.

Page 137
7.5 Testing
Lab instructor must consider the following:

 For Practice Task 1, test the exception generation of inner class type and its handling in the main()
function.

 For Practice Task 2, test that exceptions generated/thrown in insert and delete functions must be handled
within the main().

 For Practice Task 3, test the working of exception handling mechanism with single try block having
multiple associated catch blocks to handle a relevant thrown exception message.

Table 3: Practice Tasks Confirmation

Practice Tasks Confirmation Comments

T1
T2
T3
Lab 15: OPEN ENDED LAB CLO(2,3,4)