object oriented programming lab manual

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 1

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 learning’s and

experiments. Each lab has a detailed walkthrough task which provides a problem statement

and its programmable solution to the students. The students can raise queries about the code

provided and the lab instructor will guide the students on how the solution has been designed.

Thereafter predefined practice questions have been presented such that each question has a

fix duration and grade. Students are graded upon their accomplishments in these practice

tasks. At the end of the lab the lab instructor will assign an unseen task to the students. This

unseen task contains all the concepts taught in the lab. These unseen tasks have a higher level

of complexity and generally have a greater gain in terms of marks.

What sets these labs apart is the fact that a clear grading criteria has been defined for

each lab. Students are aware of the grading criteria and are expected to meet the requirements

for successful completion of each lab.

L

Department of Computer Science,

MAJU

Page 1

Lab Manual for Object Oriented Programming (LAB-01)

Functions and Pointers - Recap

Lab 1 - Functions and Pointers - Recap


MAJU

Page 2

Table of Contents

1. Introduction 3

2. Activity Time boxing 3

3. Objective of the Experiment 3

4. Concept Map 4

4.1 Reusability/ Modularity of Code 4 4.2 Function Prototype and Function Definition 4 4.3 Function Arguments and Parameters 4 4.4 Returning a Value from a Function 5 4.5 Pass by Value and Pass by Reference 6 4.6 Pointers 6

5. Home Work Before Lab 7

5.1 Problem Solution Modelling 7 5.2 Practices from home 8

6. Procedure & Tools 8

6.1 Tools 8 6.2 Setting-up Visual Studio 2008 8 6.3 Walkthrough Task 8

7. Practice Tasks 10

7.1 Practice Task 1 10 7.2 Practice Task 2 10 7.3 Practice Task 3 10 7.4 Practice Task 4 10 7.5 Outcomes 10 7.6 Testing 11

8. Evaluation Task (Unseen) 11

9. Evaluation criteria 11

10. Further Reading 12

10.1 Books 12 10.2 Slides 12



MAJU

Page 3

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

Table 1: Activity Time Boxing

Task No. Activity Name Activity time Total Time

5.1 Evaluation of Design 15 mins 15 mins

6.2 Setting-up Visual Studio 5 mins 5 mins

6.3 Walkthrough Task 25 mins 25 mins

7 Practice tasks 15 + 15 + 20 + 35 (mins) 85 mins

8 Evaluation Task 40 min for two task 50 mins

Total Time 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 4

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 5

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 6

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 7

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

b



MAJU

Page 8

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.

6. Procedure & Tools

6.1 Tools

Visual Studio 2008.

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

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

6.3 Walkthrough Task [Expected time = 25 mins]

Write a C++ program that creates (in main function) an array of type int having 6 elements. Now write a function

called arr_avg( ) that will find the average of all the elements of the array. This function should return the average

back to the main( ) function. Also write another function called arr_display() that will display all the elements of the

array.

h

r



MAJU

Page 9

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 10

6.3.3 Executing the Program

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

Figure 2: Final output of FindAverage program.

7. Practice Tasks

This section will provide more practice exercises which you need to finish during the lab. You need to finish the

tasks in the required time. When you finish them, put these tasks in the following folder:

\\dataserver\assignments$\OOP\Lab01

7.1 Practice Task 1 [Expected time = 15 mins]

Write a program that contains a function to find twenty odd numbers starting from a particular number provided by a

user.


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.


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.


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.



MAJU

Page 11

7.6 Testing

Test Cases for Practice Task-1

Sample Inputs Sample Outputs

Number: 3

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



Base: 4

Exponent: 11

Result = 4194304

Check that the function works with pass by reference



Array having all entries 1

Sum = 20

Check that pointers have been used to iterate the array



Number: -5

Invalid Input

Number: 5.5

Invalid Input

Number: 5

120

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

Practice Tasks Confirmation Comments

T1

T2

T3

T4

8. Evaluation Task (Unseen) [Expected time = 40 mins]

The lab instructor will assign you unseen tasks depending upon the progress of the students.

9. Evaluation criteria

The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is assigned

marks which will be evaluated by the instructor in the lab depending on the accomplishment of the assigned tasks.



MAJU

Page 12

Table 3: Evaluation of the Lab

Sr.

No.

Task No Description Marks

1 4.1 Problem Modelling 20

2 6 Procedures and Tools 5

3 7.1 Practice task 1 with Testing 10




7 8 Evaluation Tasks (Unseen) 20

8 Good Programming

Practices

10

Total Marks 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 13


Introduction to Classes and Objects

Lab 2 - Introduction to Classes and Objects


MAJU

Page 14

Table of Contents

1. Introduction 15



4. Concept Map 16

4.1 Object 16 4.2 Data Members 16 4.3 Member Functions 16 4.4 Constant Member Functions 17 4.5 Class 17 4.6 Encapsulation 17


5.1 Problem Solution Modelling 18 5.2 Practices from home 18




7.1 Practice Task 1 20 7.2 Practice Task 2 20 7.3 Practice Task 3 20 7.4 Outcomes 20 7.5 Testing 20


9. Evaluation Criteria 21


10.1 Books 21 10.2 Slides 21



MAJU

Page 15

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






6.3 Walkthrough Task 30 mins 25 mins

7 Practice tasks 25 + 25 + 30 (mins) 80 mins

8 Evaluation Task 45 min 45 mins




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 16

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

{

}

Amna

Highlight

Amna

Highlight

Amna

Highlight



MAJU

Page 17

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.

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.


class myclass

{

int datamember;

void memberfun (int)

{

...

}

}; //Semicolon is necessary

void main( )

{

}


class myclass;

void main( )

{

}

class myclass

{

int datamember;

void memberfun (int)

{

...

}

}; //Semicolon is necessary

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight



MAJU

Page 18


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 19

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 20

7. Practice Tasks





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.


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.


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



Set the following values

Brand = DELL

Model = 1565D

Serial = 123456

Colour = Silver

Price = 64500.5

Processor = 2.8

RAM = 2

Screen = 15.6

Then Modify the RAM to 3

Brand = DELL

Model = 1565D

Serial = 123456

Colour = Silver

Price = 64500.5

Processor = 2.8

RAM = 3

Screen = 15.6



Length: 4

width: 10

Length = 5

Width = 11

Area = 55



MAJU

Page 21

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



Number: -5

Invalid Input

Number: 5.5

Invalid Input

Number: 5

Number = 5

Factorial = 120

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


T1

T2

T3

8. Evaluation Task (Unseen) [Expected time = 45 Minutes]

The lab instructor will assign you an unseen task depending upon the progress of the students.

9. Evaluation Criteria




Sr.

No.








7 Good Programming

Practices

10

Total Marks 80

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 22


Access Specifiers, Constructors and Destructors

Lab 3 - Access Specifiers, Constructors and Destructors


MAJU

Page 23

Table of Contents

1. Introduction 24



4. Concept Map 25

4.1 Access Specifiers – Public and Private Access 25 4.2 Constructors 25 4.3 Destructors 26


5.1 Practices from home 27




7.1 Practice Task 1 29 7.2 Outcomes 30 7.3 Testing 30




10.1 Books 31 10.2 Slides 31



MAJU

Page 24

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






6.3 Walkthrough Tasks 40 mins 40 mins

7 Practice tasks 60 mins 60 mins

8 Evaluation Task 55 mins 45 mins




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 25

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.

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.


class myclass

{

private:

int datamember; //Private data member

public:

int memberfun(int); // public member function

};

int myclass :: memberfun (int x) // This function is still public

because its prototype is public

{

datamember=x;

}

void main( )

{

myclass obj;

myclass::datamember=10; //Syntax Error: private member

obj.memberfun(10);

}

Amna

Highlight

Amna

Highlight

Amna

Highlight



MAJU

Page 26

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.

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:


public:

myclass( ); //Class constructor

{

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

}

};

void main( )

{

myclass obj;

}


class myclass

{

private:


public:

myclass( ); //Class constructor

{

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

}

~myclass( ); //Class constructor

{

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

}

};

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight



MAJU

Page 27



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.


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.

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( );

}



MAJU

Page 28

6.3.1 Writing Code

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

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

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( );

}



MAJU

Page 29

6.3.2 Compilation





Figure 2: Final output of pizza program.

7. Practice Tasks





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 30

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



Flavour = chocolate

Wafer required = yes

Number of scoops = 3

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


T1

8. Evaluation Task (Unseen) [Expected time = 45 Mins]




MAJU

Page 31





Sr.

No.






5 Good Programming

Practices

10

Total Marks 90

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 32


Constructor Overloading and Copy Constructors

Lab 4 - Constructor Overloading and Copy Constructors


MAJU

Page 33

Table of Contents

1. Introduction 34



4. Concept Map 34

4.1 Function Overloading 34 4.2 Constructor Overloading – Parameterized and Nullary Constructors 35 4.3 Copy Constructors 35


5.1 Practices from home 36




7.1 Practice Task 1 38 7.2 Practice Task 2 39 7.3 Outcomes 39 7.4 Testing 39




10.1 Books 40 10.2 Slides 40



MAJU

Page 34

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







7 Practice tasks 40 + 10 (mins) 50 mins





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

Amna

Highlight



MAJU

Page 35

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.

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

class example

{

private:

int one;

int two;

float three;

public:

example( ) //Nullary constructor

{

...

}

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

parameterized ->1

{

...

}

example (int on, float th, int tw) //Another overloaded Constructor

: Parameterized ->2

{

...

}

};

int main()

{

example obj; //Creation through nullary constru

example obj2(1, 2, 3.3); //Creation through first parameterized constru

example obj3(1, 3.3, 2); //Creation through Second parameterized constru

return 0;

}

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight



MAJU

Page 36

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:

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight



MAJU

Page 37

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

copy constructor being used

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;

}



MAJU

Page 38

6.3.2 Compilation





Figure 2: Final output of student program.

7. Practice Tasks





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.



MAJU

Page 39


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



Using Nullary constructor

Length = 48

Width = 30

Your LCD purchase details are:

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

Width = 30.5


Length = 48

Width=30

Price=80291.25



Initialize only one of the objects and use it for

copying values into another object by using the

copy constructor

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


T1

T2

8. Evaluation Task (Unseen) [Expected time = 55 Mins]




MAJU

Page 40





Sr.

No.







6 Good Programming

Practices

10

Total Marks 100

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 41


Shallow Copy / Deep Copy

Working with Arrays

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


MAJU

Page 42

Table of Contents

1. Introduction 43



4. Concept Map 43

4.1 Creating a customized copy constructor 43 4.2 Shallow Copy Constructor 44 4.3 Deep Copy Constructor 45 4.4 Working with Arrays 46


5.1 Practices from Home 47








10.1 Books 51 10.2 Slides 51



MAJU

Page 43

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







7 Practice tasks 50 + 15 (mins) 65 mins





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 44

There may be other numerous reasons why you might want to create a customized copy constructor. Before you

begin you must familiarize yourself with the syntax of a copy constructor. A copy constructor always receives an

object as a parameter and hence we can extract the data from the parameterized object and place the data in the

newly created object. Presented below are the two syntax for copy constructors:

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

called MyClass

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

class called Myclass

In the above prototypes the object which will be copied is called “other”. By writing the const keyword a copy of an

object can be created without any change to the inherent data members. Although only some of the data members

can be copied.

4.2 Shallow Copy Constructor

A shallow copy constructor is a copying function that does a member by member copy of one object to another. The

copy constructor provided by default is a shallow copy constructor. If a class does not have any dynamic members

then only a shallow copy constructor is needed.

Consider another case in which you want to create a partial copy of an object i.e. you only want to copy some of the

static data members then we need the help of a shallow copy constructor.

class example

{

private:

int a;

int b;

public:

example (example & parame) //shallow copy constructor

{

a=parame.a;

b=parame.b;

}

void showall( )

{

cout<<"\na="<<a;

cout<<"\nb="<<b;

}

example( ) //Simple constructor

{

a=10;

b=20;

}

};

int main()

{

example obj1;

example obj2(obj1);

obj1.showall();

obj2.showall();

return 0;

}

Amna

Highlight

Amna

Highlight

Amna

Highlight



MAJU

Page 45

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.

(a)

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

Object 1

Memory

Copy of

Object 1

Object 1

Memory

Copy of

Object 1

class example

{

private:

char *str;

int len;

public:

example( ); // one normal constructor

example(char *s); // another normal constructor

example(const example &st) //Deep copy constructor

{

len = st.len;

str = new char [len + 1];

strcpy(str, st.str);

}

// other stuff

};

Amna

Highlight



MAJU

Page 46

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.

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.

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

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

};

class example

{

private:

float *a; //Dynamic array as a data member

public:

example() // normal constructor

{

a=new float[10]; //size can be passed from main to constru


{


}

}

// other stuff

};



MAJU

Page 47

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.



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.

class example

{

private:

float *a; //Dynamic array as a data member

public:

example(int size)

{

a=new float[size]; //The size is passed from the main

to the constructor


{


}

}

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;

}



MAJU

Page 48


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:

Figure 1: The english class demonstrate

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

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;

}



MAJU

Page 49

6.3.2 Compilation





Figure 2: Final output of “english” class

7. Practice Tasks





Lamborghini is an international luxury sports car developer stationed in Italy. The company has a reputation for

producing cars that are extremely expensive, powerful and rare. Lamborghini has developed a brand new model

called the Diablo. The company produces a very limited number of Diablo’s each year. The company is producing

the Diablo in only one colour called the “Hot Red”.

When the company has produced a Diablo, the car has a number of attributes like colour, cubic capacity, number of

seats, year of manufacture, engine number, frame number and owner name. Out of these attributes the attributes that

remain the same for all Diablo’s being produced are colour, cubic capacity and number of seats.

Suppose you are working on a system specially designed for the Lamborghini Diablo. 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.


Your task is to create a class that contains an integer pointer data member. Create a single object named “one” in the



MAJU

Page 50

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



Colour = Hot Red

Owner = Ali Raza

Year of manufacture = 2013

Seats = 2

Cubic Capacity = 5700

Engine number = 123456

Frame number = 987654

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 =



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

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


T1

T2








MAJU

Page 51


Sr.

No.







6 Good Programming

Practices

10

Total Marks 100

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 52


Friend Functions and Friend Classes

Lab 6 - Friend Functions and Friend Classes


MAJU

Page 53

Table of Contents

1. Introduction 54



4. Concept Map 54

4.1 Friend Functions 54 4.2 Friend Classes 56










10.1 Books 60 10.2 Slides 60



MAJU

Page 54

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







7 Practice tasks 25+25+30 (mins) 80 mins





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.

Amna

Highlight



MAJU

Page 55

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:

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.

class second; //Forward Declaration

class first

{

private:

int member1;

int membern;

public:

friend void fun( first , second ); //Friend function prototype

};

class second

{

private:

int mem1;

int mem2;

public:

friend void fun( first, second ); //Friend function prototype

};

void fun( first o1, second o2) //Note that friend is not written

{

cout<<o1.member1<<o1.membern;

cout<<o2.mem1<<o2.mem2;

}

void main( )

{

first obj1;

second obj2;

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

}

Amna

Highlight

Amna

Highlight



MAJU

Page 56

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.


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.

class first

{

private:

friend class second; //Declaration of friend class

int member1;

int membern;

public:

first()

{

member1=10;

member2=20;

}

};

class second

{

private:

int mem1;

int mem2;

public:

void fun( first o1) //Friend function prototype

{

cout<<o1.member1<<o1.membern;

cout<<mem1<<mem2;

}

};

void main( )

{

first obj1;

second obj2;

obj2.fun( obj1); //cannot call using obj1! Obj1 does not contain a

function called fun

}

Amna

Highlight



MAJU

Page 57


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 𝑆𝑛 =𝑛

2 𝑎1 + 𝑎𝑛 . Use a friend function to compute the sum of the series.

6.3.1 Writing Code

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

class series

{

friend class sum; //Friend class declaration

int first; //First number

int nterm; //Last number

int entries; //Total number of entries

int sumn; //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 58

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





As you know in mathematics the quadratic equation is a very popular 2nd

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

2𝑎 where 𝑎 ≠ 0

int main()

{

series obj1(6,96,31); //(first term, last term, total number of terms)

sum obj2;

obj2.series_sum(obj1);

display(obj1); //Call the friend function

system ("pause");

return 0;

}



MAJU

Page 59

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.


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


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



a =1;

b =2;

c =-3

proot= 1

nroot = -3



a=1

b=2

c=3

𝑎 + 𝑏 + 𝑐 2 =36

𝑎 − 𝑏 − 𝑐 2 = 16 Mean = 2



MAJU

Page 60



Create the following entries for 3x3 arrays

𝐴 = 1 2 34 5 67 8 9

𝐵 = 1 2 34 5 67 8 9

Results should be as follows.

𝐴 + 𝐵 = 2 4 68 10 12

14 16 18



T1

T2

T3







Sr.

No.








7 Good Programming

Practices

5

Total Marks 100

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 61


Introduction to Operator Overloading

Lab 7 – Introduction to Operator Overloading


MAJU

Page 62

Table of Contents

1. Introduction 63



4. Concept Map 63

4.1 Introduction to Operator Overloading 63 4.2 Which Operators Can Be Overloaded 64 4.3 Operator Overloading – General Rules 64 4.4 Operator Overloading – Syntax 64 4.5 Stream Insertion and Extraction Operators 65 4.6 The Assignment Operator and the Copy Constructor 66










10.1 Books 71 10.2 Slides 71



MAJU

Page 63

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







7 Practice tasks 25+25+20 (mins) 70 mins





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.

Amna

Highlight



MAJU

Page 64

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

{

. . . }

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight



MAJU

Page 65

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;

}

Amna

Highlight

Amna

Highlight



MAJU

Page 66

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.

Amna

Highlight



MAJU

Page 67

6.3.1 Writing Code

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



MAJU

Page 68

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

6.3.2 Compilation







MAJU

Page 69

Figure 2: Final output of toll class

7. Practice Tasks





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


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.


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.



MAJU

Page 70

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



obj1= 10

obj2= 20

obj3= 40

obj4= 20

obj5= 30

obj6= 20

Provide any value for fuel

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

The average distance covered is 23.33



obj1.numerator = 1

obj1.denominator = 2

obj2.numerator = 3

obj2.denominator = 2

Sum = obj1 + obj2 = 4

2

Difference = obj1- obj2 = -2

2

Product = obj1*obj2 = 3

4



Number = 9.5

First call the post increment

Then call the pre increment

After post increment result is 9.6

After pre increment result is 10.6

Check the overloading of stream insertion and extraction



T1

T2

T3



MAJU

Page 71







Sr.

No.








7 Good Programming

Practices

5

Total Marks 100

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 72

Lab Manual for Object-Oriented Programming (LAB-08)

Inheritance in Object Oriented Programming

Lab 8 - Inheritance in Object Oriented Programming


MAJU

Page 73

Table of Contents

1. Introduction 74

2. Activity Time Boxing 74


4. Concept Map 75

5. Homework before Lab 75

5.1 Problem Solution Modeling 75 5.2 Practices from Home 76








10.1 Books 79 10.2 Slides 79



MAJU

Page 74

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 class’s object instantiation, default/no-argument constructor for the base class(es) are

automatically called first and are followed by calling derived class’s constructors. If base class(es) is/are without

default/no-argument constructor, then it is must to call explicitly any base class’s constructor even if there is no need

to call a constructor.

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

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




6.3 Walk-through Tasks 30 mins 30 mins

7 Practice tasks 40 mins for each task 80 mins

8 Evaluation Task 55 min for all assigned task 55 mins

Total Time 170 mins

Amna

Highlight



MAJU

Page 75


After completing this lab, the student should be able to:

get basic understanding of inheritance concept in OOP

derive class(es) from other base class(es) through inheritance

understand the constructor and destructor chaining in inheritance hierarchy

know how to invoke the base class’s constructors within derived class(es)

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 76


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 class’s data fields

Two functions i.e. deposit(amount) to deposit certain amount and witdraw(amount) to withdraw certain

amount

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

In the main() function, create an object of both SavingAccount and CheckingAccount class. Moreover, test the

functionality of their respective deposit(amount) and withdraw(amount) functions while passing different amounts

as parameter.


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 77

.

Figure 1: Base and Derived Classes

Figure 2: Main function for classes of Figure 1

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


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



MAJU

Page 78

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.


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 79

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


T1

T2

8. Evaluation Task (Unseen) [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. Task No Description Marks


2 7.1 Practice tasks and Testing 55


4 Comments 5

5 Good Programming Practices 10

Total Time 100

10. Further Reading

10.1 Books

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

10.2 Slides




MAJU

Page 80


The protected Access Specifier and Types of Inheritance

Lab 9 - The Protected Access Specifier and Types of Inheritance


MAJU

Page 81

Table of Contents

1. Introduction 82



4. Concept Map 83










10.1 Books 88 10.2 Slides 88



MAJU

Page 82

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 class’s member functions are able to access class’s data fields having public or private

accessibility for all times. However, externally created object(s) can only access public data members of that class

and private data members are restricted to be accessed outside the class. For example, consider the following class:

class Examp

{

private:

int attribute;

public:

void show()

{

cout<<attribute;

}

};

Any externally created instance (e.g. Obj) of class Examp would not be able to access data member(s) directly while

using the dot (.) operator. Hence, in the main() function, the statement Obj.attribute is not legal but the statement

Obj.show() is legal.

It is sufficient to know about public and private access specifiers/modifiers in the absence of inheritance. However,

in case of inheritance, sometimes it is required to access data member(s) of base class in derived class(es) but not

outside these classes. In this situation, you must make access protected for that data member(s) rather than private or

public. Protected access will ensure access of data members only within inheritance hierarchy.

Another important use of access specifiers is their role in the inheritance process. Considering access specification in

C++, inheritance can be private, protected, or public. Each type of inheritance has specific rules to access base

class’s data member(s), which have been explained below.

Public Inheritance:

Syntax: class Student: public Person { };

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

become public/protected member(s) of derived class. However, private member(s) of base class are never accessible

from derived class directly.

Protected Inheritance:

Syntax: class Student: protected Person { };

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

become protected member(s) of derived class. However, private member(s) of base class are never accessible from

derived class directly.

Private Inheritance:

Syntax: class Student: private Person { };

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

become private member(s) of derived class.



MAJU

Page 83

Relevant Lecture Readings:

Lectures: 17, 18


o Pages: 372 - 428






7 Practice tasks 25 mins for task 1 and 2

35 mins for task 3

85 mins


Total Time 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 class’s 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 class’s

data member(s) that exists only within inheritance class hierarchy but not outside these classes.

C++ provides intermediate level of accessibility through protected access specifier. Data member(s) of a base class

with protected accessibility are only be directly accessible within base class and all of its derived classes but not in

other parts of the program. Nevertheless, you should be careful while making data field(s) protected. Use protected

access only where you think that derived classes will use base class data field(s). The access of protected data

members in the derived classes make them less secure than private data members.

Moreover, access specifiers also play their role in the inheritance process. Considering access specification in C++,

inheritance can be private, protected, or public. The effects of access specifiers in inheritance process on derived

class’s member(s) are different as illustrated in Table 2.

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

Access Specifier with Inherited class

Private Protected Public

Access Specifier with Data

Member in Base class

Private Inaccessible Inaccessible Inaccessible

Protected private Protected protected

Public private Private Private



MAJU

Page 84



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 85

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

A constructor with three arguments that constructs a point with three specified coordinate values

An accessor function, which returns the value of data field Z

A function named spaceDistance to return the distance between two points in the space

Implement both the classes and in the main() create two points with different dimensions and invoke appropriate

function to display the distance between these two points.

6. Procedure & Tools 6.1 Tools Visual Studio 2008.


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 86

Figure 2: Main function for Figure 1



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


7. Practice Tasks





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 87


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.


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 88



T1

T2

T3












4 Comments 5


Total Marks 100

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 89


Multi-level and Multiple Inheritance

Lab 10 - Multi-level and Multiple Inheritance


MAJU

Page 90

Table of Contents

1. Introduction 91



4. Concept Map 92


5.1 Problem Solution Modeling 93 5.2 Practices from home 93








10.1 Books 97 10.2 Slides 97



MAJU

Page 91

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 here

};

class Y

{


};

class Z: public X, public Y

{


};



MAJU

Page 92


Lectures: 19, 20


o Pages: 399- 412






7 Practice tasks 80 mins 80 mins


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

Student Employee

Academic Administration

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 93






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



Setup visual studio and make a project named “MultipleInheritance”



MAJU

Page 94


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 95




6.3.3 Executing the Program A sample output after running the program is shown below:


7. Practice Tasks





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 96

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.



T1












4 Comments 5


Total Marks 100



MAJU

Page 97

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 98


Function Overloading and Function Overriding

Lab 11 - Function Overloading and Function Overriding


MAJU

Page 99

Table of Contents

1. Introduction 100



4. Concept Map 101










10.1 Books 105 10.2 Slides 105



MAJU

Page 100

Lab 11: Function Overloading and Function Overriding

1. Introduction

Earlier in Lab-09, you have already studied that a sub/derived class is able to access all non-private data members

and member functions of the base/parent class. Moreover, besides inheriting attributes and behaviors from base

class(es), the derived class also contains its own data members and member functions.

Function overloading is the availability of various functions within a class that differ from each other in function

signature i.e. various functions share same name with different parameter types or number of parameters.

Inheritance is not necessarily required to overload functions within a program.

On the other hand, in function overriding, there must exists inheritance relationship between classes (i.e. base and

derived) and functions’ signature are also required to be same in both parent and child class(es). However, derived

class(es) redefine function(s) having signature similar to base class’s function(s).

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

elaborated:

class Base

{

protected:

void myFunc()

{

cout<<"Base Class’ Function";

}

};

class Derived: public Base

{

public:

void myFunc()

{

cout<<"Derived Class’ Function";

}

void myFunc(int a)

{

cout<<"Derived Class’ Function with Parameter Value" <<a;

}

};

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

Amna

Highlight

Amna

Highlight



MAJU

Page 101






7 Practice tasks 50 mins for task 1

30 mins for task 2

80 mins


Total Time 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 102


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.



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 103

Figure 1: Function Overloading

Figure 2: Main( ) function for Figure 1



MAJU

Page 104





7. Practice Tasks





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.


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 105

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.



T1

T2












4 Comments 5


Total Marks 100

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 106


Polymorphism in Object Oriented Programming

Lab 12 - Polymorphism in Object Oriented Programming


MAJU

Page 107

Table of Contents

1. Introduction 108



4. Concept Map 110




6.1 Tools 111 6.2 Setting-up Visual Studio 2008 111 6.3 Walk-through Task 111






10.1 Books 114 10.2 Slides 114



MAJU

Page 108

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 class‟s object. Following code provides an

example of polymorphism mechanism in C++.

class Base

{

public:

virtual void func()

{

cout<<”Base Class Function”;

}

};

class Derived: public Base

{

public:

void func()

{

cout<<”Derived Class Function”;

}

};

void main()

{

Base *bPtr;

Derived dev;

bPtr = dev;

bPtr->func();

}

Upon calling func() with bPtr, Derived class func() will be invoked and output would be “Derived Class

Function”. In the absence of virtual keyword, func() of base would be called each time. Hence, it can be concluded

that virtual keyword allow a pointer of base class to call appropriate function of any of its derived class to whom it

is referencing. In this way, each time a different function will be invoked with the same function call. With

polymorphism, compiler does not know which function to call at compile and thus appropriate function call is

deferred to runtime. At runtime, the type of object that a base class pointer is pointing is recognized to call proper

function. This is known as dynamic or late binding.

Virtual keyword can also be used with destructors and classes. However, virtual keyword possesses different

meanings when used with destructor and classes as explained below.



MAJU

Page 109

Virtual Destructors:

In practice, it is always recommended to make the base class destructor as virtual. In the absence of virtual keyword

with base class destructor, upon deletion of any derived class‟s object only destructor of base class would be called.

Virtual Base Classes:

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

class Base

{

protected:

void func()

{ cout<<”A Base Class Function”; }

};

class Derived1: public Base{ };

class Derived2: public Base{ };

class Derived3: public Derived1, public Derived2

{ };

In the code above, both (Derived1 and Derived2) classes contain a copy of func(), which is inherited from class

Base. Upon the invocation of func() with an object of Derived3 class, compiler would be unable to decide which

copy to use.

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

would be implemented as

class Base

{

protected:

void func()

{ cout<<”A Base Class Function”; }

};

class Derived1: virtual public Base{ };

class Derived2: virtual public Base{ };

class Derived3: public Derived1, public Derived2

{ };

Pure Virtual Function and Abstract Class:

You may have observed that with any class hierarchy in OOP, derived class(es) become more specific version of

base class(es) which are more general or abstract. It is sometime good in practice to make the base class as abstract

class that contains only the most common features of all of its derived classes. In C++, you can make base class an

abstract class by declaring a pure virtual function in it. The syntax is given as under:

class Base

{

protected:

virtual void func() = 0;

};

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


Lectures: 23, 24, 25, 26


o Pages: 503- 520



MAJU

Page 110






7 Practice tasks 80 mins for two task 80 mins


Total Time 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 111


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 112

Figure 1: Polymorphism




MAJU

Page 113





7. Practice Tasks





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.


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 114

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.



T1

T2












4 Comments 5


Total Marks 100

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 115


Relationships in Object Oriented Programming

Lab 13 - Relationships in Object Oriented Programming


MAJU

Page 116

Table of Contents

1. Introduction 117



4. Concept Map 118










10.1 Books 122 10.2 Slides 122



MAJU

Page 117

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

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight

Amna

Highlight



MAJU

Page 118






7 Practice tasks 80 mins for assigned task 80 mins


Total Time 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 119






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.



Setup visual studio and make a project named “RelationshipExample”



MAJU

Page 120


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 121





7. Practice Tasks





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 122

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.



T1












4 Comments 5


Total Marks 100

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 123


Function and Class Templates

Lab 14 - Function and Class Templates


MAJU

Page 124

Table of Contents

1. Introduction 125



4. Concept Map 126










10.1 Books 130 10.2 Slides 130



MAJU

Page 125

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>

T functionName(T value)

{

return value * value;

}

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

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

functionName(var1);

functionName(var2);

functionName(var3);

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

template<class T> or template<typename T>

class TemplateExample

{

private:

T var;

public:

TemplateExample(T var)

{

this.var = var;

}

};

In order to create two objects containing data members of different data type, you have to write:

TemplateExample<int> TE1;

TemplateExample<double> TE2;

It is clear from above examples that prior to coding a function template or class template you have to provide

template definition statement starting with the keyword template. This template reserved word in C++ informs the

compiler that programmer is going to define a function or class template. Further, the variable with reserved word

class or typename within angle brackets (< >) is known as the template argument. This template argument is

replaced with specific data type with each function call statement.


Lectures: 29, 30, 31


o Pages: 682- 703



MAJU

Page 126






7 Practice tasks 25 mins each for task 1 and 2

40 mins for task 3

90 mins


Total Time 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 127

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.



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 128





7. Practice Tasks





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.


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.


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 129

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


int arr = {101, 29, 40, 90,45}

minimun(arr, 5)

29

double arr = {10.11, 2.99, 1.40, 90.99}

minimun(arr, 4)

1.40

Test cases for Practice Lab 2


area(5.0)

area(5)

area(20.0,10.0)

area(20,10)

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.



T1

T2

T3












4 Comments 5


Total Marks 100



MAJU

Page 130

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 131


Exception Handling

Lab 15 - Exception Handling


MAJU

Page 132

Table of Contents

1. Introduction 133



4. Concept Map 134




Tools 135 6.1 Setting-up Visual Studio 2008 135 6.2 Walkthrough Task 135






10.1 Books 138 10.2 Slides 138



MAJU

Page 133

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






7 Practice tasks 30 mins for each task 90 mins


Total Time 170 Mins



MAJU

Page 134



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 135


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 136

Figure 1: Exception Code







MAJU

Page 137


7. Practice Tasks





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.


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.


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 138

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.



T1

T2

T3












4 Comments 5


Total Marks 100

10. Further Reading

10.1 Books


10.2 Slides




MAJU

Page 139

Annexure – A Course Outline

Week# Lecture# Topic

1

Lecture 1 - Introduction of the Course

- Overview of Structured Programming in C++

Lecture 2 - Function Revision (Call by Value, Call by Reference, Call by Pointer)

- Pointer Revision

2

Lecture 3 - Object-Oriented Concepts (Introduction to Classes and Objects)

Lecture 4 - Data Members and Member Functions

- Constant Member Functions

3

Lecture 5 - Use of Access Specifiers (public, private) - (Scope of class members)

Lecture 6 - Concept of Constructor and Object Instantiation

- Importance of Destructor

4 Lecture 7

- Constructor Overloading

(No-argument Constructor, Parameterized Constructor)

Lecture 8 - Introduction to copy constructors

5

Lecture 9 - Shallow Copy and Deep Copy

Lecture 10 - Array as class data members (Initializing array with constructors)

- Static and Dynamic Arrays, Array of Objects

6 Lecture 11 - Friend Functions

Lecture 12 - Friend Classes

7

Lecture 13 - Operator Overloading - (Unary and Binary Operator Overloading)

Lecture 14

- Assignment Operator Overloading

(Difference between Assignment Operator and Copy Constructor)

- Stream Insertion and Extraction Operator Overloading

8 Lecture 15 - Introduction to Inheritance in OOP

Lecture 16 - Constructor and Destructor Chaining

9 Lecture 17 - The protected access specifier

Lecture 18 - Types of Inheritance

10 Lecture 19 - Class Hierarchies (Multi-level Inheritance)

Lecture 20 - C++ Multiple Inheritance

11

Lecture 21 - Function Overloading and Function Overriding

Lecture 22 - Object as argument to the Function

- Pointer to Objects

12 Lecture 23 - Introduction to Polymorphism in OOP

Lecture 24 - Virtual Functions

13

Lecture 25 - Pure Virtual Functions and Abstract Base Classes

Lecture 26 - Virtual Inheritance

(The Diamond Problem and its Solution)

14 Lecture 27 - Relationships in OOP - (Association, Aggregation, and Composition)

Lecture 28 - Life Cycle and Ownership of Objects

15 Lecture 29 - Function Templates

Lecture 30 - Class Template Specialization

16 Lecture 31 - Standard Template Libraries

Lecture 32 - Exception Handling


MAJU

Page 140

Annexure – B

Good Programming Practices

This section presents you some of the well known good programming practices. You will be evaluated based on

these practices in all your tasks.

Generic Programming Practices

Always use indentation. Your code should clearly state the start and end of the if-statements, loop-

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

This page intentionally left blank

Mohammad Ali Jinnah University

Islamabad