Sie sind auf Seite 1von 146

Mohammad Ali Jinnah University

Islamabad

LAB MANUAL
OBJECT ORIENTED PROGRAMMING
First Edition

DEPARTMENT OF COMPUTER SCIENCE

ii

Lab Course Development Team

Supervision and Coordination


Dr. Muhammad Abdul Qadir
Professor
Dean Faculty of Computing

Lab Designers
Dr. Muhammad Azhar Iqbal
Assistant Professor
Department of Computer Science

Mr. Hasan Tahir Butt


Lecturer
Department of Computer Science

Mr. Faisal Shahzad


Junior Lecturer
Department of Computer Science

iii

Table of Contents
Preface

iv

Lab 1 Functions and Pointers Recap

Lab 2 Introduction to Classes and Objects

13

Lab 3 Access Specifiers, Constructors and Destructors

22

Lab 4 Constructor Overloading and Copy Constructors

32

Lab 5 Shallow Copy/ Deep Copy and Working with arrays

41

Lab 6 Friend Functions and Friend Classes

52

Lab 7 Introduction to Operator Overloading

61

Lab 8 Inheritance in Object Oriented Programming

72

Lab 9 The Protected Access Specifier and Types of Inheritance

80

Lab 10 Multi-level and Multiple Inheritance

89

Lab 11 Function Overloading and Function Overriding

98

Lab 12 Polymorphism in Object Oriented Programming

106

Lab 13 Relationship in Object Oriented Programming

115

Lab 14 Function and Class Templates

124

Lab 15 Exception Handling

131

Annexure A Course Outline

139

Annexure B Good Programming Practices

140

iv

Preface

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 learnings 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 - Recap

Department of Computer Science,


MAJU

Page 1

Lab 1 - Functions and Pointers - Recap

Table of Contents
1.

Introduction

2.

Activity Time boxing

3.

Objective of the Experiment

4.

Concept Map

4.1
4.2
4.3
4.4
4.5
4.6

4
4
4
5
6
6

5.

6.

7.

Reusability/ Modularity of Code


Function Prototype and Function Definition
Function Arguments and Parameters
Returning a Value from a Function
Pass by Value and Pass by Reference
Pointers

Home Work Before Lab

5.1
5.2

7
8

Problem Solution Modelling


Practices from home

Procedure & Tools

6.1
6.2
6.3

8
8
8

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

10

7.1
7.2
7.3
7.4
7.5
7.6

10
10
10
10
10
11

Practice Task 1
Practice Task 2
Practice Task 3
Practice Task 4
Outcomes
Testing

8.

Evaluation Task (Unseen)

11

9.

Evaluation criteria

11

10.

Further Reading

12

10.1
10.2

12
12

Books
Slides

Department of Computer Science,


MAJU

Page 2

Lab 1 - Functions and Pointers - Recap

Lab 01: Functions and Pointers - Recap


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.

Relevant Lecture Material

Lectures: 1, 2
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Chapters: 5, 10

2. Activity Time boxing


Task No.
5.1
6.2
6.3
7
8

Activity Name
Evaluation of Design
Setting-up Visual Studio
Walkthrough Task
Practice tasks
Evaluation Task

Table 1: Activity Time Boxing


Activity time
15 mins
5 mins
25 mins
15 + 15 + 20 + 35 (mins)
40 min for two task
Total Time

Total Time
15 mins
5 mins
25 mins
85 mins
50 mins
170 Minutes

3. 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.

Department of Computer Science,


MAJU

Page 3

Lab 1 - Functions and Pointers - Recap

4. 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);
{
Department of Computer Science,
MAJU

Page 4

Lab 1 - Functions and Pointers - Recap


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.
Department of Computer Science,
MAJU

Page 5

Lab 1 - Functions and Pointers - Recap


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.

Department of Computer Science,


MAJU

Page 6

Lab 1 - Functions and Pointers - Recap

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.

5. 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
Department of Computer Science,
MAJU

Page 7

Lab 1 - Functions and Pointers - Recap

lab instructor.

5.1.1 Problem description


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
In The field of Physics you are aware of the concept of force and acceleration. Your task is 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
Write a program that creates a function to find the area of a cylinder if the radius and height of the cylinder is
provided. The function should return the value of area. The area of a cylinder is 2 . Consider the figure below for
further clarification.
r

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup Visual Studio and make a project named FindAverage.

[Expected time = 5 mins]

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.

Department of Computer Science,


MAJU

Page 8

Lab 1 - Functions and Pointers - Recap

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.

Department of Computer Science,


MAJU

Page 9

Lab 1 - Functions and Pointers - Recap

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.


7. 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


[Expected time = 15 mins]
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
[Expected time = 15 mins]
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
[Expected time = 20 mins]
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
[Expected time = 35 mins]
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.
Department of Computer Science,
Page 10
MAJU

Lab 1 - Functions and Pointers - Recap

7.6 Testing
Test Cases for Practice Task-1
Sample Inputs
Number: 3

Sample Outputs
5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25,

Test Cases for Practice Task-2


Sample Inputs
Base: 4
Exponent: 11

Sample Outputs
Result = 4194304
Check that the function works with pass by reference

Test Cases for Practice Task-3


Sample Inputs
Array having all entries 1

Sample Outputs
Sum = 20
Check that pointers have been used to iterate the array

Test Cases for Practice Task-4


Sample Inputs
Number: -5

Sample Outputs
Invalid Input

Number: 5.5

Invalid Input

Number: 5

120

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


Practice Tasks
T1
T2
T3
T4

Confirmation

Comments

8. Evaluation Task (Unseen)


[Expected time = 40 mins]
The lab instructor will assign you unseen tasks depending upon the progress of the students.
9. Evaluation criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned
marks which will be evaluated by the instructor in the lab depending on the accomplishment of the assigned tasks.

Department of Computer Science,


MAJU

Page 11

Lab 1 - Functions and Pointers - Recap

Table 3: Evaluation of the Lab


Sr.
No.
1
2
3
4
5
6
7
8

Task No

Description

Marks

4.1
6
7.1
7.2
7.3
7.4
8

Problem Modelling
Procedures and Tools
Practice task 1 with Testing
Practice task 2 with Testing
Practice task 3 with Testing
Practice task 4 with Testing
Evaluation Tasks (Unseen)
Good Programming
Practices
Total Marks

20
5
10
10
10
15
20
10
100

10. Further Readings


10.1 Books

Object-Oriented Programming Using C++, Fourth edition, Joyce Farrell

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 12

Lab Manual for Object Oriented Programming


(LAB-02)
Introduction to Classes and Objects

Department of Computer Science,


MAJU

Page 13

Lab 2 - Introduction to Classes and Objects

Table of Contents
1.

Introduction

15

2.

Activity Time boxing

15

3.

Objective of the Experiment

15

4.

Concept Map

16

4.1
4.2
4.3
4.4
4.5
4.6

16
16
16
17
17
17

5.

6.

7.

Object
Data Members
Member Functions
Constant Member Functions
Class
Encapsulation

Home Work Before Lab

18

5.1
5.2

18
18

Problem Solution Modelling


Practices from home

Procedure & Tools

18

6.1
6.2
6.3

18
18
18

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

20

7.1
7.2
7.3
7.4
7.5

20
20
20
20
20

Practice Task 1
Practice Task 2
Practice Task 3
Outcomes
Testing

8.

Evaluation Task (Unseen)

21

9.

Evaluation Criteria

21

10.

Further Reading

21

10.1
10.2

21
21

Books
Slides

Department of Computer Science,


MAJU

Page 14

Lab 2 - Introduction to Classes and Objects

Lab 02: Introduction to Classes and Objects


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.

Relevant Lecture Material

Lectures: 3, 4
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore
o Pages: 195-201

2. Activity Time boxing


Task No.
5.1
6.2
6.3
7
8

Table 1: Activity Time Boxing


Activity Name
Activity time
Evaluation of Design
15 mins
Setting-up Visual Studio
5 mins
Walkthrough Task
30 mins
Practice tasks
25 + 25 + 30 (mins)
Evaluation Task
45 min
Total Time

Total Time
15 mins
5 mins
25 mins
80 mins
45 mins
170 Minutes

3. 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.

Department of Computer Science,


MAJU

Page 15

Lab 2 - Introduction to Classes and Objects

4. 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( )
{
}

Department of Computer Science,


MAJU

Page 16

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;
class myclass
{
int datamember;

};

void main( )
{

void memberfun (int)


{
...
}
//Semicolon is necessary

void main( )
{
}

using namespace std;


class myclass;

}
class myclass
{
int datamember;
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.

Department of Computer Science,


MAJU

Page 17

Lab 2 - Introduction to Classes and Objects

5. 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.

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup Visual Studio and make a project named cylinder.

[Expected time = 5 mins]

6.3 Walkthrough Task


[Expected time = 25 mins]
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.

Department of Computer Science,


MAJU

Page 18

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.


Department of Computer Science,
MAJU

Page 19

Lab 2 - Introduction to Classes and Objects

7. 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
[Expected time = 25 mins]
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
[Expected time = 25 mins]
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
[Expected time = 30 mins]
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
Set the following values
Brand = DELL
Model = 1565D
Serial = 123456
Colour = Silver
Price = 64500.5
Processor = 2.8
RAM = 2
Screen = 15.6

Sample Outputs
Brand = DELL
Model = 1565D
Serial = 123456
Colour = Silver
Price = 64500.5
Processor = 2.8
RAM = 3
Screen = 15.6

Then Modify the RAM to 3


Test Cases for Practice Task-2
Sample Inputs
Length: 4
width: 10

Sample Outputs
Length = 5
Width = 11
Area = 55
Department of Computer Science,
MAJU

Page 20

Lab 2 - Introduction to Classes and Objects

call the increment function

Check the use of constant function for display

Test Cases for Practice Task-3


Sample Inputs
Number: -5

Sample Outputs
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
T1
T2
T3

Confirmation

Comments

8. Evaluation Task (Unseen)


[Expected time = 45 Minutes]
The lab instructor will assign you an unseen task depending upon the progress of the students.
9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned
marks which will be evaluated by the instructor in the lab depending on the accomplishment of the assigned tasks.
Table 3: Evaluation of the Lab
Sr.
No.
1
2
3
4
5
6
7

Task No

Description

Marks

4.1
6
7.1
7.2
7.3
8

Problem Modelling
Procedures and Tools
Practice task 1 with Testing
Practice task 2 with Testing
Practice task 3 with Testing
Evaluation Tasks (Unseen)
Good Programming
Practices
Total Marks

20
5
10
10
10
15
10
80

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++, Fourth edition, Joyce Farrell

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 21

Lab Manual for Object Oriented Programming


(LAB-03)
Access Specifiers, Constructors and Destructors

Department of Computer Science,


MAJU

Page 22

Lab 3 - Access Specifiers, Constructors and Destructors

Table of Contents
1.

Introduction

24

2.

Activity Time boxing

24

3.

Objective of the Experiment

24

4.

Concept Map

25

4.1
4.2
4.3
5.

6.

7.

Access Specifiers Public and Private Access


Constructors
Destructors

25
25
26

Home Work Before Lab

27

5.1

27

Practices from home

Procedure & Tools

27

6.1
6.2
6.3

27
27
27

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

29

7.1
7.2
7.3

29
30
30

Practice Task 1
Outcomes
Testing

8.

Evaluation Task (Unseen)

30

9.

Evaluation Criteria

31

10.

Further Reading

31

10.1
10.2

31
31

Books
Slides

Department of Computer Science,


MAJU

Page 23

Lab 3 - Access Specifiers, Constructors and Destructors

Lab 03: Access Specifiers, Constructors and


Destructors
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.

Relevant Lecture Material

Lectures: 3, 4, 5, 6
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore
o Pages: 201-212

2. Activity Time boxing


Task No.
5.1
6.2
6.3
7
8

Activity Name
Evaluation of Design
Setting-up Visual Studio
Walkthrough Tasks
Practice tasks
Evaluation Task

Table 1: Activity Time Boxing


Activity time
20 mins
5 mins
40 mins
60 mins
55 mins
Total Time

Total Time
20 mins
5 mins
40 mins
60 mins
45 mins
170 Minutes

3. 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.

Department of Computer Science,


MAJU

Page 24

Lab 3 - Access Specifiers, Constructors and Destructors

4. 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

int myclass :: memberfun (int x)


because its prototype is public
{
datamember=x;
}
void main( )
{
myclass obj;
myclass::datamember=10;
obj.memberfun(10);
}

// This function is still public

//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.
Department of Computer Science,
MAJU

Page 25

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;
//Private data member
public:
myclass( );
//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;
//Private data member
public:
myclass( );
//Class constructor
{
cout<<Hello you have called the class constructor;
}
~myclass( );
//Class constructor
{
cout<<Hello you have called the class destructor;
}
};

Department of Computer Science,


MAJU

Page 26

Lab 3 - Access Specifiers, Constructors and Destructors

5. 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( );
}

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup Visual Studio and make a project named pizza.

[Expected time = 5 mins]

6.3 Walkthrough Task


[Expected time = 40 mins]
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.

Department of Computer Science,


MAJU

Page 27

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
Department of Computer Science,
MAJU

Page 28

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.


7. 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


[Expected time = 60 mins]
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
Department of Computer Science,
MAJU

Page 29

Lab 3 - Access Specifiers, Constructors and Destructors

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
Flavour = chocolate
Wafer required = yes
Number of scoops = 3

Sample Outputs
Your choice of ice cream is as follows
Flavour = chocolate
Number of scoops = 3
Wafer is required
Total price is 190
Thank you for visiting LeCream!

Flavour = Almond crunch


Wafer required = No
Number of scoops = 2

Your choice of ice cream is as follows


Flavour = Almond Crunch
Number of scoops = 2
Wafer is not required
Total price is 100
Thank you for visiting LeCream!

Flavour = Coffee
Wafer required = yes
Number of scoops = 3

Your choice of ice cream is as follows


Flavour = Coffee
Number of scoops = 3
Wafer is Required
Total price is 160
Thank you for visiting LeCream!

Flavour = Mango
Wafer required = No
Number of scoops = 4

Invalid Input
Thank you for visiting LeCream!

Table 2: Confirmation of practice tasks T1


Practice Tasks
T1

Confirmation

Comments

8. Evaluation Task (Unseen)


[Expected time = 45 Mins]
The lab instructor will assign you an unseen task depending upon the progress of the students.

Department of Computer Science,


MAJU

Page 30

Lab 3 - Access Specifiers, Constructors and Destructors

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned
marks which will be evaluated by the instructor in the lab depending on the accomplishment of the assigned tasks.
Table 3: Evaluation of the Lab
Sr.
No.
1
2
3
4
5

Task No

Description

Marks

4.1
6
7.1
8

Problem Modelling
Procedures and Tools
Practice task 1 with Testing
Evaluation Tasks (Unseen)
Good Programming
Practices
Total Marks

10
5
50
15
10
90

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++, Fourth edition, Joyce Farrell

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 31

Lab Manual for Object Oriented Programming


(LAB-04)
Constructor Overloading and Copy Constructors

Department of Computer Science,


MAJU

Page 32

Lab 4 - Constructor Overloading and Copy Constructors

Table of Contents
1.

Introduction

34

2.

Activity Time boxing

34

3.

Objective of the Experiment

34

4.

Concept Map

34

4.1
4.2
4.3

34
35
35

5.

6.

7.

Function Overloading
Constructor Overloading Parameterized and Nullary Constructors
Copy Constructors

Home Work Before Lab

36

5.1

36

Practices from home

Procedure & Tools

36

6.1
6.2
6.3

36
36
36

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

38

7.1
7.2
7.3
7.4

38
39
39
39

Practice Task 1
Practice Task 2
Outcomes
Testing

8.

Evaluation Task (Unseen)

39

9.

Evaluation Criteria

40

10.

Further Reading

40

10.1
10.2

40
40

Books
Slides

Department of Computer Science,


MAJU

Page 33

Lab 4 - Constructor Overloading and Copy Constructors

Lab 04: Constructor Overloading and Copy


Constructors
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.

Relevant Lecture Material

Lectures: 6, 7, 8
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore
o Pages: 212-213, 216-217

2. Activity Time boxing


Task No.
5.1
6.2
6.3
7
8

Table 1: Activity Time Boxing


Activity time
25 mins
5 mins
35 mins
40 + 10 (mins)
55 mins
Total Time

Activity Name
Evaluation of Design
Setting-up Visual Studio
Walkthrough Tasks
Practice tasks
Evaluation Task

Total Time
25 mins
5 mins
35 mins
50 mins
55 mins
170 Minutes

3. 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.

4. 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
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);
Department of Computer Science,
MAJU

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)


parameterized ->1
{
...
}

//Overloaded Constructor:

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, 3.3, 2); //Creation through Second parameterized constru
return 0;
}
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
Department of Computer Science,
MAJU

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.

5. 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.

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup Visual Studio and make a project named student.

[Expected time = 5 mins]

6.3 Walkthrough Task


[Expected time = 35 mins]
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:

Department of Computer Science,


MAJU

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

Department of Computer Science,


MAJU

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.


7. 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


[Expected time = 40 mins]
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.
Department of Computer Science,
Page 38
MAJU

Lab 4 - Constructor Overloading and Copy Constructors

7.2 Practice Task 2


[Expected time = 10 mins]
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
Using Nullary constructor

Sample Outputs
Your LCD purchase details are:
Length = 48
Width=30

Length = 48
Width = 30

Price=93600
Using parameterized constructor (integer)
Length = 48
Width = 30

Your LCD purchase details are:


Length = 48
Width=30
Price=93600

Using parameterized constructor (float)

Your LCD purchase details are:


Length = 48
Width=30

Length = 40.5
Width = 30.5

Price=80291.25

Test Cases for Practice Task-2


Sample Inputs
Initialize only one of the objects and use it for
copying values into another object by using the
copy constructor

Sample Outputs
Call the display function using the new object;
The new object will contain the values of the previous object.

Table 2: Confirmation of practice tasks T1, T2


Practice Tasks
T1
T2

Confirmation

Comments

8. Evaluation Task (Unseen)


[Expected time = 55 Mins]
The lab instructor will assign you an unseen task depending upon the progress of the students.

Department of Computer Science,


MAJU

Page 39

Lab 4 - Constructor Overloading and Copy Constructors

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned
marks which will be evaluated by the instructor in the lab depending on the accomplishment of the assigned tasks.
Table 3: Evaluation of the Lab
Sr.
No.
1
2
3
4
5
6

Task No

Description

Marks

4.1
6
7.1
7.2
8

Problem Modelling
Procedures and Tools
Practice task 1 with Testing
Practice task 2 with Testing
Evaluation Tasks (Unseen)
Good Programming
Practices
Total Marks

10
5
30
20
25
10
100

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++, Fourth edition, Joyce Farrell

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 40

Lab Manual for Object Oriented Programming


(LAB-05)
Shallow Copy / Deep Copy
Working with Arrays

Department of Computer Science,


MAJU

Page 41

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

Table of Contents
1.

Introduction

43

2.

Activity Time boxing

43

3.

Objective of the Experiment

43

4.

Concept Map

43

4.1
4.2
4.3
4.4

43
44
45
46

5.

6.

7.

Creating a customized copy constructor


Shallow Copy Constructor
Deep Copy Constructor
Working with Arrays

Home Work Before Lab

47

5.1

47

Practices from Home

Procedure & Tools

48

6.1
6.2
6.3

48
48
48

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

49

7.1
7.2
7.3
7.4

49
49
50
50

Practice Task 1
Practice Task 2
Outcomes
Testing

8.

Evaluation Task (Unseen)

50

9.

Evaluation Criteria

50

10.

Further Reading

51

10.1
10.2

51
51

Books
Slides

Department of Computer Science,


MAJU

Page 42

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

Lab 05: Deep Copy / Shallow Copy and Arrays in


Classes
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.

Relevant Lecture Material

Lectures: 8, 9, 10

2. Activity Time boxing


Task No.
5.1
6.2
6.3
7
8

Activity Name
Evaluation of Design
Setting-up Visual Studio
Walkthrough Tasks
Practice tasks
Evaluation Task

Table 1: Activity Time Boxing


Activity time
25 mins
5 mins
30 mins
50 + 15 (mins)
45 mins
Total Time

Total Time
25 mins
5 mins
30 mins
65 mins
45 mins
170 Minutes

3. 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.

4. 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.
Department of Computer Science,
MAJU

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
called MyClass

MyClass (const MyClass& other );

prototype

//const copy constructor


class called Myclass

for

class

prototype

for

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)
{
a=parame.a;
b=parame.b;
}
void showall( )
{
cout<<"\na="<<a;
cout<<"\nb="<<b;
}
example( )
{
a=10;
b=20;
}
};
int main()
{
example obj1;
example obj2(obj1);
obj1.showall();
obj2.showall();
return 0;
}

//shallow copy constructor

//Simple constructor

Department of Computer Science,


MAJU

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( );
example(char *s);
example(const example &st)
{
len = st.len;
str = new char [len + 1];
strcpy(str, st.str);
}
// other stuff
};

// one normal constructor


// another normal constructor
//Deep copy constructor

Department of Computer Science,


MAJU

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];
//array as a data member
public:
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:
example()
{
a=new float[10];

//Dynamic array as a data member


// normal constructor
//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
Department of Computer Science,
MAJU

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:
example(int size)
{
a=new float[size];
to the constructor
for(int i=0; i<=9;i++)
{
a[i]=0;
}

//Dynamic array as a data member

//The size is passed from the main

// 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;
}

5. 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
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.
Department of Computer Science,
MAJU

Page 47

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

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup Visual Studio and make a project named english.

[Expected time = 5 mins]

6.3 Walkthrough Task


[Expected time = 30 mins]
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 demonstrate
Figure 1: The english class demonstrating the use of a constructor and a copy constructor.

Department of Computer Science,


MAJU

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


7. 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


[Expected time = 50 mins]
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 Diablos 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 Diablos being produced are colour, cubic capacity and number of seats.
Suppose you are working on a system specially designed for the Lamborghini Diablo. 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
[Expected time = 15 mins]
Your task is to create a class that contains an integer pointer data member. Create a single object named one in the
Department of Computer Science,
MAJU

Page 49

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


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
Colour = Hot Red
Owner = Ali Raza
Year of manufacture = 2013
Seats = 2
Cubic Capacity = 5700
Engine number = 123456
Frame number = 987654

Sample Outputs
After selective copying only the permanent attributes contain
values.
Colour = Hot Red
Owner =
Year of manufacture =
Seats = 2
Cubic Capacity = 5700
Engine number =
Frame number =

Test Cases for Practice Task-2


Sample Inputs
Initialize only object one and use it for
copying values into object two by using the
copy constructor.
Make a modification in object two.
Call the display function of object one.

Sample Outputs
Upon calling the display function of object one the modified
values will be displayed
Upon calling the display function of object two the same
modified values will be shown.

Table 2: Confirmation of practice tasks T1 and T2


Practice Tasks
T1
T2

Confirmation

Comments

8. Evaluation Task (Unseen)


[Expected time = 45 mins]
The lab instructor will assign you an unseen task depending upon the progress of the students.
9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned
marks which will be evaluated by the instructor in the lab depending on the accomplishment of the assigned tasks.

Department of Computer Science,


MAJU

Page 50

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

Table 3: Evaluation of the Lab


Sr.
No.
1
2
3
4
5
6

Task No

Description

Marks

4.1
6
7.1
7.2
8

Problem Modelling
Procedures and Tools
Practice task 1 with Testing
Practice task 2 with Testing
Evaluation Tasks (Unseen)
Good Programming
Practices
Total Marks

10
5
30
20
25
10
100

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++, Fourth edition, Joyce Farrell

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 51

Lab Manual for Object Oriented Programming


(LAB-06)
Friend Functions and Friend Classes

Department of Computer Science,


MAJU

Page 52

Lab 6 - Friend Functions and Friend Classes

Table of Contents
1.

Introduction

54

2.

Activity Time boxing

54

3.

Objective of the Experiment

54

4.

Concept Map

54

4.1
4.2

Friend Functions
Friend Classes

54
56

Home Work Before Lab

56

5.1

56

5.

6.

7.

Practices from Home

Procedure & Tools

57

6.1
6.2
6.3

57
57
57

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

58

7.1
7.2
7.3
7.4
7.5

58
59
59
59
59

Practice Task 1
Practice Task 2
Practice Task 3
Outcomes
Testing

8.

Evaluation Task (Unseen)

60

9.

Evaluation Criteria

60

10.

Further Reading

60

10.1
10.2

60
60

Books
Slides

Department of Computer Science,


MAJU

Page 53

Lab 6 - Friend Functions and Friend Classes

Lab 06: Friend Functions and Friend Classes


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.

Relevant Lecture Material

Lecture: 11 - 12
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore
o Pages: 468-475

2. Activity Time boxing


Task No.
5.1
6.2
6.3
7
8

Activity Name
Evaluation of Design
Setting-up Visual Studio
Walkthrough Tasks
Practice tasks
Evaluation Task

Table 1: Activity Time Boxing


Activity time
20 mins
5 mins
25 mins
25+25+30 (mins)
35 mins
Total Time

Total Time
25 mins
5 mins
25 mins
80 mins
35 mins
170 Minutes

3. 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.

4. 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.
Department of Computer Science,
MAJU

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;
//Forward Declaration
class first
{
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.

Department of Computer Science,


MAJU

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;
int member1;
int membern;
public:
first()
{
member1=10;
member2=20;
}
};
class second
{
private:
int mem1;
int mem2;
public:
void fun( first o1)
{
cout<<o1.member1<<o1.membern;
cout<<mem1<<mem2;
}
};
void main( )
{
first obj1;
second obj2;
obj2.fun( obj1);

//Declaration of friend class

//Friend function prototype

//cannot call using obj1! Obj1 does not contain a


function called fun

5. 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
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.

Department of Computer Science,


MAJU

Page 56

Lab 6 - Friend Functions and Friend Classes

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup Visual Studio and make a project named series.

[Expected time = 5 mins]

6.3 Walkthrough Task

[Expected time = 25 mins]

Find the sum of 1 + 2 + 3 + + arithmetic series. In an arithmetic series the difference between two
consecutive numbers is the same throughout the series. Your class is composed of four data members i.e. the first
entry of the series, last entry of the series, total number of entries for which sum is required and finally the sum up to

n terms which has the formula = 1 + . Use a friend function to compute the sum of the series.
2

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;
int nterm;
int entries;
int sumn;

//Friend class declaration


//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;
}

Department of Computer Science,


MAJU

Page 57

Lab 6 - Friend Functions and Friend Classes

int main()
{
series obj1(6,96,31);
sum obj2;
obj2.series_sum(obj1);
display(obj1);
system ("pause");
return 0;
}

//(first term, last term, total number of terms)

//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


7. 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


[Expected time = 25 mins]
nd
As you know in mathematics the quadratic equation is a very popular 2 degree equation. Although there are many
possible methods of solving the quadratic equation, a very popular method is through the use of quadratic formula.
The quadratic equation is 2 + + = 0 and its roots can be determined using the quadratic formula as follows:
2 4
where 0
2
Department of Computer Science,
Page 58
MAJU

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
[Expected time = 25 mins]
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
as follows:
A function to compute the square of sums i.e. + + 2 = 2 + 2 + 2 + 2 + 2 + 2
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
[Expected time = 30 mins]
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
a =1;
b =2;
c =-3

Test Cases for Practice Task-2


Sample Inputs
a=1
b=2
c=3

Sample Outputs
proot= 1
nroot = -3

Sample Outputs

++

Mean = 2

2
2

=36
= 16

Department of Computer Science,


MAJU

Page 59

Lab 6 - Friend Functions and Friend Classes

Test Cases for Practice Task-3


Sample Inputs
Create the following entries for 3x3 arrays
1 2 3
= 4 5 6
7 8 9
1
= 4
7

2
5
8

Sample Outputs
Results should be as follows.
2
+ = 8
14

3
6
9

4
10
16

6
12
18

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


Practice Tasks
T1
T2
T3

Confirmation

Comments

8. Evaluation Task (Unseen)


[Expected time = 35 mins]
The lab instructor will assign you an unseen task depending upon the progress of the students.
9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned
marks which will be evaluated by the instructor in the lab depending on the accomplishment of the assigned tasks.
Table 3: Evaluation of the Lab
Sr.
No.
1
2
3
4
5
6
7

Task No

Description

Marks

4.1
6
7.1
7.2
7.3
8

Problem Modelling
Procedures and Tools
Practice task 1 with Testing
Practice task 2 with Testing
Practice task 3 with Testing
Evaluation Tasks (Unseen)
Good Programming
Practices
Total Marks

10
5
15
20
25
20
5
100

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++, Fourth edition, Joyce Farrell

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 60

Lab Manual for Object Oriented Programming


(LAB-07)
Introduction to Operator Overloading

Department of Computer Science,


MAJU

Page 61

Lab 7 Introduction to Operator Overloading

Table of Contents
1.

Introduction

63

2.

Activity Time boxing

63

3.

Objective of the Experiment

63

4.

Concept Map

63

4.1
4.2
4.3
4.4
4.5
4.6

63
64
64
64
65
66

5.

6.

7.

Introduction to Operator Overloading


Which Operators Can Be Overloaded
Operator Overloading General Rules
Operator Overloading Syntax
Stream Insertion and Extraction Operators
The Assignment Operator and the Copy Constructor

Home Work Before Lab

66

5.1

66

Practices from Home

Procedure & Tools

66

6.1
6.2
6.3

66
66
66

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

69

7.1
7.2
7.3
7.4
7.5

69
69
69
70
70

Practice Task 1
Practice Task 2
Practice Task 3
Outcomes
Testing

8.

Evaluation Task (Unseen)

71

9.

Evaluation Criteria

71

10.

Further Reading

71

10.1
10.2

71
71

Books
Slides

Department of Computer Science,


MAJU

Page 62

Lab 7 Introduction to Operator Overloading

Lab 07: Introduction to Operator Overloading


1. Introduction
In object Oriented Programming perhaps the most exciting and interesting feature is the adaptation of operators
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.

Relevant Lecture Material

Lecture: 13
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore
o Pages: 291-308

2. Activity Time boxing


Task No.
5.1
6.2
6.3
7
8

Activity Name
Evaluation of Design
Setting-up Visual Studio
Walkthrough Tasks
Practice tasks
Evaluation Task

Table 1: Activity Time Boxing


Activity time
20 mins
5 mins
30 mins
25+25+20 (mins)
40 mins
Total Time

Total Time
25 mins
5 mins
30 mins
70 mins
40 mins
170 Minutes

3. 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.

4. 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.
Department of Computer Science,
MAJU

Page 63

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
{
. . . }
Department of Computer Science,
MAJU

Page 64

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;
}

Department of Computer Science,


MAJU

Page 65

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.

5. 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
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.

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup Visual Studio and make a project named tolltax.

[Expected time = 5 mins]

6.3 Walkthrough Task


[Expected time = 30 mins]
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.

Department of Computer Science,


MAJU

Page 66

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:

Department of Computer Science,


MAJU

Page 67

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.

Department of Computer Science,


MAJU

Page 68

Lab 7 Introduction to Operator Overloading

Figure 2: Final output of toll class


7. 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
[Expected time = 25 mins]
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
[Expected time = 25 mins]
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
[Expected time = 20 mins]
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.
Department of Computer Science,
Page 69
MAJU

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
obj1= 10
obj2= 20
obj3= 40
obj4= 20
obj5= 30
obj6= 20
Provide any value for fuel

Sample Outputs
The average distance covered is 23.33

Obj1+obj2+obj3+obj4+obj5+obj6/6
Test Cases for Practice Task-2
Sample Inputs
obj1.numerator = 1
obj1.denominator = 2

Sample Outputs
Sum = obj1 + obj2 =

obj2.numerator = 3
obj2.denominator = 2

4
2

Difference = obj1- obj2 =

Product = obj1*obj2 =

Test Cases for Practice Task-3


Sample Inputs
Number = 9.5
First call the post increment

-2
2

3
4

Sample Outputs
After post increment result is 9.6
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
T1
T2
T3

Confirmation

Comments

Department of Computer Science,


MAJU

Page 70

Lab 7 Introduction to Operator Overloading

8. Evaluation Task (Unseen)


[Expected time = 55 mins]
The lab instructor will assign you an unseen task depending upon the progress of the students.
9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned
marks which will be evaluated by the instructor in the lab depending on the accomplishment of the assigned tasks.
Table 3: Evaluation of the Lab
Sr.
No.
1
2
3
4
5
6
7

Task No

Description

Marks

4.1
6
7.1
7.2
7.2
8

Problem Modelling
Procedures and Tools
Practice task 1 with Testing
Practice task 2 with Testing
Practice task 3 with Testing
Evaluation Tasks (Unseen)
Good Programming
Practices
Total Marks

10
5
20
25
15
20
5
100

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++, Fourth edition, Joyce Farrell

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 71

Lab Manual for Object-Oriented Programming


(LAB-08)
Inheritance in Object Oriented Programming

Department of Computer Science,


MAJU

Page 72

Lab 8 - Inheritance in Object Oriented Programming

Table of Contents
1.

Introduction

74

2.

Activity Time Boxing

74

3.

Objective of the Experiment

75

4.

Concept Map

75

5.

Homework before Lab

75

5.1
5.2

75
76

6.

7.

Problem Solution Modeling


Practices from Home

Procedure & Tools

76

6.1
6.2
6.3

76
76
76

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

78

7.1
7.2
7.3
7.4

78
78
79
79

Practice Task 1
Practice Task 2
Outcomes
Testing

8.

Evaluation Task (Unseen)

79

9.

Evaluation Criteria

79

10. Further Reading


10.1
10.2

79

Books
Slides

79
79

Department of Computer Science,


MAJU

Page 73

Lab 8 - Inheritance in Object Oriented Programming

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 classs object instantiation, default/no-argument constructor for the base class(es) are
automatically called first and are followed by calling derived classs constructors. If base class(es) is/are without
default/no-argument constructor, then it is must to call explicitly any base classs constructor even if there is no need
to call a constructor.
Regarding syntax, other details are given in the section 6.3.

Relevant Lecture Readings:

Lecture: 15 and 16
Textbook: Object-Oriented Programming in C++; Author: Robert Lafore, Fourth Edition
o Pages: 372 428

2. Activity Time Boxing


Task No.
6.2
6.3
7
8

Table 1: Activity Time Boxing


Activity Name
Activity time
Setting-up Visual Studio
5 mins
Walk-through Tasks
30 mins
Practice tasks
40 mins for each task
Evaluation Task
55 min for all assigned task
Total Time
Department of Computer Science,
MAJU

Total Time
5 mins
30 mins
80 mins
55 mins
170 mins
Page 74

Lab 8 - Inheritance in Object Oriented Programming

3. 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 classs constructors within derived class(es)

4. 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.

5. 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.

Department of Computer Science,


MAJU

Page 75

Lab 8 - Inheritance in Object Oriented Programming

5.2 Practices from Home


5.2.1 Task-1
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
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 classs 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.

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.

6.2 Setting-up Visual Studio 2008


Setup visual studio and make a project named Inheritance

[Expected time = 5 mins]

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:
Department of Computer Science,
MAJU

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.

Department of Computer Science,


MAJU

Page 77

Lab 8 - Inheritance in Object Oriented Programming

Figure 3: Final Output

7. 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
[Expected Time = 40 mins]
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
[Expected Time = 40 mins]
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.

Department of Computer Science,


MAJU

Page 78

Lab 8 - Inheritance in Object Oriented Programming

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
T1
T2

8. Evaluation Task (Unseen)

Confirmation

Comments

[Expected Time = 55 mins for all tasks]

The lab instructor will give you unseen task depending upon the progress of the class.

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned the
marks percentage which will be evaluated by the instructor in the lab whether the student has finished the
complete/partial task(s).
Table 3: Evaluation of the Lab
Sr. No.
1
2
3
4
5

Task No
6
7.1

Description
Procedures and Tools
Practice tasks and Testing
Evaluation Tasks (Unseen)
Comments
Good Programming Practices
Total Time

Marks
10
55
20
5
10
100

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++; Joyce Farrell, Fourth Edition

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 79

Lab Manual for Object-Oriented Programming


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

Department of Computer Science,


MAJU

Page 80

Lab 9 - The Protected Access Specifier and Types of Inheritance

Table of Contents
1.

Introduction

82

2.

Activity Time Boxing

83

3.

Objective of the Experiment

83

4.

Concept Map

83

5.

Homework before Lab

84

5.1
5.2

84
84

6.

7.

Problem Solution Modeling


Practices from Home

Procedure & Tools

85

6.1
6.2
6.3

85
85
85

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

86

7.1
7.2
7.3
7.4
7.5

86
87
87
87
87

Practice Task 1
Practice Task 2
Practice Task 3
Outcomes
Testing

8.

Evaluation Task (Unseen)

88

9.

Evaluation Criteria

88

10. Further Reading


10.1
10.2

88

Books
Slides

88
88

Department of Computer Science,


MAJU

Page 81

Lab 9 - The Protected Access Specifier and Types of Inheritance

Lab 09: The protected Access Specifier and Types of


Inheritance in C++
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 classs member functions are able to access classs 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
classs 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.

Department of Computer Science,


MAJU

Page 82

Lab 9 - The Protected Access Specifier and Types of Inheritance

Relevant Lecture Readings:

Lectures: 17, 18
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Pages: 372 - 428

2. Activity Time Boxing


Table 1: Activity Time Boxing
Task No.
6.2
6.3
7

Activity Name
Setting-up Visual Studio
Walk-through Tasks
Practice tasks

Evaluation Task

Activity time
5 mins
30 mins
25 mins for task 1 and 2
35 mins for task 3
50 min for all assigned task
Total Time

Total Time
5 mins
30 mins
85 mins
50 mins
170 mins

3. 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 classs data members
understand public, private, and protected types of inheritance

4. 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 classs
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
classs member(s) are different as illustrated in Table 2.
Table 2: Inheritance access specifiers and their effect on derived class members

Access Specifier with Data


Member in Base class

Private
Protected
Public

Access Specifier with Inherited class


Private
Protected
Public
Inaccessible Inaccessible Inaccessible
private
Protected
protected
private
Private
Private

Department of Computer Science,


MAJU

Page 83

Lab 9 - The Protected Access Specifier and Types of Inheritance

5. 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:
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
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
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
Department of Computer Science,
MAJU

Page 84

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.

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup visual studio and make a project named InheritanceSpecifier

[Expected time = 5 mins]

6.3 Walkthrough Task


[Expected time = 30 mins]
In this task, you are required 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

Department of Computer Science,


MAJU

Page 85

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

7. 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
[Expected Time = 25 mins]
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
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.

Department of Computer Science,


MAJU

Page 86

Lab 9 - The Protected Access Specifier and Types of Inheritance

7.2 Practice Task 2


[Expected Time = 25 mins]
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

[Expected Time = 35 mins]

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
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
Department of Computer Science,
MAJU

Page 87

Lab 9 - The Protected Access Specifier and Types of Inheritance

Table 3: Practice Tasks Confirmation


Practice Tasks
T1
T2
T3

8. Evaluation Task (Unseen)

Confirmation

Comments

[Expected Time = 50 mins for all tasks]

The lab instructor will give you unseen task depending upon the progress of the class.

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned the
marks percentage which will be evaluated by the instructor in the lab whether the student has finished the
complete/partial task(s).
Table 4: Evaluation of the Lab
Sr. No.
1
2
3
4
5

Task No
6
7.1

Description
Procedures and Tools
Practice tasks and Testing
Evaluation Tasks (Unseen)
Comments
Good Programming Practices
Total Marks

Marks
10
55
20
5
10
100

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++; Joyce Farrell, Fourth Edition

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 88

Lab Manual for Object-Oriented Programming


(LAB-10)
Multi-level and Multiple Inheritance

Department of Computer Science,


MAJU

Page 89

Lab 10 - Multi-level and Multiple Inheritance

Table of Contents
1.

Introduction

91

2.

Activity Time Boxing

92

3.

Objective of the Experiment

92

4.

Concept Map

92

5.

Homework before Lab

93

5.1
5.2

93
93

6.

7.

Problem Solution Modeling


Practices from home

Procedure & Tools

93

6.1
6.2
6.3

93
93
94

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

95

7.1
7.2
7.3

95
96
96

Practice Task 1
Outcomes
Testing

8.

Evaluation Task (Unseen)

96

9.

Evaluation Criteria

96

10. Further Reading


10.1
10.2

97

Books
Slides

97
97

Department of Computer Science,


MAJU

Page 90

Lab 10 - Multi-level and Multiple Inheritance

Lab 10: Multi-level and Multiple Inheritance


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
};
class Y
{
//code statements go
};
class Z: public X, public
{
//code statements go
};

here

here
Y
here

Department of Computer Science,


MAJU

Page 91

Lab 10 - Multi-level and Multiple Inheritance

Relevant Lecture Readings:

Lectures: 19, 20
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Pages: 399- 412

2. Activity Time Boxing


Table 1: Activity Time Boxing
Task No.
6.2
6.3
7
8

Activity Name
Setting-up Visual Studio
Walk-through Tasks
Practice tasks
Evaluation Task

Activity time
5 mins
30 mins
80 mins
55 min for all assigned task
Total Time

Total Time
5 mins
30 mins
80 mins
55 mins
170 mins

3. Objective of the Experiment


After completing this lab, the student should be able to:
develop multiple level class hierarchies
derive a child class from multiple base classes
understand the advantages of multi-level inheritance and multiple inheritance

4. 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

Administration

Student

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.
Department of Computer Science,
MAJU

Page 92

Lab 10 - Multi-level and Multiple Inheritance

5. 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:
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
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, 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
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++.

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup visual studio and make a project named MultipleInheritance

Department of Computer Science,


MAJU

[Expected time = 5 mins]

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

Department of Computer Science,


MAJU

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

7. 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
[Expected Time = 80 mins]
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
Department of Computer Science,
MAJU

Page 95

Lab 10 - Multi-level and Multiple Inheritance

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
T1

8. Evaluation Task (Unseen)

Confirmation

Comments

[Expected Time = 55 mins for all tasks]

The lab instructor will give you unseen task depending upon the progress of the class.

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned the
marks percentage which will be evaluated by the instructor in the lab whether the student has finished the
complete/partial task(s).
Table 4: Evaluation of the Lab
Sr. No.
1
2
3
4
5

Task No
6
7.1

Description
Procedures and Tools
Practice tasks and Testing
Evaluation Tasks (Unseen)
Comments
Good Programming Practices
Total Marks
Department of Computer Science,
MAJU

Marks
10
55
20
5
10
100
Page 96

Lab 10 - Multi-level and Multiple Inheritance

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++; Joyce Farrell, Fourth Edition

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 97

Lab Manual for Object-Oriented Programming


(LAB-11)
Function Overloading and Function Overriding

Department of Computer Science,


MAJU

Page 98

Lab 11 - Function Overloading and Function Overriding

Table of Contents
1.

Introduction

100

2.

Activity Time Boxing

100

3.

Objective of the Experiment

101

4.

Concept Map

101

5.

Homework before Lab

101

5.1
5.2

101
102

6.

7.

Problem Solution Modeling


Practices from home

Procedure & Tools

102

6.1
6.2
6.3

102
102
102

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

104

7.1
7.2
7.3
7.4

104
104
105
105

Practice Task 1
Practice Task 2
Outcomes
Testing

8.

Evaluation Task (Unseen)

105

9.

Evaluation Criteria

105

10. Further Reading


10.1
10.2

105

Books
Slides

105
105

Department of Computer Science,


MAJU

Page 99

Lab 11 - Function Overloading and Function Overriding

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 classs 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;
}
};
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.

Relevant Lecture Readings:

Lectures: 21, 22
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Pages: 188-193, 382-392
Department of Computer Science,
MAJU

Page 100

Lab 11 - Function Overloading and Function Overriding

2. Activity Time Boxing


Table 1: Activity Time Boxing
Task No.
6.2
6.3
7

Activity Name
Setting-up Visual Studio
Walk-through Tasks
Practice tasks

Evaluation Task

Activity time
5 mins
30 mins
50 mins for task 1
30 mins for task 2
55 min for all assigned task
Total Time

Total Time
5 mins
30 mins
80 mins
55 mins
170 mins

3. 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

4. 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.

5. 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.

Department of Computer Science,


MAJU

Page 101

Lab 11 - Function Overloading and Function Overriding

5.1.1 Problem description:


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
Consider 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
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.

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup visual studio and make a project named FunctionOverloading
6.3 Walkthrough Task

[Expected time = 5 mins]

[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:

Department of Computer Science,


MAJU

Page 102

Lab 11 - Function Overloading and Function Overriding

Figure 1: Function Overloading

Figure 2: Main( ) function for Figure 1


Department of Computer Science,
MAJU

Page 103

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

7. 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
[Expected Time = 50 mins]
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

[Expected Time = 30 mins]

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
Department of Computer Science,
MAJU

Page 104

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
T1
T2

8. Evaluation Task (Unseen)

Confirmation

Comments

[Expected Time = 55 mins for all tasks]

The lab instructor will give you unseen task depending upon the progress of the class.

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned the
marks percentage which will be evaluated by the instructor in the lab whether the student has finished the
complete/partial task(s).
Table 4: Evaluation of the Lab
Sr. No.
1
2
3
4
5

Task No
6
7.1

Description
Procedures and Tools
Practice tasks and Testing
Evaluation Tasks (Unseen)
Comments
Good Programming Practices
Total Marks

Marks
10
55
20
5
10
100

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++; Joyce Farrell, Fourth Edition

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\
Department of Computer Science,
MAJU

Page 105

Lab Manual for Object-Oriented Programming


(LAB-12)
Polymorphism in Object Oriented Programming

Department of Computer Science,


MAJU

Page 106

Lab 12 - Polymorphism in Object Oriented Programming

Table of Contents
1.

Introduction

108

2.

Activity Time Boxing

110

3.

Objective of the Experiment

110

4.

Concept Map

110

5.

Homework before Lab

110

5.1
5.2

110
111

6.

7.

Problem Solution Modeling


Practices from home

Procedure & Tools

111

6.1
6.2
6.3

111
111
111

Tools
Setting-up Visual Studio 2008
Walk-through Task

Practice Tasks

113

7.1
7.2
7.3
7.4

113
113
114
114

Practice Task 1
Practice Task 2
Outcomes
Testing

8.

Evaluation Task (Unseen)

114

9.

Evaluation Criteria

114

10. Further Reading


10.1
10.2

114

Books
Slides

114
114

Department of Computer Science,


MAJU

Page 107

Lab 12 - Polymorphism in Object Oriented Programming

Lab 12: Polymorphism in Object Oriented


Programming
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 classs 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.
Department of Computer Science,
MAJU

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 classs 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).

Relevant Lecture Readings:

Lectures: 23, 24, 25, 26


Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Pages: 503- 520
Department of Computer Science,
MAJU

Page 109

Lab 12 - Polymorphism in Object Oriented Programming

2. Activity Time Boxing


Task No.
6.2
6.3
7
8

Table 1: Activity Time Boxing


Activity Name
Activity time
Setting-up Visual Studio
5 mins
Walk-through Tasks
30 mins
Practice tasks
80 mins for two task
Evaluation Task
55 min for all assigned task
Total Time

Total Time
5 mins
30 mins
80 mins
55 mins
170 mins

3. 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

4. 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.

5. 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:
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.
Department of Computer Science,
MAJU

Page 110

Lab 12 - Polymorphism in Object Oriented Programming

5.2 Practices from home


5.2.1 Task-1
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
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.

6. 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:

Department of Computer Science,


MAJU

Page 111

Lab 12 - Polymorphism in Object Oriented Programming

Figure 1: Polymorphism

Figure 2: Main( ) function for Figure 1

Department of Computer Science,


MAJU

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

7. 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
Consider an abstract class Computer having
Two fields (i.e. companyName, price) and
A single function named show()

[Expected Time = 40 mins]

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
Create a class named Person, which contains
A pure virtual function named print()
Two data fields i.e. personName and age

[Expected Time = 40 mins]

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

Department of Computer Science,


MAJU

Page 113

Lab 12 - Polymorphism in Object Oriented Programming

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
T1
T2

8. Evaluation Task (Unseen)

Confirmation

Comments

[Expected Time = 55 mins for all tasks]

The lab instructor will give you unseen task depending upon the progress of the class.

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned the
marks percentage which will be evaluated by the instructor in the lab whether the student has finished the
complete/partial task(s).
Table 4: Evaluation of the Lab
Sr. No.
1
2
3
4
5

Task No
6
7.1

Description
Procedures and Tools
Practice tasks and Testing
Evaluation Tasks (Unseen)
Comments
Good Programming Practices
Total Marks

Marks
10
55
20
5
10
100

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++; Joyce Farrell, Fourth Edition

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 114

Lab Manual for Object-Oriented Programming


(LAB-13)
Relationships in Object Oriented Programming

Department of Computer Science,


MAJU

Page 115

Lab 13 - Relationships in Object Oriented Programming

Table of Contents
1.

Introduction

117

2.

Activity Time Boxing

118

3.

Objective of the Experiment

118

4.

Concept Map

118

5.

Homework before Lab

119

5.1
5.2

119
119

6.

7.

Problem Solution Modeling


Practices from home

Procedure & Tools

119

6.1
6.2
6.3

119
119
120

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

121

7.1
7.2
7.3

121
122
122

Practice Task 1
Outcomes
Testing

8.

Evaluation Task (Unseen)

122

9.

Evaluation Criteria

122

10. Further Reading


10.1
10.2

122

Books
Slides

122
122

Department of Computer Science,


MAJU

Page 116

Lab 13 - Relationships in Object Oriented Programming

Lab 13: Relationships in Object Oriented


Programming
1. Introduction
In OOP, various kinds of relationships (i.e. inheritance, association, aggregation, composition) exist between various
classes/objects.
Inheritance is modeled as is-a relationship. Inheritance exists between classes and the main goal of inheritance is to
make objects that would represent specialized versions of generalized original objects. For example, a car is-a
vehicle, manager is-an employee etc.
On the other hand, association and aggregation/composition represent uses-a and has-a relationship, respectively
between objects. It is based on the object-oriented design where an object can contain other object(s). Association
specifies that objects of different kinds are connected with each other and there exist no ownership and lifecycle
dependency. In advance, aggregation and composition are two types of association representing weak and strong
(whole-part) relationship between contained (whole) and owing (part) objects. Therefore, aggregation and
composition are other forms of code reusability along with inheritance. Aggregation is a special kind of association
represents ownership relationship between objects. Composition is special kind of aggregation which represents
ownership between objects along with the existence of life-cycle dependency. A department-employees relationship
is an example of aggregation whereas university-departments relationship is an example of composition.
Following example explains the syntax for aggregation and composition in C++:
class Battery{
};
class Engine{
};
class Vehicle
{
private:
Battery *bat;
Engine *eng;
public:
Vehicle(Battery *b)
{
bat = b;
eng = new Engine();
}
~Vehicle()
{
delete eng;
}
};
Above example shows that aggregation exists between battery and vehicle because of the possession of ownership
but not life-cycle dependency. On the contrary, composition exists between vehicle and engine because of the
possession of ownership and life-cycle dependency.

Relevant Lecture Readings:

Lectures: 27, 28
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Pages: 414- 420

Department of Computer Science,


MAJU

Page 117

Lab 13 - Relationships in Object Oriented Programming

2. Activity Time Boxing


Table 1: Activity Time Boxing
Task No.
6.2
6.3
7
8

Activity Name
Setting-up Visual Studio
Walk-through Tasks
Practice tasks
Evaluation Task

Activity time
5 mins
30 mins
80 mins for assigned task
55 min for all assigned task
Total Time

Total Time
5 mins
30 mins
80 mins
55 mins
170 mins

3. Objective of the Experiment


After completing this lab, the student should be able to:
model relationship between existing classes
distinguish between association, aggregation, and composition
understand difference between aggregation and composition in terms of ownership and life cycle

4. Concept Map
Primarily two tasks are the part of each object-oriented design i.e. identification of object types within the problem
domain and relationship modeling between the existing object types. Three kinds of relationships are usually exist
between identified objects i.e.

is-a relationship (Inheritance)


uses-a relationship (Association)
has-a relationship (Aggregation, Composition)

The is-a relationship exhibits a relationship between an object of specific type to its general type. For example, a bus
is-a vehicle, an employee is-a person, circle is-a geometric shape etc. The is-a relationship has been modeled in
terms of inheritance that you have already studied in Lectures 15-18.
The uses-a relationship demonstrate that an object of one specific type uses an object of different type to perform
some activity. For example, a person uses-a wiper to wash bus window pane, a teacher uses-a course to teach
student, a cyclist uses-a pump in tire-pumping activity). The uses-a relationship can be described as association
between objects i.e. a teacher has association with student through a specific course. Similarly, university has
association with its departments through administration. In simple words, association is a relationship between
objects where exists no ownership and each object has its own lifecycle. More specifically, association are of two
types i.e. aggregation and composition that represents has-a relationship between objects.
The has-a relationship represents a classical ownership of whole-part relationship. Sometimes an object of one type
contains an object of type e.g. a university has-a number of departments and ultimately a department has a number
of professors, a bus has-an engine, a bike has-a set of wheels etc. The has-a relationship can be modeled as
aggregation and composition.

Aggregation is type of association representing weak relationship. In aggregation, contained object exists even
after the release of an owning object. Hence, in aggregation, there exists ownership without life-cycle
dependency. For example, if a company no longer exists even then employee of that will continue to exist.
Composition is a special type of aggregation representing strong relationship in which the life-cycle of the part
is dependent on the whole. Existence of the part is directly dependent on the existence of the whole. For
example, the relationship between vehicle and its engine. Engine is build and destroyed whenever a vehicle is
build or destroyed, respectively.

Department of Computer Science,


MAJU

Page 118

Lab 13 - Relationships in Object Oriented Programming

5. 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:
A class named Processor has
Two attributes i.e. processName and price
A parameterized constructor to initialize attributes with user-defined values
Class MainMemory consists of
Two attributes i.e. size and price
A parameterized constructor to initialize attributes with user-defined values
Class MotherBoard has
a data member named compName of type string
a no-argument constructor to initialize with default name intel
Design a class named Computer that includes
A data member named proc of type Processor
A data member named ram of type MainMemory
A data member named mboard of type MotherBoard
A parameterized constructor that accept two arguments of type Processor and MainMemory to initialize
members of these types. Moreover, within this constructor, instantiate object of MotherBoard to initialize
mboard data field.
Draw UML diagram for each class and show aggregation and composition relationship between these classes.
5.2 Practices from home
5.2.1 Task-1
Using C++ compiler, illustrate the implementation of classes that have been specified in section 5.1.1. Write main()
in a way that it clearly describes aggregation and composition relationships between objects of implemented classes.
5.2.2 Task-2
Consider seven classes i.e. Vehicle, Bus, Wheel, Brakes, Carburetor, Engine, SteeringWheel.
Draw UML diagram for each class and show aggregation and composition relationship between these classes.
Using C++ compiler, demonstrate the implementation of classes in a way that it proves inheritance relationship
between appropriate classes, and aggregation/composition relationship between objects of various classes in terms
of ownership and lifecycle dependency.

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup visual studio and make a project named RelationshipExample
Department of Computer Science,
MAJU

[Expected time = 5 mins]

Page 119

Lab 13 - Relationships in Object Oriented Programming

6.3 Walkthrough Task


[Expected time = 30 mins]
In this task, you are required to write a C++ code which would elaborate the concept of relationships (i.e.
inheritance, aggregation, composition) in OOP. The following lines show the output of a basic relationship concept:
6.3.1 Writing Code
In the source file, which is created in the project RelationshipExample write following C++ code:

Figure 1: Relationship Example

Figure 2: Main( ) function for Figure 1

Department of Computer Science,


MAJU

Page 120

Lab 13 - Relationships 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

7. 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\Lab123
7.1 Practice Task 1
[Expected Time = 80 mins]
Consider six classes i.e. Person, Professor, Researcher, Department, Laboratory, and University having following
specifications.
Class University has
Two attributes of type string i.e. universityName and location
An attribute named dept of type Department
Class Department has
Two attributes i.e. deptID, deptName
A two-argument constructor to initialize data fields with user-defined values
A member function display() to show all attribute values
Class Laboratory contains
Two attributes i.e. labID and experimentNo
A two-argument constructor to initialize data member with user-defined values
Class Person has
Two attributes i.e. name and age
A parameterized constructor to initialize attributes with user-defined values
A member function display() to show its attribute values
Class Professor is derived from class Person and has
A data field named profName of type string
A data field named dept of type Department
A two-argument constructor to initialize both attributes of user-defined values
Class Researcher is derived from class Professor and has
An additional attribute named lab of type Laboratory
A constructor to initialize lab with user-defined value
Department of Computer Science,
MAJU

Page 121

Lab 13 - Relationships in Object Oriented Programming

a)

Draw UML diagram for each class and show inheritance, aggregation, and composition relationship
between these classes.
b) Implement all these classes while illustrating the concept of aggregation and composition in terms of
ownership and life-cycle.
7.2 Outcomes
After completing this lab, student will be able to implement the concepts of association, aggregation, and
composition in terms of ownership and life cycle of associated objects.
7.3 Testing

For Practice Task 1, Lab instructor must verify the implementation and required relationships among all
classes and objects. In addition, it is required to confirm that code has clearly elaborated the concept of
aggregation and composition in terms of ownership and life cycle.
Table 3: Practice Tasks Confirmation
Practice Tasks
T1

8. Evaluation Task (Unseen)

Confirmation

Comments

[Expected Time = 55 mins for all tasks]

The lab instructor will give you unseen task depending upon the progress of the class.

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned the
marks percentage which will be evaluated by the instructor in the lab whether the student has finished the
complete/partial task(s).
Table 4: Evaluation of the Lab
Sr. No.
1
2
3
4
5

Task No
6
7.1

Description
Procedures and Tools
Practice tasks and Testing
Evaluation Tasks (Unseen)
Comments
Good Programming Practices
Total Marks

Marks
10
55
20
5
10
100

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++; Joyce Farrell, Fourth Edition

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 122

Lab Manual for Object-Oriented Programming


(LAB-14)
Function and Class Templates

Department of Computer Science,


MAJU

Page 123

Lab 14 - Function and Class Templates

Table of Contents
1.

Introduction

125

2.

Activity Time Boxing

126

3.

Objective of the Experiment

126

4.

Concept Map

126

5.

Homework before Lab

126

5.1

126

6.

7.

Practices from Home

Procedure & Tools

127

6.1
6.2
6.3

127
127
127

Tools
Setting-up Visual Studio 2008
Walkthrough Task

Practice Tasks

128

7.1
7.2
7.3
7.4
7.5

128
128
128
129
129

Practice Task 1
Practice Task 2
Practice Task 3
Outcomes
Testing

8.

Evaluation Task (Unseen)

129

9.

Evaluation Criteria

129

10. Further Reading


10.1
10.2

130

Books
Slides

130
130

Department of Computer Science,


MAJU

Page 124

Lab 14 - Function and Class Templates

Lab 14: Function and Class Templates


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
functionName(T
value)
{
return
value * value;

T>

}
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;
functionName(var1);
functionName(var2);
functionName(var3);

double

var3 = 10.0;

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>
TemplateExample<double>

TE1;
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.

Relevant Lecture Readings:

Lectures: 29, 30, 31


Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Pages: 682- 703
Department of Computer Science,
MAJU

Page 125

Lab 14 - Function and Class Templates

2. Activity Time Boxing


Table 1: Activity Time Boxing
Task No.
6.2
6.3
7

Activity Name
Setting-up Visual Studio
Walk-through Tasks
Practice tasks

Evaluation Task

Activity time
5 mins
30 mins
25 mins each for task 1 and 2
40 mins for task 3
45 min for all assigned task
Total Time

Total Time
5 mins
30 mins
90 mins
45 mins
170 mins

3. 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).

4. 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.

5. Homework before Lab


5.1 Practices from Home
5.1.1 Task-1
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
Consider a class named Calculator that contains

Two data members i.e. num1 and num2


Department of Computer Science,
MAJU

Page 126

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.

6. Procedure & Tools


6.1 Tools
Visual Studio 2008.
6.2 Setting-up Visual Studio 2008
Setup visual studio and make a project named TemplateExample

[Expected time = 5 mins]

6.3 Walkthrough Task


[Expected time = 30 mins]
In this task, you are required 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

Department of Computer Science,


MAJU

Page 127

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

7. 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


[Expected Time = 25 mins]
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
[Expected Time = 25 mins]
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
Create a class template for a class named GeneralStack that holds

[Expected Time = 40 mins]

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.

Department of Computer Science,


MAJU

Page 128

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
int arr = {101, 29, 40, 90,45}
minimun(arr, 5)
double arr = {10.11, 2.99, 1.40, 90.99}
minimun(arr, 4)

1.40

Test cases for Practice Lab 2


Sample Inputs
area(5.0)
area(5)
area(20.0,10.0)
area(20,10)

Sample Outputs
29

Sample Outputs
78.5
78
200.0
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
T1
T2
T3

8. Evaluation Task (Unseen)

Confirmation

Comments

[Expected Time = 45 mins for all tasks]

The lab instructor will give you unseen task depending upon the progress of the class.

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned the
marks percentage which will be evaluated by the instructor in the lab whether the student has finished the
complete/partial task(s).
Table 4: Evaluation of the Lab
Sr. No.
1
2
3
4
5

Task No
6
7.1

Description
Procedures and Tools
Practice tasks and Testing
Evaluation Tasks (Unseen)
Comments
Good Programming Practices
Total Marks
Department of Computer Science,
MAJU

Marks
10
55
20
5
10
100
Page 129

Lab 14 - Function and Class Templates

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++; Joyce Farrell, Fourth Edition

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 130

Lab Manual for Object-Oriented Programming


(LAB-15)
Exception Handling

Department of Computer Science,


MAJU

Page 131

Lab 15 - Exception Handling

Table of Contents
1.

Introduction

133

2.

Activity Time Boxing

133

3.

Objective of the Experiment

134

4.

Concept Map

134

5.

Homework before Lab

134

5.1
5.2

134
135

6.

7.

Problem Solution Modeling


Practices from Home

Procedure & Tools

135

Tools
6.1
Setting-up Visual Studio 2008
6.2
Walkthrough Task

135
135
135

Practice Tasks

137

7.1
7.2
7.3
7.4
7.5

137
137
137
137
138

Practice Task 1
Practice Task 2
Practice Task 3
Outcomes
Testing

8.

Evaluation Task (Unseen)

138

9.

Evaluation Criteria

138

10. Further Reading


10.1
10.2

138

Books
Slides

138
138

Department of Computer Science,


MAJU

Page 132

Lab 15 - Exception Handling

Lab 15: Exception Handling


1. Introduction
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 }

Relevant Lecture Readings:

Lecture: 32
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Pages: 703 - 720

2. Activity Time Boxing


Table 1: Activity Time Boxing
Task No.
6.2
6.3
7
8

Activity Name
Setting-up Visual Studio
Walk-through Tasks
Practice tasks
Evaluation Task

Activity time
5 mins
25 mins
30 mins for each task
50 min for all assigned task
Total Time

Department of Computer Science,


MAJU

Total Time
5 mins
25 mins
90 mins
50 mins
170 Mins
Page 133

Lab 15 - Exception Handling

3. 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.

4. 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
...
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.

5. 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.

Department of Computer Science,


MAJU

Page 134

Lab 15 - Exception Handling

5.2 Practices from Home


5.2.1 Task-1
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
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).

6. Procedure & Tools


Tools
Visual Studio 2008.
6.1 Setting-up Visual Studio 2008
Setup visual studio and make a project named ExceptionHandling

[Expected time = 5 mins]

6.2 Walkthrough Task


[Expected time = 25 mins]
In this task, you are required 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:

Department of Computer Science,


MAJU

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:

Department of Computer Science,


MAJU

Page 136

Lab 15 - Exception Handling

Figure 3: Final Output

7. 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
[Expected Time = 30 mins]
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
[Expected Time = 30 mins]
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
[Expected Time = 30 mins]
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.

Department of Computer Science,


MAJU

Page 137

Lab 15 - Exception Handling

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
T1
T2
T3

8. Evaluation Task (Unseen)

Confirmation

Comments

[Expected Time = 50 mins for all tasks]

The lab instructor will give you unseen task depending upon the progress of the class.

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned the
marks percentage which will be evaluated by the instructor in the lab whether the student has finished the
complete/partial task(s).
Table 4: Evaluation of the Lab
Sr. No.
1
2
3
4
5

Task No
6
7.1

Description
Procedures and Tools
Practice tasks and Testing
Evaluation Tasks (Unseen)
Comments
Good Programming Practices
Total Marks

Marks
10
55
20
5
10
100

10. Further Reading


10.1 Books

Object-Oriented Programming Using C++; Joyce Farrell, Fourth Edition

10.2 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\dataserver\jinnah$\

Department of Computer Science,


MAJU

Page 138

Annexure A
Course Outline

Week#

Lecture#
Lecture 1

1
Lecture 2
Lecture 3
2

Lecture 4
Lecture 5

Lecture 6
Lecture 7
Lecture 8
Lecture 9

5
6

8
9
10
11
12
13
14
15
16

Lecture 10
Lecture 11
Lecture 12
Lecture 13
Lecture 14
Lecture 15
Lecture 16
Lecture 17
Lecture 18
Lecture 19
Lecture 20
Lecture 21
Lecture 22
Lecture 23
Lecture 24
Lecture 25
Lecture 26
Lecture 27
Lecture 28
Lecture 29
Lecture 30
Lecture 31
Lecture 32

Topic
- Introduction of the Course
- Overview of Structured Programming in C++
- Function Revision (Call by Value, Call by Reference, Call by Pointer)
- Pointer Revision
- Object-Oriented Concepts (Introduction to Classes and Objects)
- Data Members and Member Functions
- Constant Member Functions
- Use of Access Specifiers (public, private) - (Scope of class members)
- Concept of Constructor and Object Instantiation
- Importance of Destructor
- Constructor Overloading
(No-argument Constructor, Parameterized Constructor)
- Introduction to copy constructors
- Shallow Copy and Deep Copy
- Array as class data members (Initializing array with constructors)
- Static and Dynamic Arrays, Array of Objects
- Friend Functions
- Friend Classes
- Operator Overloading - (Unary and Binary Operator Overloading)
- Assignment Operator Overloading
(Difference between Assignment Operator and Copy Constructor)
- Stream Insertion and Extraction Operator Overloading
- Introduction to Inheritance in OOP
- Constructor and Destructor Chaining
- The protected access specifier
- Types of Inheritance
- Class Hierarchies (Multi-level Inheritance)
- C++ Multiple Inheritance
- Function Overloading and Function Overriding
- Object as argument to the Function
- Pointer to Objects
- Introduction to Polymorphism in OOP
- Virtual Functions
- Pure Virtual Functions and Abstract Base Classes
- Virtual Inheritance
(The Diamond Problem and its Solution)
- Relationships in OOP - (Association, Aggregation, and Composition)
- Life Cycle and Ownership of Objects
- Function Templates
- Class Template Specialization
- Standard Template Libraries
- Exception Handling

Department of Computer Science,


MAJU

Page 139

Annexure B
Good Programming Practices
This section presents you some of the well known good programming practices. You will be evaluated based on
these practices in all your tasks.
Generic Programming Practices

Always use indentation. Your code should clearly state the start and end of the if-statements, loopstatements, switch statements etc.
Always use meaningful variable names, do not use the general name of variables such as: a, b, x etc.
For example, you want to declare a variable to store the marks obtained by a student, you may think of
using the name of this variable as std_marks.
Always use consistent variable names in your code for things that are similar. For example you want to
store student-marks and student-names. And for student marks you have already defined std_marks, now
if you define the student-name to store student name. This will not remain consistent although
std_name is also a valid and good logical name.
Same rule applies for function names. Make sure that function names are meaningful and convey their
purpose.
Always use proper comments to each line/ section. For example what a particular line is doing, what a
particular loop, if-statement is doing. This will help other people and yourself in understanding the code.
Always select a proper data type to store a particular data. For example, storing the status of student as
pass or fail, you may consider the data type of Boolean, instead of using int variable which will be
excessively larger data type to store such values.
Write only one statement per line.

OOP Programming Practices


Presented below is a list of practices that you are expected to follow in the Object Oriented Programming:

Try to create many member functions and avoid creating a single member function that will set or get
values for a large number of variables.
When you create constructors make sure that you create both the nullary and the parameterized constructor.
Try to use the destructor as a cleanup mechanism.
Overload functions where possible. This increases flexibility of code.
Do not use friend functions as a technique for bypassing data hiding and encapsulation.
Do not use inheritance between classes that can have no relation between them.
Do not use exception handling as a method for non exception based programming.

Department of Computer Science,


MAJU

Page 140

This page intentionally left blank

Mohammad Ali Jinnah University


Islamabad