Ooplabmanual 150412132629 Conversion Gate01 PDF

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
Mr. Faisal Shahzad

Junior Lecturer
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

MAJU
Page 2
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.

MAJU
Page 3
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);
{
MAJU
Page 4

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

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.

MAJU
Page 6
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
MAJU
Page 7
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

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.

MAJU
Page 8
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.

MAJU
Page 9
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

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
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
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
Write a program that finds the factorial of a non negative number provided by the user. Since the user can enter a
floating point number hence your input should accommodate floats and ints. To find the factorial of the entered
number you will need to design three functions as follows:
Function to determine if a number is a whole number or not
Function to determine if the number is positive or not
Function to find the actual factorial
Remember that to find the factorial the number must of positive and a whole number. So if any of these conditions
are not met then you cannot determine the factorial.
7.5 Outcomes
After completing this lab, students will be able to use functions and also understand the concept of parameters,
arguments and returning of values. Students should also be comfortable with pointers and their use in functions.
Page 10
MAJU
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,

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

Sample Inputs
Array having all entries 1
Sample Outputs
Sum = 20
Check that pointers have been used to iterate the array

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)

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.

MAJU
Page 11
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
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$\

MAJU
Page 12

(LAB-02)
Introduction to Classes and Objects

MAJU
Page 13
Lab 2 - Introduction to Classes and Objects
Table of Contents
1.
Introduction
15
2.
15
3.
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
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
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.
21
9.
Evaluation Criteria
21
10.
Further Reading
21
10.1
10.2
21
21
Books
Slides

MAJU
Page 14
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.
Lectures: 3, 4
Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore
o Pages: 195-201

Task No.
5.1
6.2
6.3
7
8

Activity Name
Activity time
15 mins
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

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.

MAJU
Page 15
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( )
{
}

MAJU
Page 16
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.
class myclass
{
int datamember;
};
void main( )
{
void memberfun (int)

{
...
}
//Semicolon is necessary
void main( )
{
}

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.

MAJU
Page 17

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.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.1 Tools
Visual Studio 2008.
Setup Visual Studio and make a project named cylinder.

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.

MAJU
Page 18
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
Figure 2: Final output of cylinder program.

MAJU
Page 19
7. Practice Tasks
7.1 Practice Task 1
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
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
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
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

Sample Inputs
Length: 4
width: 10
Sample Outputs
Length = 5
Width = 11
Area = 55
MAJU
Page 20
call the increment function
Check the use of constant function for display

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

[Expected time = 45 Minutes]
The lab instructor will assign you an unseen task depending upon the progress of the students.
9. Evaluation Criteria
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
Good Programming
Practices
Total Marks
20
5
10
10
10
15
10
80
10. Further Reading

10.1 Books
10.2 Slides

MAJU
Page 21

(LAB-03)
Access Specifiers, Constructors and Destructors

MAJU
Page 22
Lab 3 - Access Specifiers, Constructors and Destructors
Table of Contents
1.
Introduction
24
2.
24
3.
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
27
5.1
27
Practices from home
Procedure & Tools
27
6.1
6.2
6.3
27
27
27
Tools
Walkthrough Task
Practice Tasks
29
7.1
7.2
7.3
29
30
30
Practice Task 1
Outcomes
Testing
8.
30
9.
Evaluation Criteria
31
10.
Further Reading
31
10.1
10.2
31
31
Books
Slides

MAJU
Page 23
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.
Lectures: 3, 4, 5, 6
o Pages: 201-212

Task No.
5.1
6.2
6.3
7
8
Activity Name
Walkthrough Tasks
Practice tasks
Evaluation Task

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

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.

MAJU
Page 24
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.

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.
MAJU
Page 25
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.
class myclass
{
private:
int datamember;
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.
class myclass
{
private:
int datamember;
public:
myclass( );
//Class constructor
{
cout<<Hello you have called the class constructor;
}
~myclass( );
//Class constructor
{
cout<<Hello you have called the class destructor;
}
};

MAJU
Page 26

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.1 Tools
Visual Studio 2008.
Setup Visual Studio and make a project named pizza.

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.

MAJU
Page 27
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
MAJU
Page 28
6.3.2 Compilation
Figure 2: Final output of pizza program.

7. Practice Tasks
7.1 Practice Task 1

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
MAJU
Page 29
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
Sample Inputs
Flavour = chocolate
Wafer required = yes
Number of scoops = 3
Sample Outputs
Your choice of ice cream is as follows
Flavour = chocolate
Wafer is required
Total price is 190
Thank you for visiting LeCream!
Flavour = Almond crunch

Wafer required = No

Flavour = Almond Crunch
Wafer is not required
Total price is 100
Flavour = Coffee
Wafer required = yes

Flavour = Coffee
Wafer is Required
Total price is 160
Flavour = Mango
Wafer required = No
Invalid Input
Table 2: Confirmation of practice tasks T1

Practice Tasks
T1
Confirmation
Comments

[Expected time = 45 Mins]

MAJU
Page 30
Sr.
No.
1
2
3
4
5
Task No
Description
Marks
4.1
6
7.1
8
Problem Modelling
Good Programming
Practices
Total Marks
10
5
50
15
10
90
10. Further Reading

10.1 Books
10.2 Slides

MAJU
Page 31

(LAB-04)
Constructor Overloading and Copy Constructors

MAJU
Page 32
Lab 4 - Constructor Overloading and Copy Constructors
Table of Contents
1.
Introduction
34
2.
34
3.
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
36
5.1
36
Practices from home
Procedure & Tools
36
6.1
6.2
6.3
36
36
36
Tools
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.
39
9.
Evaluation Criteria
40
10.
Further Reading
40
10.1
10.2
40
40
Books
Slides

MAJU
Page 33
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.
Lectures: 6, 7, 8
o Pages: 212-213, 216-217

Task No.
5.1
6.2
6.3
7
8

Activity time
25 mins
5 mins
35 mins
40 + 10 (mins)
55 mins
Total Time
Activity Name
Walkthrough Tasks
Practice tasks
Evaluation Task
Total Time
25 mins
5 mins
35 mins
50 mins
55 mins
170 Minutes

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);
MAJU
Page 34

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
MAJU
Page 35
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.

Provided below is a statement for a program which you will code and submit to your lab instructor.
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.1 Tools
Visual Studio 2008.
Setup Visual Studio and make a project named student.

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:

MAJU
Page 36
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

MAJU
Page 37
6.3.2 Compilation
Figure 2: Final output of student program.

7. Practice Tasks
7.1 Practice Task 1

VISION is a world leader in manufacturing LCD Televisions. The company has decided that it will allow its
customers to give the dimensions of the TV (in length and width). Once the length and width are ordered the
company will manufacture the TV according to your requirements. In this regard they want you to create a program
that will assist them. Carefully read all the instructions and follow the requirements.
Create a class called vision
Create three constructors as follows:
- A nullary constructor that calls the setlength( ) and setwidth( ) function.
- A parameterized constructor that will receive the length and width as integers
- A parameterized constructor that will receive the length and width in float
By using a special function calculate the area of the TV
Create a function to calculate the price of the TV by multiplying the area with Rs. 65.
Create a display( ) function to show the details of the purchased TV.
In the main you will construct three objects that demonstrate the use of the three constructors. After calling the
constructor it will take over and will handover control to the area function, and then the price calculation function.
Remember that the user should not have access to modifying the price.
Determine the access specifiers, data members and member functions. Also note that each constructor can / will
have a distinct functionality in its body. Hence do not try to copy code from one constructor to the other. Focus on
the design clarity and quality of your code.
Page 38
MAJU
7.2 Practice Task 2

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

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

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

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

[Expected time = 55 Mins]

MAJU
Page 39
Sr.
No.
1
2
3
4
5
6
Task No
Description
Marks
4.1
6
7.1
7.2
8
Problem Modelling
Good Programming
Practices
Total Marks
10
5
30
20
25
10
100
10. Further Reading

10.1 Books
10.2 Slides

MAJU
Page 40

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

MAJU
Page 41
Lab 5 - Shallow Copy/ Deep Copy, Working With Arrays
Table of Contents
1.
Introduction
43
2.
43
3.
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
47
5.1
47
Practices from Home
Procedure & Tools
48
6.1
6.2
6.3
48
48
48
Tools
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.
50
9.
Evaluation Criteria
50
10.
Further Reading
51
10.1
10.2
51
51
Books
Slides

MAJU
Page 42
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.
Lectures: 8, 9, 10

Task No.
5.1
6.2
6.3
7
8
Activity Name
Walkthrough Tasks
Practice tasks
Evaluation Task

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

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.
MAJU
Page 43
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

MAJU
Page 44
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

MAJU
Page 45
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

{
a[i]=0;
}
}
// 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
MAJU
Page 46
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
{
a[i]=0;
}
//Dynamic array as a data member
//The size is passed from the main
}
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.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.
MAJU
Page 47

6.1 Tools
Visual Studio 2008.
Setup Visual Studio and make a project named english.

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.

MAJU
Page 48
6.3.2 Compilation
Figure 2: Final output of english class

7. Practice Tasks
7.1 Practice Task 1

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
Your task is to create a class that contains an integer pointer data member. Create a single object named one in the
MAJU
Page 49

main and assign values to the data member of the object. Then create another object named two that is a copy of
the one. Create a shallow copy constructor and then demonstrate that both objects share a common memory i.e.
modifying one object in fact modifies the other. Create a display function that will show the values of the object.
7.3 Outcomes
After completing this lab, students will be able to conveniently use a copy constructor in both deep copy and
shallow copy mode. Further the students will have the ability to comfortably use arrays in their various forms both
inside and outside the class.
7.4 Testing
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 =

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


MAJU
Page 50

Sr.
No.
1
2
3
4
5
6
Task No
Description
Marks
4.1
6
7.1
7.2
8
Problem Modelling
Good Programming
Practices
Total Marks
10
5
30
20
25
10
100
10. Further Reading

10.1 Books
10.2 Slides

MAJU
Page 51

(LAB-06)
Friend Functions and Friend Classes

MAJU
Page 52
Lab 6 - Friend Functions and Friend Classes
Table of Contents
1.
Introduction
54
2.
54
3.
54
4.
Concept Map
54
4.1
4.2
Friend Functions
Friend Classes
54
56
56
5.1
56
5.
6.
7.
Practices from Home
Procedure & Tools
57
6.1
6.2
6.3
57
57
57
Tools
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.
60
9.
Evaluation Criteria
60
10.
Further Reading
60
10.1
10.2
60
60
Books
Slides

MAJU
Page 53
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.
Lecture: 11 - 12
o Pages: 468-475

Task No.
5.1
6.2
6.3
7
8
Activity Name
Walkthrough Tasks
Practice tasks
Evaluation Task

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

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.
MAJU
Page 54
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 );
};
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.

MAJU
Page 55
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
//cannot call using obj1! Obj1 does not contain a

function called fun

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

MAJU
Page 56

6.1 Tools
Visual Studio 2008.
Setup Visual Studio and make a project named series.
Find the sum of 1 + 2 + 3 + + arithmetic series. In an arithmetic series the difference between two
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;
}

MAJU
Page 57
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
Figure 2: Final output of series project

7. Practice Tasks
7.1 Practice Task 1

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
Page 58
MAJU
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
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
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
Sample Inputs
a =1;
b =2;
c =-3

Sample Inputs
a=1
b=2
c=3
Sample Outputs
proot= 1
nroot = -3
Sample Outputs
++
Mean = 2
2
2
=36
= 16

MAJU
Page 59

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

Practice Tasks
T1
T2
T3
Confirmation
Comments

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
Good Programming
Practices
Total Marks
10
5
15
20
25
20
5
100
10. Further Reading

10.1 Books
10.2 Slides

MAJU
Page 60

(LAB-07)
Introduction to Operator Overloading

MAJU
Page 61
Table of Contents
1.
Introduction
63
2.
63
3.
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
66
5.1
66
Practices from Home
Procedure & Tools
66
6.1
6.2
6.3
66
66
66
Tools
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.
71
9.
Evaluation Criteria
71
10.
Further Reading
71
10.1
10.2
71
71
Books
Slides

MAJU
Page 62
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.
Lecture: 13
o Pages: 291-308

Task No.
5.1
6.2
6.3
7
8
Activity Name
Walkthrough Tasks
Practice tasks
Evaluation Task

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

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.
MAJU
Page 63
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
{
. . . }
MAJU
Page 64
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;
}

MAJU
Page 65
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.

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.1 Tools
Visual Studio 2008.
Setup Visual Studio and make a project named tolltax.

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.

MAJU
Page 66
6.3.1 Writing Code

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

MAJU
Page 67
Figure 1: The toll class demonstrating the use of various overloaded operators
6.3.2 Compilation

MAJU
Page 68
Figure 2: Final output of toll class

7. Practice Tasks
7.1 Practice Task 1
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
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
A decimal number is composed of an integral part and a fractional part. The number appearing before the decimal
point is the integral part while the number appearing after the decimal point is called the fractional part. For example
if our number is 1.2 then 1 is the integral part while 2 is the fractional part. Using this concept develop the following
class.
Page 69
MAJU
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
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
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 =

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
Practice Tasks
T1
T2
T3
Confirmation
Comments

MAJU
Page 70

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
Good Programming
Practices
Total Marks
10
5
20
25
15
20
5
100
10. Further Reading

10.1 Books
10.2 Slides

MAJU
Page 71
Lab Manual for Object-Oriented Programming

(LAB-08)
Inheritance in Object Oriented Programming

MAJU
Page 72
Lab 8 - Inheritance in Object Oriented Programming
Table of Contents
1.
Introduction
74
2.
Activity Time Boxing
74
3.
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
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.
79
9.
Evaluation Criteria
79
10. Further Reading

10.1
10.2
79
Books
Slides
79
79

MAJU
Page 73
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
{
};
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

Activity Name
Activity time
5 mins
Walk-through Tasks
30 mins
Practice tasks
40 mins for each task
Evaluation Task
55 min for all assigned task
Total Time
MAJU
Total Time
5 mins
30 mins
80 mins
55 mins
170 mins
Page 74

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.

MAJU
Page 75

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.1 Tools
Visual Studio 2008.

Setup visual studio and make a project named Inheritance

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:
MAJU
Page 76
.
Figure 1: Base and Derived Classes
Figure 2: Main function for classes of Figure 1

6.3.2 Compilation

MAJU
Page 77
Figure 3: Final Output
7. Practice Tasks
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
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.

MAJU
Page 78
7.3 Outcomes
After completing this lab, student will be able to understand the implementation and design of Inheritance in C++.
7.4 Testing
For both Practice Tasks, lab instructor must examine
the implementation of above mentioned classes

the creation of instances of specified classes
the invocation of specified functions
Table 2: Practice Tasks Confirmation
Practice Tasks
T1
T2
Confirmation
Comments
[Expected Time = 55 mins for all tasks]
The lab instructor will give you unseen task depending upon the progress of the class.
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).
Sr. No.
1
2
3
4
5
Task No
6
7.1
Description
Practice tasks and Testing
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

MAJU
Page 79

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

MAJU
Page 80
Lab 9 - The Protected Access Specifier and Types of Inheritance
Table of Contents
1.
Introduction
82
2.
83
3.
83
4.
Concept Map
83
5.
Homework before Lab
84
5.1
5.2
84
84
6.
7.

Practices from Home
Procedure & Tools
85
6.1
6.2
6.3
85
85
85
Tools
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.
88
9.
Evaluation Criteria
88
10. Further Reading

10.1
10.2
88
Books
Slides
88
88

MAJU
Page 81
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.

MAJU
Page 82
Lectures: 17, 18
o Pages: 372 - 428

Task No.
6.2
6.3
7
Activity Name
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
Total Time
Total Time
5 mins
30 mins
85 mins
50 mins
170 mins

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

MAJU
Page 83

Draw UML class diagrams of the following task. You are required to bring this design with you and submit to
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.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
MAJU
Page 84
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.1 Tools
Visual Studio 2008.
Setup visual studio and make a project named InheritanceSpecifier

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

MAJU
Page 85
Figure 2: Main function for Figure 1

6.3.2 Compilation
7. Practice Tasks
7.1 Practice Task 1
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.

MAJU
Page 86
7.2 Practice Task 2

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
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
MAJU
Page 87

Practice Tasks
T1
T2
T3
Confirmation
Comments
Sr. No.
1
2
3
4
5
Task No
6
7.1
Description
Comments
Total Marks
Marks
10
55
20
5
10
100
10. Further Reading

10.1 Books
10.2 Slides

MAJU
Page 88

(LAB-10)
Multi-level and Multiple Inheritance

MAJU
Page 89
Lab 10 - Multi-level and Multiple Inheritance
Table of Contents
1.
Introduction
91
2.
92
3.
92
4.
Concept Map
92
5.
Homework before Lab
93
5.1
5.2
93
93
6.
7.

Practices from home
Procedure & Tools
93
6.1
6.2
6.3
93
93
94
Tools
Walkthrough Task
Practice Tasks
95
7.1
7.2
7.3
95
96
96
Practice Task 1
Outcomes
Testing
8.
96
9.
Evaluation Criteria
96
10. Further Reading

10.1
10.2
97
Books
Slides
97
97

MAJU
Page 90
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
{
};
class Z: public Y
{
};
...
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

MAJU
Page 91
Lectures: 19, 20
o Pages: 399- 412

Task No.
6.2
6.3
7
8
Activity Name
Walk-through Tasks
Practice tasks
Evaluation Task
Activity time
5 mins
30 mins
80 mins
Total Time
Total Time
5 mins
30 mins
80 mins
55 mins
170 mins

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
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.
MAJU
Page 92

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
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.1 Tools
Visual Studio 2008.
Setup visual studio and make a project named MultipleInheritance

MAJU
Page 93

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

MAJU
Page 94

6.3.2 Compilation
A sample output after running the program is shown below:
7. Practice Tasks
7.1 Practice Task 1
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
MAJU
Page 95
Class Administration has

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

o A parameterized constructor to receive five arguments to initialize inherited attributes from class
Employee
(Concerning employeeID, joiningYear, and jobTitle, only null value is allowed to set)
o Two functions i.e. setCourseID() and setCourseTitle()
Only an instance of class DeanHOD should be able to modify values for employeeID, designation of an
employee, ID and name of a particular course.
Implement all these classes and within the main function, create instances of all classes (except class Employee) and
test the described working of all these classes.
7.2 Outcomes
After completing this lab, student will be able to understand the implementation and design of Multi-level and
Multiple Inheritance in C++.
7.3 Testing
For Practice Task 1, while inspecting implementation of classes, lab instructor must ensure that student has
taken hold the concept of multi-level and multiple inheritance. Furthermore, it is required to check the
invocation of all functions with the created instances of all mentioned classes.
Practice Tasks
T1
Confirmation
Comments
Sr. No.
1
2
3
4
5
Task No
6
7.1
Description
Comments
Total Marks
MAJU
Marks
10
55
20
5
10
100
Page 96
10. Further Reading

10.1 Books
10.2 Slides

MAJU
Page 97

(LAB-11)
Function Overloading and Function Overriding

MAJU
Page 98
Lab 11 - Function Overloading and Function Overriding
Table of Contents
1.
Introduction
100
2.
100
3.
101
4.
Concept Map
101
5.
Homework before Lab
101
5.1
5.2
101
102
6.
7.

Practices from home
Procedure & Tools
102
6.1
6.2
6.3
102
102
102
Tools
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.
105
9.
Evaluation Criteria
105
10. Further Reading

10.1
10.2
105
Books
Slides
105
105

MAJU
Page 99
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.
Lectures: 21, 22
o Pages: 188-193, 382-392
MAJU
Page 100

Task No.
6.2
6.3
7
Activity Name
Walk-through Tasks
Practice tasks
Evaluation Task
Activity time
5 mins
30 mins
50 mins for task 1
30 mins for task 2
Total Time
Total Time
5 mins
30 mins
80 mins
55 mins
170 mins

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.


MAJU
Page 101

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
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.1 Tools
Visual Studio 2008.
Setup visual studio and make a project named FunctionOverloading
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:

MAJU
Page 102
Figure 1: Function Overloading
Figure 2: Main( ) function for Figure 1

MAJU
Page 103
6.3.2 Compilation
7. Practice Tasks
7.1 Practice Task 1
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
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
MAJU
Page 104

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.
Practice Tasks
T1
T2
Confirmation
Comments
Sr. No.
1
2
3
4
5
Task No
6
7.1
Description
Comments
Total Marks
Marks
10
55
20
5
10
100
10. Further Reading

10.1 Books
10.2 Slides
MAJU
Page 105

(LAB-12)
Polymorphism in Object Oriented Programming

MAJU
Page 106
Lab 12 - Polymorphism in Object Oriented Programming
Table of Contents
1.
Introduction
108
2.
110
3.
110
4.
Concept Map
110
5.
Homework before Lab
110
5.1
5.2
110
111
6.
7.

Practices from home
Procedure & Tools
111
6.1
6.2
6.3
111
111
111
Tools
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.
114
9.
Evaluation Criteria
114
10. Further Reading

10.1
10.2
114
Books
Slides
114
114

MAJU
Page 107
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.
MAJU
Page 108
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).
Lectures: 23, 24, 25, 26

o Pages: 503- 520
MAJU
Page 109

Task No.
6.2
6.3
7
8

Activity Name
Activity time
5 mins
Walk-through Tasks
30 mins
Practice tasks
80 mins for two task
Evaluation Task
Total Time
Total Time
5 mins
30 mins
80 mins
55 mins
170 mins

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.

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
MAJU
Page 110

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.
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.1 Tools
Visual Studio 2008.
Setup visual studio and make a project named Polymorphism

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:

MAJU
Page 111
Figure 1: Polymorphism

MAJU
Page 112
6.3.2 Compilation
7. Practice Tasks
7.1 Practice Task 1
Consider an abstract class Computer having
Two fields (i.e. companyName, price) and
A single function named show()
A class named Desktop inherits Computer class and adds fields representing
color, monitor size, and processor type and
Override function named show() to display values of its all attributes
A class named Laptop inherits Computer class and adds fields representing
color, size, weight, and processor type and
Override function named show() to display values of its all attributes
Write a main() function that instantiates objects of derived classes to access respective show() function using
dynamic binding.
7.2 Practice Task 2
Create a class named Person, which contains
A pure virtual function named print()
Two data fields i.e. personName and age
A class named Patient inherits Person class, which contains

Two data fields i.e. diseaseType and recommendedMedicine
Overridden function print() to display all details relevant to a patient
A class named MedicarePatient inherited from class Patient, which holds
A data field representing the name of the hospital
A data filed representing the name of the ward
A data field representing room number
Overridden function print() to display all details relevant to a patient

MAJU
Page 113
In the main function, create instances of derived classes to access respective print() function using dynamic
binding.
7.3 Outcomes
After completing this lab, student will be able to implement the concepts of virtual functions, dynamic binding, pure
virtual function, and abstract classes.
7.4 Testing
For Practice Task 1, it is required to check the assignment of derived class instances to base class pointer.
Moreover, (while considering the dynamic binding) test the invocation of respective show() function.
For Practice Task 2, it is required to check the assignment of derived class instances to base class pointer.
Moreover, (while considering the dynamic binding) test the invocation of respective print() function.
Practice Tasks
T1
T2
Confirmation
Comments
Sr. No.
1
2
3
4
5
Task No
6
7.1
Description
Comments
Total Marks
Marks
10
55
20
5
10
100
10. Further Reading

10.1 Books
10.2 Slides

MAJU
Page 114

(LAB-13)
Relationships in Object Oriented Programming

MAJU
Page 115
Lab 13 - Relationships in Object Oriented Programming
Table of Contents
1.
Introduction
117
2.
118
3.
118
4.
Concept Map
118
5.
Homework before Lab
119
5.1
5.2
119
119
6.
7.

Practices from home
Procedure & Tools
119
6.1
6.2
6.3
119
119
120
Tools
Walkthrough Task
Practice Tasks
121
7.1
7.2
7.3
121
122
122
Practice Task 1
Outcomes
Testing
8.
122
9.
Evaluation Criteria
122
10. Further Reading

10.1
10.2
122
Books
Slides
122
122

MAJU
Page 116
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.
Lectures: 27, 28
o Pages: 414- 420

MAJU
Page 117

Task No.
6.2
6.3
7
8
Activity Name
Walk-through Tasks
Practice tasks
Evaluation Task
Activity time
5 mins
30 mins
80 mins for assigned task
Total Time
Total Time
5 mins
30 mins
80 mins
55 mins
170 mins

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.

MAJU
Page 118

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
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.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.1 Tools
Visual Studio 2008.
Setup visual studio and make a project named RelationshipExample
MAJU
Page 119

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

MAJU
Page 120
6.3.2 Compilation
7. Practice Tasks
7.1 Practice Task 1
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 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
MAJU
Page 121
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.
Practice Tasks
T1
Confirmation
Comments
Sr. No.
1
2
3
4
5
Task No
6
7.1
Description
Comments
Total Marks
Marks
10
55
20
5
10
100
10. Further Reading

10.1 Books
10.2 Slides

MAJU
Page 122

(LAB-14)
Function and Class Templates

MAJU
Page 123
Lab 14 - Function and Class Templates
Table of Contents
1.
Introduction
125
2.
126
3.
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
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.
129
9.
Evaluation Criteria
129
10. Further Reading

10.1
10.2
130
Books
Slides
130
130

MAJU
Page 124
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.
Lectures: 29, 30, 31

o Pages: 682- 703
MAJU
Page 125

Task No.
6.2
6.3
7
Activity Name
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
Total Time
Total Time
5 mins
30 mins
90 mins
45 mins
170 mins

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

MAJU
Page 126
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.1 Tools
Visual Studio 2008.
Setup visual studio and make a project named TemplateExample

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

MAJU
Page 127
6.3.2 Compilation
7. Practice Tasks
7.1 Practice Task 1

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

MAJU
Page 128
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.
Practice Tasks
T1
T2
T3
Confirmation
Comments
Sr. No.
1
2
3
4
5
Task No
6
7.1
Description
Comments
Total Marks
MAJU
Marks
10
55
20
5
10
100
Page 129
10. Further Reading

10.1 Books
10.2 Slides

MAJU
Page 130

(LAB-15)
Exception Handling

MAJU
Page 131
Lab 15 - Exception Handling
Table of Contents
1.
Introduction
133
2.
133
3.
134
4.
Concept Map
134
5.
Homework before Lab
134
5.1
5.2
134
135
6.
7.

Practices from Home
Procedure & Tools
135
Tools
6.1
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.
138
9.
Evaluation Criteria
138
10. Further Reading

10.1
10.2
138
Books
Slides
138
138

MAJU
Page 132
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 }
Lecture: 32
o Pages: 703 - 720

Task No.
6.2
6.3
7
8
Activity Name
Walk-through Tasks
Practice tasks
Evaluation Task
Activity time
5 mins
25 mins
30 mins for each task
Total Time

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

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.

Draw class diagrams of the following task. You are required to bring this design with you and submit to your
lab instructor.
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.

MAJU
Page 134

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

Tools
Visual Studio 2008.
Setup visual studio and make a project named ExceptionHandling

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:

MAJU
Page 135
Figure 1: Exception Code

6.3.2 Compilation

MAJU
Page 136
7. Practice Tasks
7.1 Practice Task 1
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
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
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.

MAJU
Page 137
7.5 Testing
Lab instructor must consider the following:
For Practice Task 1, test the exception generation of inner class type and its handling in the main()
function.
For Practice Task 2, test that exceptions generated/thrown in insert and delete functions must be handled
within the main().
For Practice Task 3, test the working of exception handling mechanism with single try block having
multiple associated catch blocks to handle a relevant thrown exception message.
Practice Tasks
T1
T2
T3
Confirmation
Comments
Sr. No.
1
2
3
4
5
Task No
6
7.1
Description
Comments
Total Marks
Marks
10
55
20
5
10
100
10. Further Reading

10.1 Books
10.2 Slides

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

MAJU
Page 139
Annexure B
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.

MAJU
Page 140
This page intentionally left blank
Mohammad Ali Jinnah University

Islamabad

Ooplabmanual 150412132629 Conversion Gate01 PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Ooplabmanual 150412132629 Conversion Gate01 PDF

Загружено:

Авторское право:

Доступные форматы

Mohammad Ali Jinnah University

DEPARTMENT OF COMPUTER SCIENCE

Lab Course Development Team

Supervision and Coordination

Mr. Hasan Tahir Butt

Mr. Faisal Shahzad

Lab 1 Functions and Pointers Recap

Lab 2 Introduction to Classes and Objects

Lab 3 Access Specifiers, Constructors and Destructors

Lab 4 Constructor Overloading and Copy Constructors

Lab 5 Shallow Copy/ Deep Copy and Working with arrays

Lab 6 Friend Functions and Friend Classes

Lab 7 Introduction to Operator Overloading

Lab 8 Inheritance in Object Oriented Programming

Lab 9 The Protected Access Specifier and Types of Inheritance

Lab 10 Multi-level and Multiple Inheritance

Lab 11 Function Overloading and Function Overriding

Lab 12 Polymorphism in Object Oriented Programming

Lab 13 Relationship in Object Oriented Programming

Lab 14 Function and Class Templates

Lab 15 Exception Handling

Annexure A Course Outline

Annexure B Good Programming Practices

Lab Manual for Object Oriented Programming

Department of Computer Science,

Lab 1 - Functions and Pointers - Recap

Activity Time boxing

Objective of the Experiment

Reusability/ Modularity of Code

Home Work Before Lab

Problem Solution Modelling

Procedure & Tools

Evaluation Task (Unseen)

Department of Computer Science,

Lab 1 - Functions and Pointers - Recap

Lab 01: Functions and Pointers - Recap

Relevant Lecture Material

2. Activity Time boxing

Table 1: Activity Time Boxing

3. Objective of the Experiment

Department of Computer Science,

Lab 1 - Functions and Pointers - Recap

Lab 1 - Functions and Pointers - Recap

Lab 1 - Functions and Pointers - Recap

Department of Computer Science,

Lab 1 - Functions and Pointers - Recap

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

5. Home Work Before Lab

Lab 1 - Functions and Pointers - Recap

5.1.1 Problem description

6. Procedure & Tools

[Expected time = 5 mins]

6.3 Walkthrough Task

Department of Computer Science,

Lab 1 - Functions and Pointers - Recap

6.3.1 Writing Code

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

Department of Computer Science,

Lab 1 - Functions and Pointers - Recap

6.3.3 Executing the Program

Figure 2: Final output of FindAverage program.

7.1 Practice Task 1

Lab 1 - Functions and Pointers - Recap