Department of Computer Science/ Software Engineering

Faculty of Computing, Capital University of Science and Technology

Lab Manual

Object Oriented Programming

(CS1141)

Fall 2023

1
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Contribution

The manual was last updated on 7th September, 23 by Dr. Umair Rafique.

2
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Table of Contents

Topic Page no.

Rubric for the evaluation of Lab Tasks 4
Course Learning Outcomes 5
Lab 1 – Selections, Loops 6
LAB 2 - Functions, Pointers, and Structure 13
LAB 3 - Introduction to Classes and Objects 26
LAB 4 - Access Specifiers, Constructors and Destructors 36
LAB 5 - Constructor Overloading and Copy Constructors 45
LAB 6 - Shallow Copy / Deep Copy and Working with Arrays 55
LAB 7 - File Handling 65
LAB 8 - Inheritance Types 74
LAB 9 - Function Overloading Overriding 84
LAB 10 – Polymorphism 94
LAB 11 – Relationships 105
LAB 12 – Templates 114
LAB 13 - Static keyword 121
LAB 14 - Friend Functions and Friend Classes 131

3
 Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Rubric for the Evaluation of Lab Tasks

(a) PSYCHOMOTOR

Criteria Level 0 Level 1 Level 2 Level 3 Level 4 Total

(Max Marks) (0%) 0% ≤ S < 50% 51% ≤ S < 65% 66% ≤ S < 80% 81% ≤ S < 100% Score
(S)
Understanding of Don’t know Inadequate Brief understanding Adequate Complete
problem about understanding of the of the provided understanding of the understanding of
(20) problem provided problem in problem in practice provided problem in the provided
understanding practice task task practice task exists but problem in practice
missing some points task

Program Logic Don’t know Poor logic in Logic corrects to Correct logic but with Program Logic
(20) about the program some extent but minor mistakes completely correct
programming with major
logic mistakes
Program No task is Makes several Makes few critical Makes some non- Applies the
Implementation implemented critical errors in errors in syntax and critical errors in syntax procedural
(20) syntax and in in applying and in applying knowledge and
applying procedural procedural procedural knowledge syntax in perfect
knowledge knowledge ways
Program Program Program does not Program produces Program produces Program produces
Correctness totally produce correct answers or correct answers or correct answers or
(10) incorrect correct answers or appropriate results appropriate results for appropriate results
appropriate results for most inputs, but most inputs. for all inputs tested
for most inputs. contains
miscalculations in
some cases
Use of Software Don’t know Uses software tool, Uses software tool, Uses software tool, Uses software tool,
Tool about the tool with limited with some with considerable with a high degree
(10) competence competence competence of competence

Sub-Total Marks 80 Sub-Total Marks Obtained (PD)

(b) AFFECTIVE

Criteria Level 0 Level 1 Level 2 Level 3 Level 4 Total

(Max (0%) 0% ≤ S < 50% 51% ≤ S < 65% 66% ≤ S < 80% 81% ≤ S < 100% Score
Marks) (S)
Viva All answers Answered for less than Answered for 60% of the Answered for Answered for more
(20) are incorrect 40% of the questions questions. But incomplete 80% of the than 90% of the
indicating a lack of understanding of results is questions. Still questions correctly,
understanding of still need some good understanding
results evident improvements of results is
conveyed
Sub- 20 Sub-Total Marks Obtained (AD)
Total

4
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Course Learning Outcomes

1. To demonstrate small-medium level programs in terms of object-oriented programming
involving single/multiple objects. [3. Problem Analysis]
2. Design and implement object-oriented solutions for complex problems, making good use
of the features of the language such as inheritance, encapsulation, polymorphism, and
abstraction. [4. Design/Development of Solution]

5
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-01
Selections, Loops – Recap

6
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

1. Introduction
To solve some problems, we must make decisions based on the test of a true-false condition. If the condition
is true, we need to execute a set of statements; if the condition is false, we need to execute another set of
statements (or no statements). This process is referred to as selection.

Additionally, in most programs, we need to repeat lines of code. Repetition allows the program to iterate a
section of code multiple times. C++ provides three constructs for repeating a set of statements without
physically repeating them in the code: while statements, for statements, and do-while statements.

In this lab we will cover these two concepts.

Relevant Lecture Readings

• Lectures: 1
• Textbook: Ch 3, 7. Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.

2. Activity Time-boxing
Table 1: Activity Time Boxing

Task No. Activity Name Activity time Total Time

6.2 Setting-up Visual Studio 10 mins 10 mins
6.3 Walkthrough Task 30 mins 30 mins
7 Practice tasks 20 + 20 + 30 (mins) 70 mins
8 Evaluation Task 30 + 30 (mins) 60 mins
Total Time 170 Mins

3. Objective of the Experiment

After completing this lab, the student should be able to:
● Understand how we can make a one-way selection using the if statement.
● Understand how we can make a two-way selection using the if-else statement.
● Understand how we can make a multiway selection using the nested if-else statement.
● Show how complex decisions can be made by combining relational/equality expressions with
logical expressions.
● Understand the syntax of a while statement and its use in creating a counter-controlled or
event-controlled repetition.
● Understand how to initialize and update a counter in a counter-controlled repetition
statement.
● Understand the syntax of a for statement as a replacement for a counter-controlled while
statement.

7
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

4. Concept Map

4.1 Relational Expressions

Relational expressions use four relational operators to compare two values. Note that the result of (a <= b)
is true if a is equal to or if a is less than b; it is false if a is greater than b. Similarly, the result of (a >= b) is
true if a is greater than or equal to b; the result is false if a is less than b. The type of the left and the right
expression must be the same when the comparison is evaluated.

Figure 1: Relation and Equality Expressions

4.2 One-Way Selection: The if Statement

The most common structure for making decisions is one-way selection, which is accomplished in C++ by
the if statement. In this type of statement, we use an expression to test a condition. The program executes
the statement (or the set of statements) if the result of the test is true; it skips the statement (or the set of
statements) if the result is false. This type of selection is often referred to as one-way selection: to do a task
or not to do a task.

Figure 2: One-way selection

4.3 Two-Way Selection: if-else Statement

When the program reaches the if-else statement during execution, it first evaluates the Boolean expression.

8
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

If the value of this expression is true, the program executes statement1 and ignores statement2; otherwise,
the program executes statement2 and ignores statement1. Note that in each run, only one of the two
statements, statement1 or statement2, is executed but never both.

Figure 3: if-else Statement

4.4 THE while STATEMENT

The while statement is made of the reserved word while, followed by a Boolean expression (called the
condition) in parentheses, followed by a single statement, which is the body of the while statement. The
following shows the code that we normally see as a while statement.
while (condition)
{
statement-1;
...
statement-n;
}

4.5 THE for STATEMENT

It is particularly useful when we need counter-controlled iteration. It combines the three elements of a
loop—initialization, conditional test, and update—into the loop construct itself. The for statement is much
more compact than using a while statement for counter-controlled looping.

Figure 4: for statement

5. Homework
No homework task as this is the first lab.

9
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

6. Procedure & Tools

6.1 Tools
Visual Studio 2017.

6.2 Setting-up Visual Studio 2017 [Expected time = 10 mins]

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

6.3 Walk-through Task [Expected time = 30 mins]

In the source file created in the project “GCD” write following C++ code.

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

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:
\\fs\assignments$\OOP\Lab01.

10
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

7.1 Practice Task 1 [Expected time = 20 mins]

Write a program to calculate the weekly gross earnings for an employee. If the employee works more than
40 hours during the week, the overtime pay rate for the extra hours is 130 percent of the base pay rate. Take
“hours worked” and “hour rate” as input from the user.

7.2 Practice Task 2 [Expected time = 20 mins]

Print the integers from 1 to a limit in which the limit is given by the user.

7.3 Practice Task 3 [Expected time = 30 mins]

Write a program to print first 50 prime numbers. To test whether a number is prime, check whether it is
divisible by 2, 3, 4, up to number/2. If a divisor is found, the number is not a prime.

7.4 Testing
Test Cases for Practice Task-1

Sample Input Sample Output

Enter hours worked: 30 Regular pay = 660.00
Enter pay rate: 22.00 Over time pay = 0.00
Total pay = 660.00

Test Cases for Practice Task-2

Sample Input Sample Output

Enter the number of integers to print: 5 12345

Test Cases for Practice Task-3

Sample Input Sample Output

The first 50 prime numbers are
2 3 5 7 11 13 17 19 23 29
31 37 41 43 47 53 59 61 67 71
73 79 83 89 97 101 103 107 109 113
127 131 137 139 149 151 157 163 167 173
179 181 191 193 197 199 211 223 227 229

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

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

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

11
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

assigned the marks percentage which will be evaluated by the instructor in the lab whether the student has
finished the complete/partial task(s).

Table 2: Evaluation of the Lab

Sr. Task No Description Marks

No.
1 6 Procedures and Tools 10
2 7.1 Practice task 1 with Testing 20
3 7.2 Practice task 2 with Testing 20
4 7.3 Practice task 3 with Testing 20
5 8 Evaluation Tasks (Unseen) 20
6 Good Programming Practices 10
Total Marks 100

10. Further Readings

10.1 Book
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
\\fs\lectures$\

12
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-02
Functions, Pointers, and Structure – Recap

13
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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 Readings
● 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 Mins

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
● Understanding of structure

14
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

{
int c = a+b;
cout<< c;
}

15
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Now suppose we are calling the same function from within the main().
void main (){
int x=3, y=4;
addtwo(x, y);
}

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

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

16
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

17
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

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

18
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

4.7 Structures
Structure is the collection of variables of different types under a single name for better visualization of
problem. Arrays is also collection of data but arrays can hold data of only one type whereas structure can
hold data of one or more types.

4.7.1 How to define a structure in C++ programming?

The struct keyword defines a structure type followed by an identifier (name of the structure). Then inside
the curly braces, you can declare one or more members (declare variables inside curly braces) of that
structure. For example:

Here a structure person is defined which has three members: name, age and salary.

4.7.2 How to define a structure variable?

Once you declare a structure person as above. You can define a structure variable as: person bill;
Here, a structure variable bill is defined which is of type structure person.

4.7.3 How to access members of a structure?

The members of a structure variable are accessed using dot operator. Suppose, you want to access age of
structure variable bill and assign the value 50 to it. You can perform this task by using following code
below:

19
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

4.7.4 Structure Example

Output:

20
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

5. Homework before Lab

5.1 Problem solution modeling

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

Write pseudo-code for a program that will read number n and print the first n numbers in Fibonacci
sequence. Your task is to also perform checks on the number entered by the user as it should be positive
integer. This condition should also be incorporated in your pseudo-code.

5.2 Practices from home

5.2.1 Task 1
Every moving object possesses a kinetic energy due to its motion. Your task is to write a program to find
the kinetic energy of an object in motion if the mass and the velocity of that object is given. Write a function
to perform the calculation. Your task is to provide the mass and velocity as arguments to the function and
then display the kinetic energy without returning a value.

5.2.2 Task 2
Write a program that creates a function to find the area of a trapezium if the sides a, b and the height h of
the trapezium are provided. The function should return the value of area. The area of a trapezium is ½(a+b)h.
Consider the figure below for further clarification.

6. Procedure & Tools

6.1 Tools
Visual Studio 2017.

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

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

6.3 Walk-through Task [Expected time = 15 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

21
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

display all the elements of the array.

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 arrayIn 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
Write a program to find the power of a number if the base and exponent is provided in the main function.
Use pass by value mechanism to compute the power and return the results back to the main function then
display the result in main function.

6.3.3 Executing the Program

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

22
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Figure 4: 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:
\\fs\assignments$\OOP\Lab01.

7.1 Practice Task 1 [Expected time = 10 mins]

Write a program to find the greatest common factor if the two numbers are provided in the main function.
Use pass by value mechanism to compute the greatest common factor and return the result back to the main
function then display the result in the main function.

7.2 Practice Task 2 [Expected time = 10 mins]

Write a program to find the product of 2 power numbers if the base and the exponent of these numbers are
provided in the main function, also check that the base of both the power number are the same, as the
product of 2 power numbers can only be calculated if their base is the same. Use pass by reference
mechanism to compute the product of these power numbers then display the result in main function.
Note: Your function should not return a value.

7.3 Practice Task 3 [Expected time = 10 mins]

Create a structure course with some attributes i.e course_ID, course_title, credit_hrs etc.. Then Implement
following 5 functions (Known as CRUDS operations which means CREATE, READ, UPDATE, DELETE,
SEARCH operations):
1. addAStudent
2. updateAStudent
3. deleteAStudent
4. searchAndDisplayAStudent
5. displayAllstudents

After that, create an array of 5 courses in main function. Create a menu in main function to enable user to
select and perform the operations we created above. Program must not exit until and unless user wants to
do so.

23
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Sample Menu:
Main Menu
---------------

Press 1 to add a Course

Press 2 to update a Course
Press 3 to delete a Course
Press 4 to search and display a Course
Press 5 to display all Courses
Press e to exit the program

7.4 Out comes

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.

7.5 Testing
Test Cases for Practice Task-1

Sample Inputs Sample Outputs

1st Number : 12 Result = 4
2nd Number: 16
Check that the function works with pass by value

Test Cases for Practice Task-2

Sample Inputs Sample Outputs

1st Power Number : Result = 8
Base = 4
Exponent = 2
2nd Power Number:
Base = 4
Exponent = 6 Check that the function works with pass by reference

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

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

24
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

Table 2: Evaluation of the Lab

Sr. Task No Description Marks
No.
1 4.1 Problem Modelling 20
2 6 Procedures and Tools 5
3 7.1 Practice task 1 with Testing 10
4 7.2 Practice task 2 with Testing 10
5 7.3 Practice task 3 with Testing 10
6 7.4 Practice task 4 with Testing 15
7 8 Evaluation Tasks (Unseen) 20
8 Good Programming 10
Practices
Total Marks 100

10. Further Readings

10.1 Books
Text Book:
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
\\fs\lectures$\

25
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-03
Introduction to Classes and Objects

26
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

1. Introduction

The programming that you have understood in your computer programming course, allows you to design a
program by assembling a sequence of instructions. This is the way in which traditional programming works,
but now there is clear paradigm shift towards an object based approach. The new object oriented approach
allows you to model your program in a way in which objects, their relationships and the functions that they
operate are clearly visible to the programmer. Perhaps the greatest advantage of this approach is that it gives
an extended modular concept in which the interface is made public while the implementation details are
kept hidden.

This allows the program to grow in size without becoming too cumbersome. Previously, when a program
grew beyond a certain size it became almost impossible to understand and extend especially when the
programmer had forgotten the minor concepts constructing the program. Here, it should be understood and
acknowledged that programs are not disposable entities they have a life beyond what is normally expected.
Hence designing a program that can be easily extended, modified and interfaced with other systems is a
very important characteristic of any well written program. This lab has been designed to give in-depth
knowledge of how to make classes, objects and their interrelations. The concept map provides all the crucial
details that are required for the completion of this lab.
Relevant Lecture Readings:
a) Revise Lecture: No. 3 and 4
b) Text Book: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore
o Pages: 195-201

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 30 mins 25 mins
7 Practice tasks 25 + 25 + 30 (mins) 80 mins
8 Evaluation Task 45 min 45 mins
Total Time 170 Minutes

3. Objective of the Experiment

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

27
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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 behavior. For example, consider the example of a cat. A cat is has both a state and behavior. The state
of a cat is its attributes namely color, breed, gender, age, weight, height, etc. Whereas the behavior of a cat
is its sound, eating, sleeping, yawning, walk, etc. Hence a cat can be completely identified by its unique
characteristics and behaviors.

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 Function

Again referring to the concept of an object and the example of a cat. The cat had a number of behaviors or
things that a cat does. In programming these behaviors 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

};

28
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

int myclass :: memberfun (int x) // Note the scope resolution operator

{
... // Function body
}

void main( )
{

4.4 Constant Member Function

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 co0llection 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 is the
syntax for creating a class:

29
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

30
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

5. Homework before Lab

5.1 Problem solving 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 identifying an Android phone. You are
allowed to suppose the data members and the member functions of the class. Also create a single member
function that will display the entire class data members. You will be graded on the quality and clarity of
your design.

5.2 Practices for home

5.2.1 Task-1
Identify the data members and member functions for a submarine sandwich class. The class should have all
the relevant attributes and qualities required for a sandwich object. Try to be imaginative in your design.
For example consider various sauces, Mortadella, salads, cheese and other fillings etc.

6. Procedure & Tolls

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

6.3 Walkthrough Task [Expected time = 25 mins]

Write a program that creates a class called arc. The data members of the class are radius, angle and
arc_length of the arc is provided. Write three functions that set the respective values, and then write a single
constant function that will read the values.

6.3.1 Writing Code

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

31
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Figure 1: Class for creating an arc with its relevant data members

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

6.3.3 Executing the Program

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

32
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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:
\\fs\assignments$\OOP\Lab02

7.1 Practice Task 1 [Expected time = 25 mins]

Create a class Android_Device. The data members of the class are IMEIno (int), Type (String), Make
(String), Modelno (int), Memory(float), Operating_System(String). Then Implement member functions to:

1. Set the values of all data members.

2. Display the values of all data members

7.2 Practice Task 2 [Expected time = 25 mins]

Write a class called quadrilateral. Your task is to store the length of all the sides of the quadrilateral and the
value of the 2 opposite angles within the quadrilateral. Then implement member functions:

1. To compute the area of the quadrilateral.

2. To compute the parameter of the quadrilateral.
3. A constant function that will display the length of all the sides, the angles, the parameter of the
quadrilateral and area of the quadrilateral.
4. Create setter and getter methods.

Demonstrate the use of the object in the main function. Make sure that the function names are meaningful
and self-descriptive.

7.3 Out comes

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

7.4 Testing
Now you need to perform the following test cases for all practice tasks mentioned above. The test cases
have been made available in Table 2.

33
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Test Cases for Practice Task-1

Sample Inputs Sample Outputs
Set the following values IMEIno = 12345678901234
IMEIno = 12345678901234 Type = Tablet
Type = Tablet Make = Chuwi
Make = Chuwi Modelno = V8 HD
Modelno = V8 HD Memory = 860.5
Memory = 860.5 Operating System = Android Ice cream Sandwich 4.0.4
Operating System = Android Ice cream
Sandwich 4.0.4

Test Cases for Practice Task-2

Sample Inputs Sample Outputs

A = 30 A = 30
B = 150 B = 150
C = 140 C = 140
D = 20 D = 20
Angle1 = 80 Angle1 = 80
Angle2 = 110 Angle2 = 110
Parameter = 340
Area = 3345.34

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

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

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

Table 2: 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
4 7.2 Practice task 2 with Testing 20
5 8 Evaluation Tasks (Unseen) 15
6 Good Programming 10
Practices
Total Marks 80

34
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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: \\fs\lectures$

35
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-04
Access Specifiers, Constructors and Destructors

36
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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 defense in secure programming. This lab is designed to teach three very basic yet essential concepts of
OOP namely access specifiers, constructor and destructors. Access specifiers provide a technique through
which we can restrict access to data members and member functions. After enforcing access it is important
to reduce our reliance on too many member functions. Constructors offer a very attractive and easy to
implement technique through which we can take steps call procedures whenever an object is created. The
use of constructors is preferred over the use of member functions because constructors are called
automatically and hence they can invoke further functions whereas simple member functions have to be
called sequentially and explicitly one by one every time an object is created. Similarly this lab also focuses
on the use of destructors that are called whenever an object goes out of scope. In this the lab the students
will be familiarized with the use of access specifiers, constructors and destructors.
Relevant Lecture Readings:
● Lectures: 3, 4, 5, 6
● Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore
o Pages: 201-212

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 30 mins 25 mins
7 Practice tasks 80 mins 80 mins
8 Evaluation Task 45 mins 45 mins
Total Time 170 Minutes

3. Objective of the Experiment

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

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

37
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

data hiding. C++ provides three access specifiers i.e. public, private and protected. In this lab we will only
cover the public and the private access specifier. The protected specifier is left for future discussions.

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

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

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

using namespace std;

class myclass
{
private:
int datamember; //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);
}

4.2 Constructors
A constructor is a function that is automatically called when an object is created. This function can exhibit
the regular behavior 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
function 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

38
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

constructor. Generally the constructor is defined as public. Also the constructor can be overloaded like a
regular member function. An important point regarding a constructor is that it cannot return a value. In fact
writing the keyword void is strictly prohibited.

using namespace std;

class myclass
{
private:
int datamember; //Private data member public:
myclass( ); //Class constructor
{
cout<<”Hello you have called the class constructor”;
}
};

void main( )
{ myclass obj; }

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

using namespace std;

class myclass
{
private:
int datamember; //Private data member public:
myclass( ); //Class constructor
{
cout<<”Hello you have called the class constructor”;
}
~myclass( ); //Class constructor
{ cout<<”Hello you have called the class destructor”; }

39
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

5. Homework before Lab

5.1 Practices from home

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

class student{
int age;
int cnic;
int semester;
char name;
public:
int setall(int a, int c, int s, int sem, char n) const
{
age = a;
cnic = c;
semester = s;
name = n;
}
}
int myclass :: displayall ( ){
cout<<”The entered data is”<<student.data;
}
void main( ){Student obj; obj::setall( ); obj.displayall( ); obj.setage(); Student
anotherobj;Student::anotherobj::setall();
}

5.2 /Practices from home

Create a class “Vehicle” having:
● “LisencePlate_No”, “Model_No”, “Type”, and “Color” as private data members.
● Parameterized constructor assigning default values to the data members
● No-Argument constructor assigning default values to the data members
● Default constructor assigning default values to the data members
● Public member functions: Register Vehicle, Update Vehicle, Delete Vehicle, and Search Vehicle
NOTE: The values required should be obtained from the user in “void main ()” function and each data
member should have a setter and a getter through which you are required to perform the member function

6. Procedure & Tools

6.1 Tools
Visual Studio 2017.

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

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

40
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

6.3 Walkthrough Task [Expected time = 40 mins]

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

6.3.1 Writing Code

In the source file created in the project “pizza” write the following C++ code:
class pizza
{ private: int size, price, thickness; string topping;
public:
void setsize() ,
{ cout<<"Enter size of pizza: ";
cin>>size; }
void setprice()
{ cout<<"Enter price of pizza: ";
cin>>price; }
void setthickness()
{ cout<<"Enter thickness of pizza: ";
cin>>thickness; }
void settopping()
{ cout<<"Enter toppings of pizza: ";
cin>>topping; }
void display() const
{ cout<<"The ordered pizza details are: "; cout<<"\nSize: "<<size; cout<<"\nPrice:
"<<price; cout<<"\nTopping:"<<topping; cout<<"\nThickness:"<<thickness<<"\n"; }
pizza() //class constructor: cannot have a return type
{ setsize(); setprice(); setthickness(); settopping(); }
};
void main()
{ pizza obj; obj.display( ); }

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

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

6.3.3 Executing the Program

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

41
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Figure 2: Final output of pizza program.

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

7.1 Practice Task 1 [Expected time = 20 mins]

Write a C++ program for a new ice cream vendor called PopSalon. The management of PopSalon has
decided that they are going to sell their popcorn in 11 different flavors namely: chocolate, English toffee,
salted caramel, caramel, jalapeno, cheese, spiced cheese, plain sated, buttered, salt and pepper, and garlic.
Carefully design the program by observing the following rules.
● PopSalon is charging Rs. 100 for small pack, Rs. 250 for medium sized pack, Rs. 500 for large
sized pack and Rs. 750 large size tin pack. Hence you will need a function to determine the size of
the pack and based on that the price. If a user enters option number other than the ones displayed,
your program should display an invalid input message and ask the user to re-enter the option
number.
● PopSalon allows its customers to purchase a gift wrapper with their popcorn. If the customer wants
to purchase the wrapper he will have to pay an additional Rs 50. This amount should be added to
the total amount payable by the user.
● If the customer asks for chocolate sauce, caramel sauce, or melted cheese as an additional topping
then he will have to pay an additional amount of Rs. 50, Rs. 30 and, Rs. 60 respectively. Design a
function that will be called if the customer chooses an additional topping.
● 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 flavor, the size of the pack and details regarding
any additional toppings.
● For service quality inspection and monthly product promotions, the program should ask the user to
enter his/her contact details including name, mobile number and email address, and select between

42
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

the options good, neutral and bad against the quality of the service provided.
● 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 Outcome:
After completing this lab, students will be able to design a class that correctly implements class members
by observing access specifiers. The students will also be familiar with the use of a constructor and
destructor.

7.3 Testing
Test Cases for Practice Task-1

Sample Inputs Sample Outputs

Flavour = Chocolate Your choice of Popcorn is:
Pack Size = Medium Flavour = Chocolate
Additional Toppings = No Pack Size = Medium
Wrapper Required = No No Additional Toppings Required !
_______________________ No Gift Wrapper Required !
Product Promotion Details Total Bill = 250
Customer Name = Ali ____________________________
Mobile Number = 0300-4004563 Thank you for visiting PopSalon!
Quality of Service = Good

Flavour = chocolate Your choice of Popcorn is:

Pack Size = medium Flavour = Chocolate
Additional Toppings = Chocolate Pack Size = Medium
Wrapper Required = No No Additional Toppings = Chocolate
_______________________ No Gift Wrapper Required !
Product Promotion Details Total Bill = 300
Customer Name = Ali ____________________________
Mobile Number = 0300-4004563 Thank you for visiting PopSalon!
Quality of Service = Good
Flavour = strawberry Invalid Input
Pack Size = medium ____________________________
Additional Toppings = No Thank you for visiting PopSalon! Please Try Again
Wrapper Required = No
_______________________
Product Promotion Details
Customer Name = Ali
Mobile Number = 0300-4004563
Quality of Service = Good

43
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

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

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is
assigned marks which will be evaluated by the instructor in the lab depending on the accomplishment of
the assigned tasks.

Table 2: Evaluation of the Lab

Sr. No. Task No Description Marks

1 4.1 Problem Modelling 10

2 6 Procedures and Tools 5
3 7.1 Practice task 1 with Testing 50
4 8 Evaluation Tasks (Unseen) 15
5 Good Programming 10
Practices
Total Marks 90

10. Further Reading

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

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

44
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-05
Constructor Overloading and Copy Constructors

45
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

Relevant Lecture Material

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

2. Activity Time boxing

Table 1: Activity Time Boxing
Task Activity Name Activity time Total Time
No.
5.1 Evaluation of Design 25 mins 25 mins
6.2 Setting-up Visual Studio 5 mins 5 mins
6.3 Walkthrough Tasks 35 mins 35 mins
7 Practice tasks 40 + 10 (mins) 50 mins
8 Evaluation Task 55 mins 55 mins
Total Time 170 Minutes

11.

3. Objective of the Experiment

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

4. Concept Map

4.1 Function Overloading

Function overloading is an advanced concept in modern languages where two functions 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 functions 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);
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.

46
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

4.2 Constructor Overloading – Parameterized and Nullary Constructors

Constructors are designed to help initialize/ create an object. A constructor is a special function that is
automatically called upon the creation of an object. The important fact that needs to be communicated is
that constructors do not have a return type. In fact using the keyword void is also prohibited.
Constructors are of two types namely:
● Nullary Constructors / Parameterless Constructors – Those constructors that do not need a parameter
to be called.
● Parameterized Constructors – Those constructors that require parameters for their calling
Inside a class C++ allows us to overload a constructor just like any other function. This means in the same
class you can have a nullary constructor alongside a parameterized constructor. Consider the code below
for further reference.
class example
{
private:
int one;
int two;
float three;
public:
example( ) //Nullary constructor
{
...
}
example (int on, int tw, float th) //Overloaded Constructor:
parameterized ->1
{
}
};
int main()
{
}; example obj; //Creation through nullary constru
example
int main() obj2(1, 2, 3.3); //Creation through first parameterized
constru
{
example
example obj3(1,
obj; 3.3, 2); //Creation throughnullary
//Creation through Second parameterized
constru
constru
example obj2(1, 2, 3.3); //Creation through first parameterized
return 0;
constru
} example obj3(1, 3.3, 2); //Creation through Second parameterized
constru
return 0;
}

47
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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 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 ourselves to
the use of the default copy constructor.
The default copy constructor can be explicitly called as follows:

class obj2(obj1); // Function calling notation

class obj2 = obj1; //Assignment statement notation

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

5. Home Work before Lab

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

5.1 Practices from home

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

6. Procedure & Tools

6.1 Tools
Visual Studio 2017.

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

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

6.3 Walkthrough Task [Expected time = 35

mins]
Write a program that creates a class called student. The data members of the class are name and age.
● Create a nullary constructor and initialize the class object.
● Create a parameterized constructor that can set the values being passed from the main function.
● Create a display function called showAll( ) which will be used to show values that have been set.

48
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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:

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()
{int main()
{ student s1; //Creation through nullary constructor
student
student s1;
s2("Ali", //Creation
30); //Creationthroughthrough
nullary constructor
parameterized
student
constructor s2("Ali", 30); //Creation through parameterized
constructor
s1.showAll ();
s1.showAll ();
s2.showAll ();
s2.showAll
student s3(s1); (); //Calling copy constructor for s3
student s3(s1);
s3.showAll (); //Calling copy constructor for s3
s3.showAll
return 0; ();
} return 0;
}
Figure 1: The student class demonstrating the use of a parameterized and nullary constructor. Also note
the default copy constructor being used

49
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

6.3.2 Compilation

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

6.3.3 Executing the Program

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

Figure 2: Final output of student program.

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

50
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

7.1 Practice Task 1 [Expected time = 40 mins]

In the above given picture of a passport there is a machine readable code at the bottom of the passport. This code
is a set of 44 characters per row. Following are the contents embedded into this code:
● The only characters used are A–Z, 0–9 and the filler character <.
● The format of the first row is:

Position Lengt Character Meaning

s h s
1 1 alpha P, indicating a passport
2 1 alpha+< Type (for countries that distinguish between different types of
passports)
3–5 3 alpha+< Issuing country or organization (ISO 3166-1 alpha-3 code with
modifications)
6–44 39 alpha+< Surname, followed by two filler characters, followed by given
names. Given names are separated by single filler characters

● In the name field, spaces, hyphens and other punctuation are represented by <, except apostrophes, which
are skipped. If the names are too long, names are abbreviated to their most significant parts. In that case,
the last position must contain an alphabetic character to indicate possible truncation, and if there is a given
name, the two fillers and at least one character of it must be included.
● The format of the second row is:

51
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Position Lengt Characters Meaning

s h
1–9 9 alpha+num+< Passport number
10 1 numeric Check digit over digits 1–9
11–13 3 alpha+< Nationality (ISO 3166-1 alpha-3 code with modifications)
14–19 6 numeric Date of birth (YYMMDD)
20 1 num Check digit over digits 14–19
21 1 alpha+< Sex (M, F or < for male, female or unspecified)
22–27 6 numeric Expiration date of passport (YYMMDD)
28 1 numeric Check digit over digits 22–27
29–42 14 alpha+num+< Personal number (may be used by the issuing country as it
desires)
43 1 numeric Check digit over digits 29–42 (may be < if all characters are <)
44 1 numeric Check digit over digits 1–10, 14–20, and 22–43

● The check digit calculation is as follows: each position is assigned a value; for the digits 0 to 9 this is the
value of the digits, for the letters A to Z this is 10 to 35, for the filler < this is 0. The value of each position
is then multiplied by its weight; the weight of the first position is 7, of the second it is 3, and of the third it
is 1, and after that the weights repeat 7, 3, 1, and so on. All values are added together and the remainder of
the final value divided by 10 is the check digit.
Write a program that uses accepts a given Machine Readable Code and using a class stores the following 11 parts of
a passport separately after extraction as private data members:
1. Full Name
2. Passport Number
3. Nationality
4. Gender
5. Date of Birth
6. Country of Issuance (Passport Issuance)
7. Date of Issuance (Passport Issuance)
8. Date of Expiry
9. Citizenship Number
10. Passport Type
Create setters and getters for all the member variables and a public method named display to display the all the data
members.
Create three constructors as follows:
1. A nullary constructor that initializes the Citizenship Number as “*****-*******-*”.
2. A parameterized constructor that accepts First Name and Second Name and concatenates them into the data
member “Full Name” in its body.
3. A parameterized constructor that will set Gender, Nationality, and Passport Number as sent in parameters.

Create three objects of the class such as:

● First object is initialized with default constructor. The values are then set by calling the setters
● Second object is initialized with the constructor that accepts three arguments.
● Third object is initialized with the constructor that accepts four arguments.

Then display these data members.

Note: Here three constructors are created for different scenarios. Discuss the possible scenarios with the lab
instructor.

52
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

7.2 Practice Task 2 [Expected time = 10 mins]

Modify the class created in 7.1, Create a copy constructor to copy a citizenship number. Then in main
function call the copy constructor and observe the outputs.

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

7.4 Testing
Test Cases for Practice Task-1
Sample Inputs Sample Outputs
Using Nullary constructor Your Data is:
Full Name = ALMEERA RAZA
Gender = F
Nationality= PAK
Issuance Date= 12-12-12
Expiry Date=12-12-25
Country of Issuance= PAK
Citizenship Number= 98858-8538674-0
DOB= 12-04-99
Passport Number= YR898395
Father Name=RAZA
Using parameterized constructor (string, string) Your Data is:
FirstName=” ALMEERA” Full Name = ALMEERA ZAHID
LastName=”ZAHID” Gender = F
Nationality= PAK
Issuance Date= 12-12-12
Expiry Date=12-12-25
Country of Issuance= PAK
Citizenship Number= 98858-8538674-0
DOB= 12-04-99
Passport Number= YR898395
Father Name=ZAHID
Using parameterized constructor (char, string, string) Your Data is:
Gender = ‘F’ Full Name = ALMEERA ZAHID
Nationality = “PAK” Gender = F
Passport_Numer= Nationality= PAK
”<PAKZAHID<<ALMEERA<<<<<<<<<<<<<<<<<<<<<<<< Issuance Date= 12-12-12
< Expiry Date=12-12-25
HJ00000014PAK9912246F12080547880745349760<78” Country of Issuance= PAK
Citizenship Number= 98858-8538674-0
DOB= 12-04-99
Passport Number= YR898395
Father Name=ZAHID

53
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Test Cases for Practice Task-2

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

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

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

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each task is
assigned marks which will be evaluated by the instructor in the lab depending on the accomplishment of
the assigned tasks.

Table 2: Evaluation of the Lab

Sr. Task No Description Marks

No.
1 4.1 Problem Modelling 10
2 6 Procedures and Tools 5
3 7.1 Practice task 1 with 30
Testing
4 7.2 Practice task 2 with 20
Testing
5 8 Evaluation Tasks 25
(Unseen)
6 Good Programming 10
Practices
Total Marks 100

10. Further Reading

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

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

54
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-06
Shallow Copy / Deep Copy and Working with Arrays

55
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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 relating arrays and
constructors. All these aspects of arrays will be discussed in detail in this lab.
Relevant Lecture Material
● Lectures: 8, 9, 10

2. Activity Time boxing

Table 1: Activity Time Boxing
Task Activity Name Activity time Total Time
No.
5.1 Evaluation of Design 25 mins 25 mins
6.2 Setting-up Visual Studio 5 mins 5 mins
6.3 Walkthrough Tasks 30 mins 30 mins
7 Practice tasks 50 + 15 (mins) 65 mins
8 Evaluation Task 45 mins 45 mins
Total Time 170 Minutes

3. Objective of the Experiment

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

4. Concept Map

4.1 Creating a customized copy constructor

Although C++ provides you with a basic copy constructor, but still there are occasions when you need to design you
own copy constructor. Given below are some of the reasons why you might want to create a copy constructor.
● You need to copy only some of the data members to a new object.
● Your objects contain pointers.
● Your objects contain dynamic data members.
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:

56
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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.

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.

57
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

4.3 Deep Copy Constructor

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

(a)
Memory
Copy of
Object Object
1 1

(b)

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

58
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

4.4 Working with Arrays

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

class example
{
private:
float a[10]; //array as a data member
public:
example() // normal constructor
{
for(int i=0; i<=9;i++)
{
a[i]=0; // put the value 0 in
all locations
}
}
// other stuff
Given
}; below is a class named example that contains a dynamic floating point array “a”. This array can be
initialized with a constructor or with a simple member function as follows. Since this code works with a
dynamic array therefore the size of the array can be provided at run time. In this particular code since the
size is not passed there may be a possibility that the programmer crosses the array boundary.

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

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

{
a[i]=0; // put the value 0 in all
locations
}
} 59
// other stuff
};
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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.
Another option which is very popular among programmers is that the size of the array can be stored as a
data member.

60
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

5. Home Work before Lab

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

5.1 Practices from Home

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

6. Procedure & Tools

6.1 Tools
Visual Studio 2017.

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

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

6.3 Walkthrough Task [Expected time = 30

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

6.3.1 Writing Code

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

class english
{
private:
string sentence;
int size;
public:
example()
{
cout<<"Enter your sentence: ";
getline(cin,sentence);
size=9;
size=sentence.length();
}
example (example & tempobj)
{
size = tempobj.size;
sentence=tempobj.sentence;
}
void showall()
{
cout<<"\nSentence: "<<sentence;
cout<<"\nCharacters: "<<size<<"\n";
} }; 61
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

int main( )
{
english obj1;
english obj2=obj1;
cout<<"Object one contains data";
obj1.showall();
cout<<"Copied object contains data";
obj2.showall();
return 0;
}

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

6.3.2 Compilation

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

6.3.3 Executing the Program

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

Figure 2: Final output of “english” class

7. Practice Tasks
This section will provide more practice exercises which you need to finish during the lab. You need to
finish the tasks in the required time. When you finish them, put these tasks in the following folder:

62
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

\\dataserver\assignments$\OOP\Lab05

7.1 Practice Task 1 [Expected time = 50 mins]

Create a class entertainment consisting of the following data members:
● Title
● Air_Date i.e. Release Date
● Genre
● Type (i.e. Movie, TV Show)
● Runtime
● Country
● Actors
● Rating.
Follow the instructions below for creating the class and objects: Store the owners name as a dynamic array data
member.
● Store the genre as a dynamic array data member.
● Store the names of the actors as a dynamic array data member.
● Create an object named “obj1” and initialize the object.
● Create a copy constructor that can list of genre, country and rating.
● Generate another object named “obj2” that is created by copying only the genre, country and ratings from
“obj1”.
● Initialize the remaining attributes with values of your own.

7.2 Practice Task 2 [Expected time = 15 mins]

Your task is to create a class name polygon that contains 2 data members i.e. length of type float and width
(a pointer of type float). Create a single object named “one” in the main and assign values to the data
member of the polygon object. Then create another object named “two” that is a copy of the “one”. Create
a shallow copy constructor that copies only the pointer data member of the class polygon 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 polygon object.

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

7.4 Testing
Test Cases for Practice Task-1
Sample Inputs Sample Outputs
Title = Interstellar After selective copying only the permanent attributes
Air_Date = October 26th,2014 contain values.
Genre = Drama, Mystery Title = Gravity
Type = Movie Air_Date = December 30th,2013
Runtime = 2h 49m Genre = Drama, Mystery
Country = USA Type = Movie

63
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Actors = Matthew MacConaughey, Anne Runtime = 2h 14m

Hathaway, Jessica Chastain, Machenzie, Country = USA
Casey Affleck, Matt Damon Actors = George Clooney, Sandra Bullock, Ed Harris
Rating = 8.6/10 Rating = 8.6/10

Test Cases for Practice Task-2

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

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

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

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

Sr. Task No Description Marks

No.
1 4.1 Problem Modelling 10
2 6 Procedures and Tools 5
3 7.1 Practice task 1 with 30
Testing
4 7.2 Practice task 2 with 20
Testing
5 8 Evaluation Tasks 25
(Unseen)
6 Good Programming 10
Practices
Total Marks 100

10. Further Reading

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

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

64
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-07
File Handling

65
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

1. Introduction
This lab will introduce you about how to implement file handling code in C++. The section 2
presents a table that outlines some major activities and tasks you will do as the part of this lab.
Table 1 also provides the estimated-time for each activity, which will help you to organize your
tasks well. Section 3 presents some of the learning objectives for this lab. Section 4 (“Concept
Map”) discusses and provides a comprehensive introduction of the topic. Section 5 lists the set of
home-tasks you are required to complete before this lab. Section 6 presents a “walkthrough task”
that you will do as the first practical activity during your lab. The walkthrough task has many small
steps which you should follow as directed in-order to complete the task and to get the desired
output. After that, you will be ready to work on some tasks on your own. The section 7 lists practice
tasks for this purpose. As the part of section 8, your lab instructor will give you some tasks at
runtime and will evaluate those according to the criteria mentioned in section 9. Section 10 lists
some further reading links.

Note: Before coming to the lab, you are required to read Lab contents until section 5. You
will start your practical work from section 6 onward in the lab.

Relevant Lecture Readings:

a) Lecture No. 23
b) Text Book: Computer Programming by D. S. Malik, pages: 147—150

2. Activity Time-boxing

Table 1: Activity Time Boxing

Task Acitivity Name Activity time Total Time
No.

5.1 Evaluation of Design 20 mins 20 mins

6.2 Setting-up Visual Studio 5 mins 5 mins
6.3 Specialized Tasks 35 mins 15 mins
7 Practice tasks 30 mins for the task 1 and 40 min 70 mins
for task 2

8 Evaluation Task 30 mins for each assigned task 60 mins

Total Time 170 mins

66
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

3. Objective of the Experiment

● To get basic understanding of writing and reading operation of text files using C++.

● To practice the usage of the ifstream, ofstream and fstream objects.

● Be familiar with basic filing related I/O member functions.

4. Concept Map
A file is a collection of information, stored on a computer’s disk. Information can be saved to
files, and then later read and reused. C++ provides the following classes to perform input/output
operations on the files:
● ofstream: Stream class to write in files
● ifstream: Stream class to read from files
● fstream: Stream class to both read and write from/to files.
These classes (ofstream, ifstream, and fstream) are derived from the classes istream, and
ostream. We have already used objects of these stream classes for example: cin (for standard
input), and cout (for standard output). Similarly, we can use the file streams objects to perform
input (read operation) and output (write operation) in the files. File operations are used extensively
in most of the large projects where we have to save the data permanently on the disks.
You can create an ofstream object to perform writing or output operations on the files while the
ifstream object can only be used for reading from the files. If you want to perform both the writing
and reading operations on the file, please use the fstream objects. Before reading/writing to a file,
it must be opened. To open a file, you can call open function of ofstream, ifstream, or fstream.
void open(const char *filename, ios::openmode mode);

In the above function the first argument specifies the name of the file to open. If the file to open is
not in the current directory (where .cpp files reside) provide complete path with filename. The
second parameter specifies the file opening mode. A list of file opening modes is provided in
Appendix (A).

4.1 Permanent Storage

Usually the data stored in variables is lost when an application exits. If we require using some
calculated data in the program, or need to save the user inputs for the later use (after some time),
then we have to store this data permanently to hard-disk. Filling allow us to write program state to
the hard-disk and further retrievals of the previously saved data.

4.2 Data Retrieval

Some applications needs initial data to run/execute for example: system programs, etc. On startup,
manual input of the initial data every time we launch the application will be very tedious. In this
situation, filling help us to read data from the permanent storage for example a hard-disk, and

67
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

applications can be launched with correct starting state.

5. Home work before Lab

5.1 Problem solution modeling

Write all the steps involved in writing and reading of text file in C++. You need to the
flowchart/steps with you and need to give it to the lab instructor. This will be evaluated and it
carries certain marks as can be seen from the section 9, Table 2.

5.2 Practices from home

Write a C++ program which writes a string “My first file handling program!” on a file named
“first.txt”. The programs also read the written that line (“My first file handling program!”) from
the file named“first.txt” and display it on the screen:

6. Procedure & Tools

6.1 Tools
Visual Studio 2017.

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

Setup Visual Studio and make a project named “WordCounter”. For setup details please refer to
the Lab-1 section 6.2.

6.3 Walkthrough Task [Expected time = 35 mins]

6.3.1 Write in a text file using C++.

Your program should take input from user about a student record. A student record means that you
are required to get his name (string type), age (int type), and program (string type). Read data for
all these data-items from the user then write in a text file named “student.txt”.

6.3.2 Writing Code

Write the following code as shown in the Figure 1. This code is for writing student information in to the file named

68
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

“student.txt”.

Figure SEQ Figure \* ARABIC 1: C++ program to write data in a

text file

6.3.3 Compilation

11.1.3 After writing the code, compile your code according to the guidelines mentioned in Lab-1 (section 6.3.2)

6.3.4 Executing the Program

11.1.4 Execute the above program. After successful execution of the program a text file named “student.txt” will be
created in the current directory (where your .cpp file resides). You may open the “student.txt” file and examine the
data written in the file.

11.1.5 Figure SEQ Figure \* ARABIC 2: Contents or values of

the text file "student.txt"

69
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

6.3.5 Reading a text file

Read the student information which was written in the previous program example. After reading
the data from “student.txt”, output it to the screen. For reading the file, write following C++ code
(as shown in the Figure 3). This code opens the “student.txt” file for reading student information
and outputs on the screen.

11.1.6

11.1.7

11.1.8

11.1.9

11.1.10

11.1.11

11.1.12

Figure 3: C++ program to read "student.txt" file.

6.3.6 Compilation

11.1.13 After writing the code, compile your code according to the guidelines mentioned in Lab-1 (section 6.3.2).

70
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

6.3.7 Executing the Program

Execute the above program. After successful execution of the program data will be read from the
file and will be displayed on the screen as shown in the figure below:

Figure SEQ Figure \* ARABIC 4: Output of the read

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 folder
specified by your lab instructor.

7.1 Practice Task 1

Write a C++ program which takes 5 students’ information (records) as inputs from the user and
save them on a file. Your program should have two options: writing and searching.

When a user selects writing option, you are required to take three inputs from the user: student
name (string type), student age (int type). After reading these data-items write to the file named
“student.txt”. Please note: write data using append mode otherwise previous information will be
lost.

Your program should have a search function. The search function should provide three options
for searching: by name, by age, or by registration number. After selection of the search option
by the user, please take input (name, age, or registration number) and search that student from the
file and display its record on the screen.

7.2 Practice Task 2

Write a C++ program which takes multiple Employees information (records) as inputs from the
user and save them on a file using class. Writing in file should be done using setters. Perform
following operations on the data saved in the file:
● Read data from file
● Search an employee’s information in the file
● Count the number of employees having salary more than 50,000.
71
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

7.3 Out comes

After completing this lab, student will be able to read and write data in a text file.

7.4 Testing

Test Cases for Practice Task-1

1. Please ensure that the student information being written in the file is actually written or
not. For this, you have to examine by double-clicking the “student.txt” file (in the current
directory) and verify its contents.
2. All recorded student data must be retrievable by search option.

Practice Confirmation
Tasks
T1

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

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

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

Table 2: Evaluation of the Lab

Sr. No. Task Description Marks
No
1 4.1 Problem Modeling 20
2 6 Procedures and Tools 10
3 7.1 Practice tasks and Testing 35
4 8.1 Evaluation Tasks (Unseen) 20
5 Comments 5
6 Good Programming Practices 10

72
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

10. Further Readings

10.1 Slides
The slides and reading material can be accessed from the folder of the class instructor available at
\\fs\lectures$

Appendix A – File Opening Modes

File Mode
Meaning
Flag

Append mode.
If the file already exists, its contents are preserved and all output is written to
ios::app
the end of the file. By default, this flag causes the file to be created if it does
not exist.
If the file already exists, the program goes directly to the end of it. Output may be
ios::ate written anywhere in the file.
Binary mode. When a file is opened in binary mode, information is written to or
ios::binary read from it in pure binary format. (The default mode is text.)
If the file does not already exist, this flag will cause the open function to fail. (The
ios::noreplace file will not be created.)

Input mode. Information will be read from the file. If the file does not exist, it
ios::in will not be created and the open function will fail.

If the file does not already exist, this flag will cause the open function to fail. (The
ios::nocreate
file will not be created.)
Output mode. Information will be written to the file. By default, the file’s contents
ios::out will be deleted if it already exists.
If the file already exists, its contents will be deleted (truncated). This is the default
ios::trunc
mode used by ios::out.

73
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-08
The protected Access Specifier and Types of Inheritance

74
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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.

75
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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.
Relevant Lecture Readings:
● Lectures: 17, 18
● Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Pages: 372 - 428

2. Activity Time Boxing

Table 1: Activity Time Boxing

Task Activity Name Activity time Total Time

No.
6.2 Setting-up Visual 5 mins 5 mins
Studio
6.3 Walk-through Tasks 30 mins 30 mins
7 Practice tasks 25 mins for task 1 and 2 85 mins
35 mins for task 3
8 Evaluation Task 50 min for all assigned 50 mins
task
Total Time 170 mins

3. Objective of the Experiment

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

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

76
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

it was important to consider that data member(s) should have private access and only through
public member functions, you can access data members of a class. However, with inheritance, it
is sometimes required to have an intermediate level of accessibility to class’s data member(s) that
exists only within inheritance class hierarchy but not outside these classes.

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

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

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

Access Specifier with Inherited class

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

5. Homework before Lab

5.1 Problem Solution Modeling

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

5.1.1 Problem description:

Design a class named Rectangle that includes

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

From the Rectangle class, derive a class named Cuboid that contains
● a data field named height in addition to length and width,
● two functions named setHeight and getHeight() to set and get value of height data field,
and

77
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

● a member function named cuboidArea() to calculate the area of a cuboid (length x width
x height)
Draw UML diagram for each class and show inheritance relationship between these classes.

5.2 Practices from Home

5.2.1 Task-1

Consider a class named GraduateCourse that includes

● Three data members i.e.
o courseID (e.g. CS2133),
o courseName (e.g. OOP),
o creditHours (e.g. 3 or 4), and
o courseFee (e.g. Rs. 10,000).
● A parameterized constructor to initialize data members with values specified by the user

Derive a class named ResearchCourse from Course class, which contains

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

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

5.2.2 Task-2

Representing a point in the plane, a class named PlanePoint has

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

Derive a class named SpacePoint to imagine a point in a three-dimensional space and has
following additional features:
● A data member Z of type integer to represent the z-coordinate of a point in space
● A no-argument constructor that constructs a point with coordinates (0,0,0)

78
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

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

Setup visual studio and make a project named “InheritanceSpecifier”

6.3 Walkthrough Task [Expected time = 30 mins]

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

6.3.1 Writing Code

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

79
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Figure 1: Base and Derived Classes

Figure 2: Main function for Figure 1

80
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

6.3.3 Executing the Program

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

Figure 3: Final Output

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

7.1 Practice Task 1 [Expected Time = 25 mins]

Create a class Car, which contains

● Three data members i.e. carName (of string type), ignition (of bool type), and
currentSpeed (of integer type)
● A no-argument constructor to initialize all data members with default values
● A parameterized constructor to initialize all data members with user-defined values
● Three setter functions to set values for all data members individually
● Three getter function to get value of all data members individually
● A member function setSpeed( ) // takes integer argument for setting speed

Derive a class named Convertible that contains

● A data member top (of Boolean type)
● A no-argument constructor to assign default value as “false” to top
● A four argument constructor to assign values to all data-members i.e. carName, ignition,
currentSpeed and top.
● A setter to set the top data member up
● A function named show() that displays all data member values of invoking object

81
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

7.2 Practice Task 2 [Expected Time = 25 mins]

Company is the base class that holds
● Data fields named companyID (of integer type), and companyName (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 Company class:

● MobilePhone, which contains an attribute mobiulePhoneName of string type, mobileID
of integer type, mobilePrice of integer type and setters and getters member function of all
data members
● Laptop which contains an string variable named laptopName along with a member
function to set laptop name
● 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 MobilePhone and Laptop classes and show the advantages
of using protected access specifier.

7.3 Practice Task 3 [Expected Time = 35 mins]

A class named CafeService contains

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

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

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

82
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

8. Evaluation Task (Unseen) [Expected Time = 50 mins for all tasks]

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

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

Table 3: Evaluation of the Lab

Sr. No. Task No Description Marks

1 6 Procedures and Tools 10
2 7.1 Practice tasks and Testing 55
3 8 Evaluation Tasks (Unseen) 20
4 Comments 5
5 Good Programming 10
Practices
Total Marks 100

10. Further Reading

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

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

83
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-9
Function Overloading and Function Overriding

84
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

1. Introduction
Earlier in Lab-08, 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),

85
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

● At first, the class Derived shows function overloading while containing two functions differ
from each other in function signature (i.e. functions myFunc() and myFunc(int))
● Secondly, it also shows function overriding as it holds two function implementations with
same signature (i.e. besides myFunc() of its own, it also contains myFunc() inherited from
the Base class.
Relevant Lecture Readings:
● Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Pages: 188-193, 382-392

2. Activity Time Boxing

Table 1: Activity Time Boxing

Task Activity Name Activity time Total Time

No.
6.2 Setting-up Visual 5 mins 5 mins
Studio
6.3 Walk-through Tasks 30 mins 30 mins
7 Practice tasks 50 mins for task 1 80 mins
30 mins for task 2
8 Evaluation Task 55 min for all assigned 55 mins
task
Total Time 170 mins

3. Objective of the Experiment

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

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

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

class GeometricShape{
public:

86
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

int squareArea(int sideLength);

int reactangleArea(int length, int width);
int triangleArea(int side1, int side2, int side3);
};

However, the same code with function overloading would be as

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

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

5. Homework before Lab

5.1 Problem Solution Modeling

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

5.1.1 Problem description:

Design a class named Automobile that includes

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

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

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

87
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

5.2 Practices from home

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

5.2.2 Task-2

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

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

6. Procedure & Tools

6.1 Tools
Visual Studio 2017.

6.2 Setting-up Visual Studio 2017 [Expected time = 05 mins]

Setup visual studio and make a project named “FunctionOverloading”

6.3 Walkthrough Task [Expected time = 30 mins]

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

6.3.1Writing Code

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

88
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Figure 1: Function Overloading

89
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Figure 2: Main( ) function for Figure 1

90
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

6.3.3 Executing the Program

A sample output after running the program is shown below:

Figure 3: Final Output

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

7.1 Practice Task 1 [Expected Time = 30 mins]

● Consider a class Shapethat contains
o A data member named as ShapeName of string type
o A data member named as areaof type int
o A member function displayarea()
● Derive two classes named Circle and polygon from the class Shape that contain
o A parameterized constructor to initialize data members that they inherit from the class
Shape

In the main(), create instances of Shape Circle and Polygon classes. Invoke displayarea() with
shape object while passing references of Circle and Polygon instances.

7.2 Practice Task 2 [Expected Time = 50 mins]

Create a class named Laboratory containing
● Two data fields i.e. name (a string) and location (string)
● A no-argument constructor to initialize all data fields with default values “NoName” and
“NULL”
● A member function named input()

91
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

● A member function named show() to display the details associated with an instance of this
class
Derive a class named WetLab from class Laboratory that includes
● data members no_of_microscopes and Scientist_name,
● respective mutator and accessor functions
● overriding function named input() to take input from user in all data members
● overriding function named show() to display the details associated with an instance of class
WetLab

From the Laboratory class, derive a class named DryLab that contains
● a data field named no_of_computers and Capacity
● Setters and getters
● an overriding function named input()
● overriding function named show() to display the details associated with an instance of this
class

Implement these classes and in the main() create instances of each class and test the functionality
of overridden member functions with these 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.

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.

9. Evaluation Criteria
The evaluation criteria for this lab will be based on the completion of the following tasks. Each
task is assigned the marks percentage which will be evaluated by the instructor in the lab whether
the student has finished the complete/partial task(s).
Table 2: Evaluation of the Lab
92
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Sr. No. Task Description Marks

No
1 6 Procedures and Tools 10
2 7.1 Practice tasks and Testing 55
3 8 Evaluation Tasks 20
(Unseen)
4 Comments 5
5 Good Programming 10
Practices
Total Marks 100

10. Further Reading

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

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

93
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-10
Polymorphism in Object Oriented Programming

94
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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.

95
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

96
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

class Derived2: virtual public Base{ };

class Derived3: public Derived1, public Derived2
{ };

Pure Virtual Function and Abstract Class:

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

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

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

Relevant Lecture Readings:

● Lectures: 23, 24, 25, 26
● Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Pages: 503- 520

2. Activity Time Boxing

Table 1: Activity Time Boxing
Task Activity Name Activity time Total Time
No.
6.2 Setting-up Visual 5 mins 5 mins
Studio
6.3 Walk-through Tasks 30 mins 20 mins
7 Practice tasks 90 mins for three task 90 mins
8 Evaluation Task 55 min for all assigned 55 mins
task
Total Time 170 mins

3. Objective of the Experiment

After completing this lab, the student should be able to:
● Distinguish between static binding and dynamic binding
● Understand polymorphism and dynamic binding while using virtual functions
● Declare abstract classes with pure virtual function

97
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

5. Homework before Lab

5.1 Problem Solution Modeling

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

5.1.1 Problem description:

Design a class named Record that includes

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

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

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

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

98
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

5.2 Practices from home

5.2.1 Task-1

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

Class Researcher is derived from both Staff and Professor classes that are ultimately derived from
class Person.

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

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

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

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

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

5.2.2 Task-2

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

6. Procedure & Tools

6.1 Tools

Visual Studio 2017.

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

Setup visual studio and make a project named “Polymorphism”

6.3 Walkthrough Task [Expected time = 30 mins]

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

99
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

6.3.1 Writing Code

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

100
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Figure 1: Polymorphism

101
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

6.3.2. Compilation

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

6.3.3. Executing the Program

A sample output after running the program is shown below:

Figure 2: Final Output

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

7.1 Practice Task 1 [Expected Time = 40 mins]

Consider an abstract class Animal having
● A datamember “Name”
● A datamember “Zoo”
● A single function named show()

A class named Birds inherits Animal class and adds fields representing
● A bool type variable flying
● Override function named show() to display values of its all attributes

A class named Reptiles inherits BOOK class and adds fields representing
● Length
● 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.

102
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

7.2 Practice Task 2 [Expected Time = 40 mins]

Create a class named Person, which contains
● A pure virtual function named print()
● Two data fields i.e. personName and age
A class named Student inherits Person class, which contains
● Two data fields i.e. Std_id and Cgpa
● Overridden function print() to display all details relevant to a patient

A class named Regular inherited from class Student which holds

● A data field representing the name of School
● A data filed representing the Fee
● Overridden function print() to display all details relevant to a Regular student
A class named Private inherited from class Student which holds
● A data field representing the address
● A data filed representing the Fee
● Overridden function print() to display all details relevant to a private Student

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

7.3 Practice Task 3 [Expected Time = 40 mins]

Create a class named GeometricShape containing

● A pure virtual function named show() is create in the GeometricShape 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
In the main function, create instances of derived classes to access respective show() function using
dynamic binding.

103
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

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.

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

Table 2: Evaluation of the Lab

Sr. No. Task Description Marks

No
1 6 Procedures and Tools 10
2 7.1 Practice tasks and Testing 55
3 8 Evaluation Tasks 20
(Unseen)
4 Comments 5
5 Good Programming 10
Practices
Total Marks 100

10. Further Reading

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

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

104
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-11
Relationships in Object Oriented Programming

105
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

1. Introduction
In OOP, various kinds of relationships (i.e. inheritance, association, aggregation, composition) exist
between various classes/objects.

Inheritance is modeled as is-a relationship. Inheritance exists between classes and the main goal of
inheritance is to make objects that would represent specialized versions of generalized original objects. For
example, a car is-a vehicle, manager is-an employee etc.

On the other hand, association and aggregation/composition represent uses-a and has-a relationship,
respectively between objects. It is based on the object-oriented design where an object can contain other
object(s). Association specifies that objects of different kinds are connected with each other and there exist
no ownership and lifecycle dependency. In advance, aggregation and composition are two types of
association representing weak and strong (whole-part) relationship between contained (whole) and owing
(part) objects. Therefore, aggregation and composition are other forms of code reusability along with
inheritance. Aggregation is a special kind of association represents ownership relationship between objects.
Composition is special kind of aggregation which represents ownership between objects along with the
existence of life-cycle dependency. A department-employees relationship is an example of aggregation
whereas university-departments relationship is an example of composition.

Following example explains the syntax for aggregation and composition in C++:

class Battery{ };
class Engine{ };
class Vehicle
{
private:
Battery *bat;
Engine *eng;
public:
Vehicle(Battery *b)
{
bat = b;
eng = new Engine();
}
~Vehicle()
{
delete eng;
}
};

Above example shows that aggregation exists between battery and vehicle because of the possession of
ownership but not life-cycle dependency. On the contrary, composition exists between vehicle and engine
because of the possession of ownership and life-cycle dependency.
Relevant Lecture Readings:
● Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.
o Pages: 414- 420

106
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

2. Activity Time Boxing

Table 1: Activity Time Boxing

Task Activity Name Activity time Total Time

No.
6.2 Setting-up Visual 5 mins 5 mins
Studio
6.3 Walk-through Tasks 30 mins 30 mins
7 Practice tasks 80 mins for assigned task 80 mins
8 Evaluation Task 55 min for all assigned 55 mins
task
Total Time 170 mins

3. Objective of the Experiment

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

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

● is-a relationship (Inheritance)

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

The is-a relationship exhibits a relationship between an object of specific type to its general type. For
example, a bus is-a vehicle, an employee is-a person, circle is-a geometric shape etc. The is-a relationship
has been modeled in terms of inheritance that you have already studied in Lectures 15-18.

The uses-a relationship demonstrate that an object of one specific type uses an object of different type to
perform some activity. For example, a person uses-a wiper to wash bus window pane, a teacher uses-a
course to teach student, a cyclist uses-a pump in tire-pumping activity). The uses-a relationship can be
described as association between objects i.e. a teacher has association with student through a specific
course. Similarly, university has association with its departments through administration. In simple words,
association is a relationship between objects where exists no ownership and each object has its own
lifecycle. More specifically, association are of two types i.e. aggregation and composition that represents
has-a relationship between objects.

The has-a relationship represents a classical ownership of whole-part relationship. Sometimes an object of
one type contains an object of type e.g. a university has-a number of departments and ultimately a
department has a number of professors, a bus has-an engine, a bike has-a set of wheels etc. The has-a
relationship can be modeled as aggregation and composition.

107
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

5. Homework before Lab

5.1 Problem Solution Modeling

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

5.1.1 Problem description:

A T20 is made up of at least 10 teams. Each cricket team is composed of 10 players, and one player captains
the team. A team has a name and a record. Players have a number and a position. Cricket teams play games
against each other. Each game has a score and a location. Teams are sometimes lead by a coach. A coach
has a level of accreditation and a number of years of experience, and can coach multiple teams. Coaches
and players are people, and people have names and addresses.

Draw UML diagram for each class and show inheritance, association, aggregation and composition
relationship between these classes.

5.2 Practices from home

5.2.1 Task-1

Using C++ compiler, illustrate the implementation of classes that have been specified in section 5.1.1. Write
main() in a way that it clearly describes aggregation and composition relationships between objects of
implemented classes.

5.2.2 Task-2

Using C++ compiler, demonstrate the implementation of classes in a way that it proves inheritance
relationship between appropriate classes, association and aggregation/composition relationship between
objects of various classes in terms of ownership and lifecycle dependency.

6. Procedure & Tools

6.1 Tools
Visual Studio 2017.

108
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

Setup visual studio and make a project named “RelationshipExample”

6.3 Walkthrough Task [Expected time = 30 mins]

In this task, you are required to write a C++ code which would elaborate the concept of relationships (i.e.
inheritance, aggregation, composition) in OOP. The following lines show the output of a basic relationship
concept:

6.3.1 Writing Code

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

109
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Figure 1: Relationship Example

110
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

6.3.3 Executing the Program

A sample output after running the program is shown below:

Figure 2: Final Output

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

7.1 Practice Task 1 [Expected Time = 80 mins]

Consider six classes i.e. Person, Scientist, Engineer, Sector, Laboratory, and Department having
following specifications.

Class Department has

● Two attributes of type string i.e. DepartmentName and location
● An attribute named sect of type Sector

Class Sector has

12. Two attributes i.e. sectID, sectName

13. A two-argument constructor to initialize data fields with user-defined values

14. A member function display() to show all attribute values

Class Laboratory contains

● Three attributes i.e. labID, access_level, sectID and experimentNo
● A three-argument constructor that:
o Initializes labID and experimentNo with user-defined values
o Based on designation, on scale of 1-10 access_level is automatically assigned (higher the
designation higher the access_level)
Class Person has
● Two attributes i.e. name and age
● A parameterized constructor to initialize attributes with user-defined values
● A member function display() to show its attribute values

Class Scientist is derived from class Person and has

● A data field named sciName of type string

111
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

● A data field named dept of type Department

● A data field named designation of type string
● A two-argument constructor to initialize both attributes of user-defined values

Class Engineer is derived from class Person and has

● An additional attribute named lab of type Laboratory
● A constructor to initialize lab with user-defined value

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 Practice Task 2 [Expected Time = 40 mins]

Cafeteria system is an important part of any institute. The university wants to automate the
cafeteria system you can help by identifying different classes along with their relationships.
University café has different customers (Employees, Students) that visit it for buying different
kinds of food. We want to make the system online so when a customer wants something he should
order it through a server. Whenever a customer comes to café he/she orders the food from specific
category. When a user wants to order something menu is displayed showing different food corners
(FastFood, ProperMeal, Beverages). After the order is placed generate bill for the user according
to the order he has placed. Identify the classes their relationship and function prototype of each
class.

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

8. Evaluation Task (Unseen) [Expected Time = 40 mins for all tasks]

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

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

112
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Table 2: Evaluation of the Lab

Sr. No. Task No Description Marks

1 6 Procedures and Tools 10
2 7.1 Practice tasks and Testing 55
3 8 Evaluation Tasks (Unseen) 20
4 Comments 5
5 Good Programming 10
Practices
Total Marks 100

10. Further Reading

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

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

113
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-12
Function and Class Templates

114
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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.
Relevant Lecture Readings:
● Lectures: 29, 30, 31

115
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

● Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.

o Pages: 682- 703

2. Activity Time Boxing

Table 1: Activity Time Boxing

Task Activity Name Activity time Total Time

No.
6.2 Setting-up Visual 5 mins 5 mins
Studio
6.3 Walk-through Tasks 30 mins 30 mins
7 Practice tasks 25 mins each for task 1 and 2 90 mins
40 mins for task 3
8 Evaluation Task 45 min for all assigned task 45 mins
Total Time 170 mins

3. Objective of the Experiment

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

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

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

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

116
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

5. Homework before Lab

5.1 Practices from Home

5.1.1 Task-1

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

5.1.2 Task-2

Consider a class named Calculator that contains

● Two data members i.e. num1 and num2
● A parameterized constructor to assign values to both data members
● Four functions i.e. addition(), subtraction(), multiplication(), and division() to perform their
respective functions on data members and return result in double

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

6. Procedure & Tools

6.1 Tools
Visual Studio 2017.

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

Setup visual studio and make a project named “TemplateExample”

6.3 Walkthrough Task [Expected time = 30 mins]

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

6.3.1 Writing Code

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

117
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

Figure 1: Find minimum number using Class Template

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

6.3.3 Executing the Program

A sample output after running the program is shown below:

Figure 2: Final Output

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

118
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

7.1 Practice Task 1 [Expected Time = 25 mins]

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

7.2 Practice Task 2 [Expected Time = 25 mins]

Write two generic functions (overloaded) named area(). Create function template for the first area()
function that it is able to receive the radius of a circle as its parameter and returns half of the calculated
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 triple of the calculated
area of rectangle as of same data type.

7.3 Practice Task 3 [Expected Time = 40 mins]

Create a class template for a class named Queue that holds

● A single data member as an array named list of size 10 to store certain elements
● A constructor to initialize queue with value 0 or 0.0 at all its indexes
● Three member functions i.e. sort() to sort the elements of the queue, max() that returns the
maximum value present in the queue, min() that returns the smallest value present in the queue,
and return_queue() that returns all the elements of the queue (in case of there being multiple
maximum and minimum values present in the queue, the member functions should return notify
the user of the number of times that value has been repeated in the queue and then return that value
to the main function).

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

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

7.5 Testing
● Test cases for Practice Lab 1

Sample Inputs Sample Outputs

int arr = {1,2,3,4,5} 10
maximum_doubled (arr,5)
double arr = {10.11, 2.99, 1.40, 181.98
90.99}
minimun(arr, 4)

● Test cases for Practice Lab 2

Sample Inputs Sample Outputs

119
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

area(5.0) 39.25
area(20.0,10.0) 600.0

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

8. Evaluation Task (Unseen) [Expected Time = 45 mins for all tasks]

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

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

Table 2: Evaluation of the Lab

Sr. No. Task No Description Marks

1 6 Procedures and Tools 10
2 7.1 Practice tasks and Testing 55
3 8 Evaluation Tasks (Unseen) 20
4 Comments 5
5 Good Programming 10
Practices
Total Marks 100

10. Further Reading

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

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

120
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-13
Static keyword in Object Oriented Programming

121
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

1. Introduction
There is an important exception to the rule that each object of a class has its own copy of all the data
members of the class. In certain cases, only one copy of a variable should be shared by all objects of a class.
A static data member is used for such propose.. Such a variable represents "class-wide" information (i.e., a
property of the class shared by all instances, not a property of a specific object of the class). The declaration
of a static member begins with keyword static.

In the above figure, consider Object1, Object2 and Object3 are three of a class. Each object has its own
private data members. The class has a static data member that is share among all the object of that class.
This data member has it own memory allocated that is separate from the memory allocated for each object
of that class.
Static keyword can be used as:

1. Variables in functions
Static variables when used inside function are initialized only once. They hold their value even through
function calls

122
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

2. Class objects

Objects declared static are allocated storage in static storage area. They have a scope till the end of program
Static objects are also initialized using constructors like other normal objects.

123
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

3. Data members of a class

Static data members of class are those members which are shared by all the objects. Static data
member has a single piece of storage, and is not available as separate copy with each object, like
other non-static data members. Static member variables (data members) are not initialized using
constructor, because these are not dependent on object initialization. Also, it must be initialized
explicitly, always outside the class. If not initialized, Linker will give error. Once the definition
for static data member is made, user cannot redefine it. Though, arithmetic operations can be
performed on it.

124
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

4. Member functions of a class

These functions work for the class as whole rather than for a particular object of a class. It can be called
using an object and the direct member access . Operator But, its more typical to call a static member
function by itself, using class name and scope resolution :: operator. These functions cannot access ordinary
data members and member functions, but only static data members and static member functions.

• Static function can only access static data member of class

• Non static member function can access static and non static data member of class

Relevant Lecture Readings:

● Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore.

125
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

2. Activity Time Boxing

Table 1: Activity Time Boxing

Task Activity Name Activity time Total Time

No.
6.2 Setting-up Visual 5 mins 5 mins
Studio
6.3 Walk-through Tasks 30 mins 30 mins
7 Practice tasks 80 mins for assigned task 80 mins
8 Evaluation Task 55 min for all assigned 55 mins
task
Total Time 170 mins

3. Objective of the Experiment

After completing this lab, the student should be able to:
● model relationship between existing classes
● distinguish between association, aggregation, and composition

4. Concept Map
– [objectName].[public member function]
• e1.getCount();
– [Class name].[public mem.
Static data member – access
A public static data member can be access using any object of the class or class name
– [Object Name].[name of static variable]
• e1.count;
– [Class Name] .[name of static variable]
• Employee .count;
A private static member can be access using a public member function
– [objectName].[public member function]
• e1.getCount();
– [Class name].[public member function]
• Employee.getCount();

A static method is a method that can only access static data member of class. It cannot access
non static data member of that class.

Static vs. non static functions

• Static function can only access static data member of class
• Non static member function can access static and non static data member of class

126
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

5. Homework before Lab

5.1 Practices from home

5.1.1 Task-1

Create a SavingsAccount class. Use a static data member annualInterestRate to store the annual
interest rate for each of the savers. Each member of the class contains a private data member savingsBalance
indicating the amount the saver currently has on deposit. Provide member function
calculateMonthlyInterest that calculates the monthly interest by multiplying the balance by
annualInterestRate divided by 12; this interest should be added to savingsBalance. Provide a static
member function modifyInterestRate that sets the static annualInterestRate to a new value.
Write a driver program to test class SavingsAccount. Instantiate two different objects of class
SavingsAccount, saver1 and saver2, with balances of $2000.00 and $3000.00, respectively. Set the
annualInterestRate to 3 percent. Then calculate the monthly interest and print the new balances for each of
the savers. Then set the annualInterestRate to 4 percent, calculate the next month's interest and print the
new balances for each of the savers.

6. Procedure & Tools

6.1 Tools
Visual Studio 2017.

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

Setup visual studio and make a project named “StaticExample”

6.3 Walkthrough Task [Expected time = 30

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

6.3.1 Writing Code

127
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

Figure 1: Static Example

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

6.3.3 Executing the Program

A sample output after running the program is shown below:

Figure 3: Final Output

128
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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:
\\fs\assignments$\OOP\Lab13

7.1 Practice Task 1 [Expected Time = 50 mins]

14.1 Create a Calculator class that has following methods: sum, multiply, divide, modulus , sin , cos , tan
The user should be able to call these methods without creating an object of Calculator class.

7.2 Practice Task 2 [Expected Time = 40 mins]

14.2 Create a class employee with data members as name, emp_id, salary and a static variable count. Count
should count total number of objects created for employee. In main() invoke setters and getters to take input
in attributes of employee.

7.3 Outcomes
After completing this lab, student will be able to implement the concepts static keyword.

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

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.

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

Sr. No. Task No Description Marks

1 6 Procedures and Tools 10
2 7.1 Practice tasks and Testing 55
3 8 Evaluation Tasks (Unseen) 20
4 Comments 5
5 Good Programming 10
Practices
Total Marks 100

129
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

10. Further Reading

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

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

130
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

LAB-14
Friend Functions and Friend Classes

131
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

1. Introduction
In object oriented programming one of the basic goals was to enforce encapsulation and data hiding. This
is a feature that ensures that class members are not accessible openly. We want to provide access to class
members through a regulated mechanism in which all accesses are accountable and legal.
Friend functions and friend classes provide a technique through which you can relax the access specifiers
and provide direct access. Although this seems an attractive technique but it is not liked by hardcore
programmers because of its over relaxing attitude. The concept of friend functions is still important because
they need to be used in operator overloading which will be practiced in the next lab. Hence this lab attempts
to build new concepts which will be used in the next lab.
Relevant Lecture Material
● Lecture: 11 - 12
● Textbook: Object-Oriented Programming Using C++, Fourth edition, Robert Lafore
o Pages: 468-475

2. Activity Time boxing

Table 1: Activity Time Boxing
Task Activity Name Activity time Total Time
No.

5.1 Evaluation of Design 20 mins 25 mins

6.2 Setting-up Visual Studio 5 mins 5 mins
6.3 Walkthrough Tasks 25 mins 25 mins
7 Practice tasks 25+25+30 (mins) 80 mins
8 Evaluation Task 35 mins 35 mins
Total Time 170 Minutes

3. Objective of the Experiment

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

4. Concept Map

4.1 Friend Functions

Friend functions provide a relaxing mechanism through which we can access the private data members of a class
directly. 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.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.
Friend functions are not members of a class they are just regular functions with special privileges. In order to make a

132
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

friend function you have to specify that a particular function is a friend function. This can be achieved through the
following syntax:

class second; //Forward Declaration

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

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

void display( 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;
display( obj1,obj2); //Simple calling. Cannot use the dot operator
}

In the syntax above it must be understood that access specifiers are not applicable on friend functions i.e. whether you
write the function in public or private it has no effect. Another important thing to always remember is that it is
compulsory to write the keyword friend with the function prototype but writing the friend keyword in the function
definition will result in a syntax error. In the above code the friend function is bridge between two classes using a
single function. Creating this environment is purely the programmers choice. It is not necessary that you have a
function working like a bridge. You can always have a single friend function inside a single class.
When discussing friend functions one must remember that friend functions are never part of a class. They are written
in the class to show that they have a friendship with the class. Friend functions are not called using the dot notation or
by using the scope resolution. Friend functions are called like a conventional function. Now when using the friend
function we can access both public and private data members directly as if there is no such thing as an access specifier.
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.

133
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

4.2 Friend Classes

A friend function has access to those classes with which it is friend. Sometimes a situation arises when we
want to make two classes friends with each other. This means that a class can access the public and private
members of another class directly. To achieve this you must right the friend class statement in the
befriending class.

class first
{
private:
friend class second; //Declaration of friend class
int member1;
int membern;
public:
first()
{
member1=10;
member2=20;
}
};

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

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

134
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

void main( )
{

first obj1;
second obj2;

obj2.fun( obj1); //cannot call using obj1!

15. Obj1 does not contain a function //called fun
}

5. Home Work Before Lab

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

5.1 Practices from Home

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

6. Procedure & Tools

6.1 Tools
Visual Studio 2017.

6.2 Setting-up Visual Studio 2017 [Expected time = 5

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

6.3 Walkthrough Task [Expected time = 25 mins]

Find the sum of 𝑎1 + 𝑎2 + 𝑎3 + ⋯ + 𝑎𝑛 arithmetic series. In an arithmetic series the difference between
two consecutive numbers is the same throughout the series. Your class is composed of four data members
i.e. the first entry of the series, last entry of the series, total number of entries for which sum is required and
𝑛
finally the sum up to n terms which has the formula 𝑆𝑛 = 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:

135
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

136
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

6.3.2 Compilation

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

6.3.3 Executing the Program

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

Figure 2: Final output of series project

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

7.1 Practice Task 1 [Expected time = 25 mins]

Create a class Circle having private attribute of radius. Create another class Square
having a private attribute of length. Now create a friend function that calculates the parameter
of the square, and a friend class Area that should calculate the area of both the circle and the
square?

7.2 Practice Task 2 [Expected time = 25 mins]

Your task is to create two classes namely data and calculation. The calculation class is a friend of the data
class.
The data class will be composed of two floating point data members namely a and b. The class will also be
composed of a friend function display that can display all the data members.
The calculation class is responsible for performing operations on the data class and hence it has three
functions as follows:
● A function to compute the Square of sums i.e. (𝑎 + 𝑏)2 = 𝑎2 + 𝑏 2 + 2𝑎𝑏

137
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

● A function to compute the Square of difference i.e. (𝑎 − 𝑏)2 = 𝑎2 + 𝑏 2 − 2𝑎𝑏

7.3 Practice Task 3 [Expected time = 30 mins]

Your task is to create a class named equation which will have the data members a and b which are the
coefficients of the equation. The class will have three more data members namely result1, result2 and result3
which will store the computed value of equations. Suppose that variables a and b are integers.

● Setters and Getters.

● Then design a friend function which will determine the reults of all three equations.
● Create another friend function which will display the result.

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

7.5 Testing

Test Cases for Practice Task-2

Sample Inputs Sample Outputs
a=1 (𝑎 + 𝑏)3 =8
b=1 (𝑎 − 𝑏)3 = 0

Test Cases for Practice Task-3

Sample Inputs Sample Outputs

a =1; proot= 1
b =2; nroot = -3
c =-3

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

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

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

138
Department of Computer Science/ Software Engineering
Faculty of Computing, Capital University of Science and Technology

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

Table 3: Evaluation of the Lab

Sr. Task No Description Marks

No.
1 4.1 Problem Modelling 10
2 6 Procedures and Tools 5
3 7.1 Practice task 1 with 15
Testing
4 7.2 Practice task 2 with 20
Testing
5 7.3 Practice task 3 with 25
Testing
6 8 Evaluation Tasks 20
(Unseen)
7 Good Programming 5
Practices
Total Marks 100

10. Further Reading

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

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

139