CC-211L

Object Oriented Programming

Laboratory 02

Introduction to C++ (II):

(Constructors and other Member Functions)

Version: 1.0.0

Release Date: 19-01-2023

Department of Information Technology

University of the Punjab
Lahore, Pakistan
CC-211L Object Oriented Programming FALL 2022

Contents:
● Learning Objectives
● Required Resources
● General Instructions
● Background and Overview
o Class & Objects
o Comparison between Class and Object
o Encapsulation
o Abstraction
● Activities
o Pre-Lab Activity
▪ Introduction to Getter/Setter Member Functions
▪ Example code on Getter and Setter Member Functions
▪ Explanation of Public-private access specifiers
▪ Demonstration of Encapsulation and Abstraction using Getter/Setter functions
▪ Application of Access Specifiers in a sample program
o In-Lab Activity
▪ Constructor
▪ Default Constructor
▪ Example Code on Default Constructor
▪ Parameterized Constructor
▪ Example Code on Parameterized Constructor
▪ Copy Constructor
▪ Overloaded Constructor
▪ Example Code on Overloaded Constructor
▪ Destructor
▪ Example code on Destructor
▪ Task 1: Class Definition and Implementation
▪ Task 2: Constructor Implementation
▪ Task 3: Constructor Implementation
▪ Task 4: Constructor Implementation
o Post-Lab Activity
▪ Inline Functions
▪ Inline Functions with Classes
▪ Function Overloading
▪ Task 01: Inline functions
▪ Task 02: Function Overloading
● Submissions
● Evaluations Metric
● References and Additional Material
● Lab Time and Activity Simulation Log

Laboratory 02 – Constructors and other Member Functions Page 2 of 24

CC-211L Object Oriented Programming FALL 2022

Learning Objectives:
● Understanding Encapsulation and Abstraction
● Getter/Setter Member Functions
● Public private access specifiers
● Constructors
● Overloaded Constructor
● Default Constructor
● Destructor
● Inline Functions
● Function Overloading

Resources Required:
• Desktop Computer or Laptop
• Microsoft ® Visual Studio 2022

General Instructions:
• In this Lab, you are NOT allowed to discuss your solution with your colleagues, even not
allowed to ask how is s/he doing, this may result in negative marking. You can ONLY discuss
with your Teaching Assistants (TAs) or Lab Instructor.
• Your TAs will be available in the Lab for your help. Alternatively, you can send your queries
via email to one of the followings.

Teachers:
Course Instructor Prof. Dr. Syed Waqar ul Qounain [email protected]
Lab Instructor Azka Saddiqa [email protected]

Saad Rahman [email protected]

Teacher Assistants
Zain Ali Shan [email protected]

Laboratory 02 – Constructors and other Member Functions Page 3 of 24

CC-211L Object Oriented Programming FALL 2022

Background and Overview:

Class:
A class is an important concept in Object Oriented Programming (OOP). It is a blueprint that is used
to create objects, which can hold data and perform functions. A class is made up of two parts:
attributes and methods. Attributes are the properties of the class that describe its characteristics, such
as its name, size, and color. Methods are the functions that the class can perform, such as adding,
deleting, or editing data. Classes are reusable and allow for code to be written more efficiently. They
are also a key tool for creating complex applications.
Object:
Objects are instances of classes, which are templates for creating objects. Objects have properties and
methods that define their state and behavior, respectively. It is a self-contained entity that contains
both data and instructions for manipulating that data. Objects are used in object-oriented
programming (OOP) to represent real-world entities such as people, places, and things. Objects
contain data and methods that describe the object's characteristics and behavior. The data is stored in
the form of properties, while the methods are functions that can access and modify the object's data.
Comparison Between class and object:
Objects are often referred to as the "nouns" of programming, while classes are the "verbs". Objects are
tangible, physical objects in the real world, while classes are abstract concepts that define how objects
should behave
Abstraction:
Abstraction in C++ is the process of hiding the implementation details from the user. It allows the user
to focus on the functionality of an object without worrying about its internal implementation.
Abstraction is achieved in C++ through the use of classes and objects, which can be used to define data
and functions that can be used to manipulate the data. By hiding the implementation details, the user is
able to use the object without having to worry about its internal working. This helps make code easier
to understand and maintain.
Encapsulation:
Encapsulation in C++ is the process of combining data and functions into a single unit, called a class.
This process allows data and functions to be accessed and used together while keeping the data hidden
from outside users. Encapsulation is a powerful concept that helps keep code organized, secure, and
manageable. By using encapsulation, developers can define the interactions between different parts of
a program in a clear and concise way. This helps to reduce potential errors and maintain the program's
functionality over time.
.

Laboratory 02 – Constructors and other Member Functions Page 4 of 24

CC-211L Object Oriented Programming FALL 2022

Activities:
Pre-Lab Activities:
Overview of the Getter/Setter Member Functions:
Getter/Setter member functions are used to control access to class data members in C++. Getters are
used to retrieve data from the class, and setters are used to assign values to the class. They allow for the
encapsulation of data within a class, which makes it easier to manage class data and ensures that data
is used correctly.
Example:
For example, if a class has a data member called "age", it is best to create a getter and setter function
for that data member. The getter function would return the age of the class object, and the setter function
would allow us to set the age of the class object. This way, we can ensure that the data member is being
properly used and make sure it is not being passed invalid data.
Syntax of Getters and Setters in C++:
Getter:
The syntax of Getter method is as follows
Type ClassName::getPropertyName(){
return propertyName;
}
Setter:
The syntax of Setter method is as follows
void ClassName::setPropertyName(Type propertyName){
this->propertyName = propertyName;
}
Example Code:

Fig. 01 (Getter and Setter Demonstration)

Laboratory 02 – Constructors and other Member Functions Page 5 of 24

CC-211L Object Oriented Programming FALL 2022

Output:

Fig. 02 (Output with respect to figure 1)

Some Key points about getter and setter methods:
● Getters and setters are used to access private member variables of a class from outside the class.
● Getters and setters should be used to ensure data integrity in the class by validating the input
data and restricting access to certain areas of the class.
● Getters and setters should not be used to perform business logic or complex operations on
private member variables.
● Getters should always return a copy of the private member variable and not the variable itself.
● Setters should always be used to modify the private member variable and not perform any other
operations on the variable.
● Getters and setters should have meaningful names that clearly describe the purpose of the
methods.
● Getters and setters should be declared as public methods of the class.

When to Use Getters and Setters in C++:

Getters and setters should be used when you want to maintain control over how users access and set the
data members of a class. This allows you to control how the data is accessed and can be used to validate
user input before setting a value or to perform calculations based on user input before setting a value.
Getters and setters also make it easier to maintain the code, as the logic for how the data is accessed
and set is self-contained.

Public/Private Access Specifiers:

Access Specifiers:
Access specifiers in C++ can be used to control the access level of the data members of a class. The
three access specifiers used in C++ are public, protected, and private. In this introduction, we will
discuss the purpose of public and private access specifiers and how to use them in C++.
Public Access Specifiers:
Public data members can be accessed and modified from anywhere within the program. To make a
member of a class public, use the keyword “public” before the member declaration.
Private Access Specifiers:
Private data members can only be accessed and modified by the member functions of the class. They
cannot be accessed or modified from outside the class. To make a member of a class private, use the
keyword “private” before the member declaration.

Laboratory 02 – Constructors and other Member Functions Page 6 of 24

CC-211L Object Oriented Programming FALL 2022

How to Use Public and Private Access Specifiers:

Example Code for Public and Private Access Specifiers:

Fig. 03 (Public and Private Access Specifiers)

Output:

Fig. 04 (Output for figure 3)

Laboratory 02 – Constructors and other Member Functions Page 7 of 24

CC-211L Object Oriented Programming FALL 2022

Demonstration of Encapsulation and Abstraction using Getter/Setter functions

The demonstration of the encapsulation and abstraction using getter and setter functions is given in the
code below:

Fig. 05 (Demonstration of Encapsulation and Abstraction using Getter/Setter functions)

Output:

Fig. 06 (Output for figure 5)

Laboratory 02 – Constructors and other Member Functions Page 8 of 24

CC-211L Object Oriented Programming FALL 2022

Task 01: Calculate the sum of alphabets [Estimated 10 minutes / 10 marks]

Suppose alphabets have numbers like A=a=1, B=b=2, up to Z=z=26.
Input a string from the user and check whether the sum of values of all alphabets occur in the
sequence i(i+1)/2. If yes then print “True” else print “False”.
For example, for string abc: 1+2+3=6

Input Expected Output

Enter a string: Abc True

Enter a string: Jebd True

Enter a string: dd False

Task 02: Creating A Program with Classes and Objects [Estimated 20 minutes / 15 marks]
Write a C++ program that uses classes and objects to calculate the area of a rectangle, circle, or square
based on the user's choice and the dimensions they provide. The concept of encapsulation, abstraction
should be represented clearly in your code (implementation of getters/setters). Your code should follow
all the coding conventions.
Expected Output:

Fig. 07 (Expected Output for Task 1)

Laboratory 02 – Constructors and other Member Functions Page 9 of 24

CC-211L Object Oriented Programming FALL 2022

In-Lab Activities:
Constructors:
Constructors in C++ are special class functions that are used to initialize objects. They are
automatically called when an object is created. There are three types of constructors in C++:
● Default Constructor:
The default constructor is a constructor that takes no parameters, or default values may be provided. It
is automatically called when an object is created.
Example Code:

Fig. 08 (Default Constructor)

Output:

Fig. 09 (Output with respect to figure 8)

Laboratory 02 – Constructors and other Member Functions Page 10 of 24

CC-211L Object Oriented Programming FALL 2022

● Parameterized Constructor:
The parameterized constructor is a constructor that takes parameters and initializes the object with the
given values.
Example Code:

Fig. 10 (Parameterized Constructor)

Output:

Fig. 11 (Output with respect to figure 10)

Laboratory 02 – Constructors and other Member Functions Page 11 of 24

CC-211L Object Oriented Programming FALL 2022

● Copy Constructor:
The copy constructor is a constructor that creates a new object by copying the values of an existing
object. It is used to create a new object based on an existing object. The details are out of scope for
this laboratory manual.
Overloaded Constructors:
Overloaded constructors in C++ provide developers with the ability to create multiple constructors
with different parameters and different implementations. This makes it easier to create objects with
different initial states.
Example:
For example, consider a Car class with the following two constructors:
Car()
Car(int numberOfDoors)
The first constructor is the default constructor which initializes the car with the default values. The
second constructor takes a parameter and initializes the car with the provided number of doors. This
allows a developer to create a car with the default values or one with the number of doors specified as
a parameter.
Another use of overloaded constructors is to create objects with different numbers of parameters. This
allows for more flexibility when creating objects. For example, a Car class could have the following
three constructors:
Car()
Car(int numberOfDoors)
Car(int numberOfDoors, string color)
With these three constructors, developers can create cars with the default values, with a specified
number of doors, or with a specified number of doors and color.
Overall, overloaded constructors in C++ provide developers with the ability to create multiple
constructors with different parameters and different implementations. This makes it easier to create
objects with different initial states, and can be a powerful tool when creating classes.

Laboratory 02 – Constructors and other Member Functions Page 12 of 24

CC-211L Object Oriented Programming FALL 2022

Example Code:

Fig. 12 (Overloaded Constructor)

Output:

Fig. 13 (Output with respect to figure 12)

Destructor:
A destructor is a special member function of a class that is used to release the memory held by an object
of that class, just before it is destroyed. This usually happens when the object goes out of scope, or
when the delete operator is used to explicitly delete the object. The destructor has the same name as the
class, preceded by a tilde (~). The destructor has no return type and no parameters. Because it is not
called explicitly, it is important for the destructor to be declared in the public section of the class.

Laboratory 02 – Constructors and other Member Functions Page 13 of 24

CC-211L Object Oriented Programming FALL 2022

Example Code:

Fig. 14 (Destructor)
Output:

Fig. 15 (Output with respect to figure 14)

When the object a goes out of scope, the destructor ~A() is automatically called and the statement
“Destructor called” is printed.

Laboratory 02 – Constructors and other Member Functions Page 14 of 24

CC-211L Object Oriented Programming FALL 2022

Task 01: Class Definition and Implementation [Estimated 20 minutes / 10 marks]

Create a class called Vehicle with the following properties:

• Data Members:
o A string named as company.
o A string named as fuelType.
o An integer named as yearOfManufacture.
o A string named as yearOfPurchase.
o A string named as color.
o An integer named as engineCapacity.
• Your class should provide the implementation of a default constructor that first prints a line
“Default Constructor of Vehicle is called” and then initializes all the data members with the
default values (Default value for integer and string variables are 0 and “”).
• Provide the implementation of appropriate properties method (Getter/Accessors and
Setters/Mutators).
• Provide the implementation of following data functions:
o displayDetails(): displays all the information of the particular vehicle on console.
o inputDetails(): takes the input of all the details of vehicle from the user.
o isOld(): displays that how Old the vehicle is. If the manufacturing and purchasing year
is the same, then display “vehicle is purchased in the same year as it is manufactures”,
otherwise displays the message “vehicle is years old”.
• Provide the implementation of appropriate destructor that displays the message “Destructor
Called”
Task 02: Class with Constructor Implementation [Estimated 20 minutes / 10 marks]
Write a class named Employee for which each object can hold information about a particular employee:

• The class should have following four private data members

o A string named name that holds the employee’s name.
o An integer named id that holds the employee’s ID number.
o A string named department that holds the name of the department where the employee
works.
o A string named position that holds the employee’s job title.
• Provide the implementation of following constructors and a destructor
o A parameterized constructor that accepts employee’s name, employee’s ID number,
department, and position as arguments and assigns them to the appropriate member
variables.
o A parameterized constructor that accepts employee’s name and ID number as
arguments and assigns them to the appropriate member variables. The department and
position fields should be assigned an empty string ("").
o A default constructor that assigns empty string ("") to the name, department, and
position member variables, and 0 to the id member variable.
o A destructor that do nothing except displaying a simple message “Destructor
executed…” on the screen.
• Provide the implementation of properties methods (get/set) for all the data members (name,
id, department and position) of the class.
• Provide the implementation of following member functions
o setInfo(): method accepts employee’s name, employee’s ID number, department, and
position as arguments and assigns them to the appropriate member variables.
o getInfo() method to initialize the data of an employee taken from the user.

Laboratory 02 – Constructors and other Member Functions Page 15 of 24

CC-211L Object Oriented Programming FALL 2022

o printInfo() method to display the information of a particular employee.

o convert_caps() method that changes the case of all the string data members. For
instance, if the data of the employee is in lowercase then after calling this function, it
should be in uppercase.
• Write a test program to demonstrate Employee’s capabilities. Make sure to test every single
functionality in the driver program.
Task 03: Constructor Implementation [Estimated 25 minutes / 15 marks]
Write a class named Bus that has the following characteristic:

• The class should have following three private data members

o A string named busNo that holds the license number.
o A string named owner that holds the owner’s name of the school bus.
o An integer named capacity that holds the students’ capacity inside bus.
• Provide the implementation of appropriate constructors and a destructor.
o A default constructor that assigns empty string ("") to the name, department, and
position member variables, and 0 to the id member variable.
o A parameterized constructor should accept the license number and owner as arguments
and assign it to the respective member variables. The constructor should also assign 0
to the capacity member variable.
o A parameterized constructor should accept the license number, owner and capacity as
arguments and assign it to the respective member variables.
o A destructor that do nothing except displaying a simple message “Destructor is
executed...”
• Provide the implementation of appropriate accessor/getters functions to get the values stored
in an object’s busNo, owner, and capacity member variables.
• Provide the implementation of appropriate mutator/setters functions to set the values of
object’s busNo, owner, and capacity member variables.
• Provide the implementation of following member functions:
o setBus(): accepts busNo, owner, and capacity as arguments and assigns them to the
appropriate member variables.
o getBus(): method to initialize the data of a bus taken from the user.
o putBus(): method to display the information of a particular bus.
o bookBus(): method adds 1 to the capacity member variable each time it is called.
o cancelBooking(): method subtract 1 from the capacity member variable each time it is
called.
• Test all of your functions in main function, and also creates three objects of Bus with following
data and display it in following format:
Bus No Owner Capacity
LHR 3216 Bilal Travels 20
KHI 3317 Hamza Travels 22
FSD 5467 Hassan Travels 18

• Make sure to check the functionality of bookBus() and cancelBooking() after creating three
different objects.

Laboratory 02 – Constructors and other Member Functions Page 16 of 24

CC-211L Object Oriented Programming FALL 2022

Task 4: Constructor Implementation [Estimated 40 minutes / 30 marks]

a) Design a class of Circle with at least three data members: radius, originx, and originy. Origin
is a central point of a circle and radius is the distance between the central point and the boundary
of a circle. Since the origin is a point therefore it can be modeled with x and y coordinates.
Provide the implementation of default, parameterized constructor and destructor. Provide the
implementation of appropriate getters/setters. Write down the appropriate data functions that
finds the area, diameter, and circumference of a circle. The area, circumference, and diameter
can be calculated using the following formulas, respectively:
o Area=pie*radius*radius
o Circumference=2*pie*radius
o Diameter=radius/2
All the inputs should be taken from the user in the main function to set data members of the
class and then relevant member functions of the class should be called to find area,
circumference, diameter. Main function should only call relevant methods.
b) Create 4 circles and initialize them using the parameterized constructor (you can hardcode
values while calling the constructor).
o Find and display which of the circles are concentric. That is, circles having the same
central point (as shown below). (Hint: the logic for this will be implemented in main())

c) For the identified concentric circles,

o find the label for each circle. The label is the position number (as shown above; the
most internal circle has label 1, and so on... In the end, also display the labels that you
assigned. (Hint: the logic for this will be implemented in main())
d) Find and display:
o which of the concentric circle has a diameter greater than 12. You must differentiate
the relationship between the diameter and radius of any circle. (Hint: the logic for this
will be implemented in main())

Laboratory 02 – Constructors and other Member Functions Page 17 of 24

CC-211L Object Oriented Programming FALL 2022

Output:

Fig. 16 (Expected output of Task 4)

Laboratory 02 – Constructors and other Member Functions Page 18 of 24

CC-211L Object Oriented Programming FALL 2022

Post-Lab Activities:
Inline Functions:
Implementing a program as a set of functions is good from a software engineering stand point, but
function calls involve execution-time overhead. C++ provides inline functions to help reduce function-
call overhead. Placing the qualifier inline before a function’s return type in the function definition
advises the compiler to generate a copy of the function’s body code in every place where the function
is called (when appropriate) to avoid a function call. This often makes the program larger. The compiler
can ignore the inline qualifier and generally does so for all but the smallest functions. Reusable inline
functions are typically placed in headers, so that their definitions can be included in each source file
that uses them.
Syntax to create an inline function:
inline return-type function-name(parameters)
{ // function code }
Advantages of using Inline functions:
• Function call overhead doesn’t occur.
• It also saves the overhead of push/pop variables on the stack when function is called.
• It also saves overhead of a return call from a function.
• When you inline a function, you may enable compiler to perform context specific optimization
on the body of function. Such optimizations are not possible for normal function calls. Other
optimizations can be obtained by considering the flows of calling context and the called context.
• Inline function may be useful (if it is small) for embedded systems because inline can yield less
code than the function call preamble and return.
Example of Inline Function:

Fig. 17 (An Inline Function)

Output:

Fig. 18 (Output w.r.t Fig. 17)

Laboratory 02 – Constructors and other Member Functions Page 19 of 24

CC-211L Object Oriented Programming FALL 2022

Inline function and classes:

It is also possible to define the inline function inside the class. In fact, all the functions defined inside
the class are implicitly inline. Thus, all the restrictions of inline functions are also applied here. If you
need to explicitly declare inline function in the class then just declare the function inside the class and
define it outside the class using inline keyword.
Example

Fig. 19 (Inline Function with classes)

Output:

Fig. 20 (output w.r.t Fig.19)

Function Overloading:
Function overloading is a feature of object-oriented programming where two or more functions can
have the same name but different parameters. When a function name is overloaded with different jobs
it is called Function Overloading. In Function Overloading “Function” name should be the same and
the arguments should be different. Function overloading can be considered as an example of a
polymorphism feature in C++ which will be after midterm.
The parameters should follow any one or more than one of the following conditions for Function
overloading:
1) Parameters should have a different type.
2) Parameters should have a different number.

Laboratory 02 – Constructors and other Member Functions Page 20 of 24

CC-211L Object Oriented Programming FALL 2022

Example of (1)

Fig. 21 (Function Overloading with different data type of arguments)

Output:

Fig. 22 (Output w.r.t Fig. 21)

Example of (2)

Fig. 23 (Function overloading with different no of parameters)

Output:

Fig. 24 (Output w.r.t Fig. 23)

Task 1: 1 Inline Functions [Estimated 10 minutes / 10 marks]
Write a class IntegerCalculator that performs the all operations over integer data.

Laboratory 02 – Constructors and other Member Functions Page 21 of 24

CC-211L Object Oriented Programming FALL 2022

• The class should have two data members

o firstNo of type integer that holds first number.
o secondNo of type integer that holds second number.
• The class should have the following data functions
o Input(): take input from the user.
o Output(): display the output to the user.
o add() : return the addition of the two numbers.
o substract() : return the subtraction of the two numbers.
o multiply() : return the multiplication of the two numbers.
o divide() : return the division of the two numbers.
o modulus(): return the remainder of the two numbers.
o power(): return the power of the first number by second number.
o square_root(): return the square root of second number w.r.t first number.
• Make sure to use the concept of inline functions.
• Test your functionality in the main function. Make sure to test each and every function.

Task 2: Function overloading [Estimated 10 minutes / 10 marks]

Write a C++ program that asks a user to perform one of the 8 options, addition for integers, addition for
the doubles, subtraction for integers, subtraction for doubles, addition of integer and double, subtraction
of integer and double and it’s vice versa. After this, assume that user has to input two numbers. User is
now free to enter numbers from any type(integer, double), hence, it can be both integers, one integer
one double, both doubles and so on. After this, call the respective overloaded function and display
result. You have to create the all the possible overloaded functions for the addition () and subtraction
() functionality This cycle is repeated every time, until the user presses -1 to exit.

Submissions:
● For In-Lab Activity:
▪ Save the files on your PC.
▪ TA’s will evaluate the tasks.
● For Pre-Lab & Post-Lab Activity:
▪ Submit the .cpp file on Google Classroom and name it to your roll no.

Evaluations Metric:
● All the lab tasks will be evaluated by TA’s
● Division of Pre-Lab marks: [25 marks]
▪ Task 01: C++ Strings Problem solving [10 marks]
▪ Task 02: Class and Object Basics [15 marks]
● Division of In-Lab marks: [55 marks]
▪ Task 01: Class Definition and Implementation [10 marks]
▪ Task 02: Constructor Implementation [10 marks]
▪ Task 03: Constructor Implementation [15 marks]
▪ Task 04: Constructor Implementation [30 marks]
● Division of Post-Lab marks: [20 marks]
▪ Task 01: [10 marks]
▪ Task 02: [10 marks]

Laboratory 02 – Constructors and other Member Functions Page 22 of 24

CC-211L Object Oriented Programming FALL 2022

References and Additional Material:

● Classes and Objects in C++
https://www.programiz.com/cpp-programming/object-class

● Constructors
https://www.programiz.com/cpp-programming/constructors

● Objects and Functions

https://www.programiz.com/cpp-programming/pass-return-object-function
● Inline Functions
https://www.programiz.com/cpp-programming/inline-function

Laboratory 02 – Constructors and other Member Functions Page 23 of 24

CC-211L Object Oriented Programming FALL 2022

Lab Time Activity Simulation Log:

● Slot – 01 – 00:00 – 00:15: Class Settlement
● Slot – 02 – 00:15 – 00:25: Discussion on pre-lab task
● Slot – 03 – 00:25 – 00:45: In-Lab task
● Slot – 04 – 00:45 – 01:00: In-Lab Task
● Slot – 05 – 01:00 – 01:25: In-Lab Task
● Slot – 06 – 01:25 – 02:15: In-Lab Task
● Slot – 07 – 02:15 – 02:30: Discussion on Post-Lab Task
● Slot – 08 – 02:30 – 03:00: Evaluation by TAs

Laboratory 02 – Constructors and other Member Functions Page 24 of 24