Introduction to Object Oriented Programming

OOP programs can be viewed as a collection of interacting objects. The objects this collection
react upon receipt of messages, changing their state according to invocation of methods which
might cause other messages sent to other objects. This is illustrated in below.

Object 1

Object 2
Object 4

Program Object 3

Abstraction
This refers to the act of representing essential features without including the background details
or explanations.
Classes use the concept of abstraction and are defined as a list of abstract attributes such as size,
weight and cost, and functions to operate on these attributes. They encapsulate all the essential
properties of the objects that are to be created. The attributes are sometimes called data members
because they hold information. The functions that operate on these data are sometimes called
methods or member functions
Note: since the classes use the concept of data abstraction, they are known as Abstract Data
Types (ADT)

Abstract Data Types

Each ADT description consists of two parts
i) Data: This part describes the structure of the data used in the ADT in an informal
way.
ii) Operations: This part describes valid operations for the ADT, hence it describes its
interface. The constructor is used to describe the operations to be performed once
an entity of the ADT is created while a destructor is used to describe the actions to
be performed once an entity is destroyed

Abstract Data Types and Object-Orientation

ADTs allows the creation of instances with well-defined properties and behaviour. In object-
orientation ADTs are referred to as classes . Therefore a class defines properties of objects
which are the instances in an object-oriented environment.

SMA2176 Computer Programming II Notes ~ A. Kamau Page 1 of 16

Definitions:
A class is the implementation of an abstract data type (ADT). It defines attributes and methods
which implement the data structure and operations of the ADT, respectively.

An object is an instance of a class. It can be uniquely identified by its name and it defines a state
which is represented by the values of its attributes at a particular time.

The behaviour of an object is defined by the set of methods which can be applied on it.

A message is a request to an object to invoke one of its methods. A message therefore contains
the name of the method and the arguments of the method.

A method is associated with a class. An object invokes a method as a reaction to receipt of a

message.

Attribute is a property of object. It cannot exist independently of the object. Attribute may take
other objects as values. It has a type. It describes the range of values that that property may hold.
Definition and Declaration of classes
User-defined data types must be defined before variables may be created of that type.
Definitions have the following parts:

Syntax:

class TagName // head

{
// data declaration

// operations declaration

}; //definition is now complete

A declaration of a class type uses just the head of the definition.

Class TagName;

Access Modifiers
In order to enforce data hiding, 3 different access regions could be defined.
• Private -- only member functions of the class can access the private data.
• Public -- no restrictions to access. Functions defined anywhere have access to public
members.
• Protected -- only member functions of the class and member functions of derived
classes can access the protected data.

SMA2176 Computer Programming II Notes ~ A. Kamau Page 2 of 16

 Specifying the Access Region
class A{
private: // this is optional since private is default
private members declared here
public:
public members here
};
Defining Member Functions within the Class Definition
When a member function is defined within the class definition, it is implicitly inlined, however,
it is more common to define the member functions outside of the class definition.
Defining Member Functions outside the Class Definition
When member functions are defined outside the class definition, you need to use the class scope
quantifier (::) at the point of definition.
The left operand of the:: operator is the class name to which the function belongs, while the right
operand is the identifier of the function.

Constructors
Constructors are special member functions that are automatically called when an object is
created. Constructors are used to initialise the data members of the object. They provide
guaranteed initialisation of the data contained within an object declared to be of a given class.
Constructors may not be called explicitly through an object.
When using a C++ constructor, note the following important aspects:
• The declaration of the object activates the initialisation specified in the constructor.
• A constructor's identifier is the same as the class's tag name.
• Constructors may not return a value or declare any return type, not even void.
• If only one constructor is declared and it takes two arguments, you must provide two
values when declaring an object of that type. If a constructor exists, it will be invoked
when an object is declared.
The general form of a constructor is shown below:
class_name()
{
//constructor code;
}
There are three types of constructors:
i). The default constructor
ii). User-defined constructor
iii). The Copy constructor

SMA2176 Computer Programming II Notes ~ A. Kamau Page 3 of 16

 i). Default constructor
Is a constructor that takes no arguments/parameters and performs no processing other than the
reservation of the memory. The default constructor is always called by the compiler if no other
user defined constructor is provided. Usually it is not referred by the programmer in the class
definition.

ii). User-defined constructor

It is a constructor method defined explicitly if parameters or initialization processing are required
when an object is created. It is possible to have more than one constructor in a class provided
that the difference versions are defined by differences in the parameter list (i.e. constructor
overloading)

iii). Copy Constructor

It is a constructor that allows initialization. Examples of initialization are:
• an object is declared and initialised with the contents of another existing object.
• an object is passed as a parameter to a function.
E.g. The following illustrates a copy constructor, which passes only one parameter which is the
object that it is going to be used to copy. Note that the object is passed by constant reference
because it should not be changed.
Construct::Construct (const Construct &rv)
{
a=rv.a; b=rv.b; c=rv.c;
}

The object is created as follows using the copy constructor created above

Construct a(12,14,16); //create object a using a user-defined constructor

Construct b(a); //create object b using a copy constructor
Construct *c = new Construct (b); // copy constructor

Example:
a). Create a C++ class that for a bank account abstract data type. It should have the attributes of
account number (an integer), account holder (a string) and current balance (a float). Define
methods to return the values of these attributes and set them using parameters. Add two
more methods to allow deposit and withdrawal updating the current balance as appropriate.
Include a constructor that enables any new account to be opened with an initial balance of
10,000 shillings.

b). Write a C++ program that implements the above class. The class should enable the user to
the following tasks.
1. Enter the name of the account holder and the account number
2. Allow the user to deposit or withdrawal by displaying an appropriate message
3. Display the user details in an appropriate form.

SMA2176 Computer Programming II Notes ~ A. Kamau Page 4 of 16

Solution
#include<iostream>
#include<iomanip>
#include<cstring>
#include<cstdlib>
using namespace std;
class BankAccount{
public:

//Constructor
BankAccount();
//Accessor methods
int getAccountNumber()const;
char* getAccountHolder();
double getCurrentBalance()const;

void setAccountNumber(int);
void setAccoutHolder(char[],int);
void Deposit(double);
void Withdrawal(double);
private:
int account_number;
char account_holder[20];
double current_balance;
};
//Methods Defination
BankAccount::BankAccount()
{
current_balance=10000;
}
int BankAccount::getAccountNumber()const
{
return account_number;
}
char* BankAccount::getAccountHolder()
{
return account_holder;
}
double BankAccount::getCurrentBalance()const
{
return current_balance;
}
void BankAccount::setAccountNumber(int number)
{
account_number=number;
SMA2176 Computer Programming II Notes ~ A. Kamau Page 5 of 16
}
void BankAccount::setAccoutHolder(char name[],int n)
{
strncpy(account_holder,name,n-1);
account_holder[n-1]='\0';

}
void BankAccount::Deposit(double amount)
{
current_balance=current_balance+amount;
}
void BankAccount::Withdrawal(double amount)
{
current_balance=current_balance-amount;
}
//Client Program
int main()
{
char surname[20];
int account,choice;
double dep,withd;
BankAccount client;
cout<<"\nEnter the Account Number"<<endl;
cin>>account;
cout<<"\nEnter the Account holder name"<<endl;
cin>>surname;
client.setAccountNumber(account);
client.setAccoutHolder(surname,20);
system("CLS");
cout<<"Menu Operations"<<endl;
cout<<" 1 Deposit "<<endl;
cout<<" 2 Withdrawal "<<endl;
cout<<" 3 Exit"<<endl;
cout<<"\nEnter your Choice"<<endl;
cin>>choice;
if(choice==1)
{
cout<<"\n Enter amount to Deposit"<<endl;
cin>>dep;
client.Deposit(dep);
}
else
{
cout<<"\n Enter amount to Withdraw"<<endl;
cin>>withd;
client.Withdrawal(withd);

SMA2176 Computer Programming II Notes ~ A. Kamau Page 6 of 16

 }
cout<<"\nDisplay the account details"<<endl;
cout<<"Account number is :"<<client.getAccountNumber()<<endl;
cout<<"Account Holder is : "<<client.getAccountHolder()<<endl;
cout<<"The Current Balance is : "<<client.getCurrentBalance()<<endl;
return 0;

Parameterized Constructors
These are constructors that take arguments. A parameterized should be defined with parameters
and then it can either be called explicitly or implicitly as shown below:

BankAccount client= BankAccount(10000); //explicit call

BankAccount client(10000); // implicit call

Overloading constructors
Like any other function, a constructor can also be overloaded with several other functions that
have the same name but with different type or number of parameters.

Exercise
Write a program that has a class called circle from which two circles, c1 and c2 are created such
that c2 does not pass any argument to the constructor yet its radius value is initialized to 10 and
c1 passes 20 as the radius. The class should have an inline function to calculate the area of the
two circles which should then be displayed by the main function.

Constructor Initialization List

The initialization list is used in a constructor for initializing object members data. E.g. the
following constructor can be written as follows using the constructor initialization list
// Constructor
class Rectangle{ int
length,width;
Rectangle(int l, int w)
{
length=l;
width=w;
}
……………
……………
};

// using constructor initialization list

class Rectangle{
int length,width;
Rectangle(int l, int w): length(l), width(w){}
……………

SMA2176 Computer Programming II Notes ~ A. Kamau Page 7 of 16

 ……………
};
Note
The initialisation list syntax is required when class data members are:
i). constant data type
ii). reference data type
iii). another class object that has a constructor and either the constructor requires
parameters or we want to override the default values.

Destructors
A destructor is the compliment of a constructor. It has the same name as the constructor, but is
preceded by a tilde (~). Just like a constructor, it does not have a return type. It is automatically
called when an object is released from memory, either because its scope of existence has finished
(for example, if it was defined as a local object within a function and the function ends) or when
an object is dynamically assigned and released using operator delete.
Note that there can be no overloading of a destructor i.e. destructors may not take any arguments.
Therefore, there may be only one destructor per class.

Example
Create a class called rectangle that stores the length and width of a rectangle in two private
instance variables. Include a constructor that sets these values and a destructor which is used to
release the object created from the memory. Define a member function, display (), which returns
the area of the rectangle. Have both the object and the instance variables to be dynamically
created.

# include<iostream>
using namespace std;
class Rect
{
public:
Rect(int,int);
~Rect();
int Display(){return *length * *width;}
private:
int *length,*width;
};

Rect::Rect(int l,int w)
{
length= new int;
width=new int;
*length=l;
*width=w;
}
Rect::~Rect()
{

SMA2176 Computer Programming II Notes ~ A. Kamau Page 8 of 16

 delete length;
delete width;
}

int main()
{
Rect *rec1=new Rect(5,4);
Rect *rec2=new Rect(4,3);
cout<<"The area of rectangle one is :"<<rec1->Display()<<endl;
cout<<"The area of rectangle one is :"<<rec2->Display()<<endl;
delete rec1;
delete rec2;
return 0;
}

Constant Member Functions

These are member functions (methods) that cannot change the value of any member of the
class. Constant member functions are defined using the keyword const, which is placed in the
header of the member function.
Syntax
return_type function_name (parameter list) const
{
Statement (s)
}

Static Data Members

A data member of a class can be qualified as static. The properties of a static member variable
are as follows:
• It is initialized to zero when the object of the class is created.
• Only one copy of that member is created for the entire class and is shared by all the
objects of that class, no matter how many objects are created.
• It is visible only within the class, but its lifetime is the entire program.
Generally they are used to maintain values common to the entire class. E.g. a static data member
can be used as a counter that records the occurrences of all the objects an illustrated by the
following program:
#include<iostream>
#include<iomanip>
using namespace std;
class Item
{
static int count;
int number;
public:
void getData(int a){
number=a;
SMA2176 Computer Programming II Notes ~ A. Kamau Page 9 of 16
 count++;
}
void getCount(){
cout<<"Count:"<<count<<endl;
}
};
//definition of the static data member
int Item::count;
int main()
{
Item a,b,c;
a.getCount();
b.getCount();
c.getCount();

a.getData(100);
b.getData(200);
c.getData(300);

cout<<"After reading data"<<endl;

a.getCount();
b.getCount();
c.getCount();
return 0;
} /* end of main */

Expected output from the program:

Count: 0
Count: 0
Count: 0
After reading data
Count: 3
Count: 3
Count: 3

The type and scope of each static member variable must be defined outside the class definition.
This is necessary since because the static data members are stored separately rather than as a part
of an object. Since they are associated with the class itself rather with any class object, they are
also known as class variables.
From the above program, the static count is initialized to zero when the objects are created. Then
count is incremented whenever data is read into the object. Since data is read three times, count
will be incremented three times. However since only one copy of count is shared by all the three
objects, all the three output statements cause the value 3 to be displayed

SMA2176 Computer Programming II Notes ~ A. Kamau Page 10 of 16

Static Data Functions
They have the following characteristics:
i) Can have access to only static members (data or functions) declared in the same class.
ii) Member functions can be called using class name (instead of objects) as follows:
class_name::function_name

Example:
The following is a C++ program that uses a static member function showCount() to display the
number of objects created at any given moment. The member function showCode displays the
code number of each object.

#include<iomanip>
using namespace std;
class Test
{
int code;
static int count;
public:
void setCode(){
code=++count;
}
void showCode(){
cout<<"Object number:"<<code<<endl;
}
static void showCount(){
cout<<"Count:"<<count<<endl;
}
};
//definition of the static data member
int Test::count;
int main()
{
Test t1,t2;
t1.setCode();
t2.setCode();
Test::showCount();//accessing static member function
Test t3; t3.setCode();
Test::showCount();
t1.showCode();
t2.showCode();
t3.showCode();
return 0;
}

Expected output:

SMA2176 Computer Programming II Notes ~ A. Kamau Page 11 of 16

 Count: 2
Count: 3
Object number: 1
Object number: 2
Object number: 3
Note that code=++count; is executed whenever setCode() is invoked and the current value of
count is assigned to code. Since each object has its own copy of code, then the value it contains
represents a unique number of its object.

Separating Interface from Implementation

One fundamental principals of good software engineer is to separate interface from
implementation. This make it easier to modify programs. I.e. changes in class implementation do
not affect the client as long as the class interface originally provided to the client is uncharged.
When splitting a program into multiple files, each class definition and class member definitions
are placed in the header file.
The header file are included (via # include) in each file in which the class is used.

Example
Write a complete C++ program that uses an ADT SalesPerson, with an attribute, which is an
array of twelve monthly sales figure initialized by a constructor to zero and set to user supplied
values by the member function setSales. The method printAnnuaSales prints the total sales of the
salesperson for the twelve months. The utility (helper) function totalAnnualSales totals the
twelve monthly sales for the benefit of printAnnuaSales. The printAnnuaSales should also edit
the sales figure into KSh format. Use a header file for the class definition, and separate source
files for the class member function implementation and the main function.

Solution:
//salesperson.h, defines the header file for the class definition
#ifndef SALESP_H
#define SALESP_H
class SalesPerson{
public:
SalesPerson();
void getSalesFromUser();
void setSales(int,double);
void printAnnualSales();
private:
double totalAnnualSales();
double sales[12];
};
#endif

//salesperson.cpp, defines source file for the class member function implementation
#include<iostream>
#include<iomanip>

SMA2176 Computer Programming II Notes ~ A. Kamau Page 12 of 16

#include<cstring>
#include"salesperson.h"
using namespace std;
SalesPerson::SalesPerson()
{
for(int i=0;i<12;i++)
sales[i]=0;
}
void SalesPerson::getSalesFromUser()
{
double sales_figure;
for(int i=1;i<=12;i++)
{
cout<<"Enter the sales amount for month "<<i<<":";
cin>>sales_figure;
setSales(i,sales_figure);
}
}
void SalesPerson::setSales(int month,double amount)
{
if(month>=1 && month<=12 && amount>0)
sales[month-1]=amount;
else
cout<<"Invalid month or sales valus"<<endl;
}
void SalesPerson::printAnnualSales()
{
cout<<"The total amount sales are KSh: "
<<totalAnnualSales()<<endl;
}
double SalesPerson::totalAnnualSales()
{
double total=0;
for(int i=0;i<12;i++)
total+=sales[i];
return total;
}
//defines the main function implementation of the program
#include"SalesPerson.h"
int main()
{
SalesPerson sales;
sales.getSalesFromUser();
sales.printAnnualSales();
return 0;
}

SMA2176 Computer Programming II Notes ~ A. Kamau Page 13 of 16

Friend Functions and Friend classes
A friend function of a class is a function which is defined outside the class scope yet it has the
right to access private member of that class .A function or an entire class may be declared to be a
friend of another class.
Friend functions are commonly used with operator overloading, or when a function needs to
access objects in two separate classes.

To declare a function as a friend of a class, precede the function prototype in the class definition
with the keyword friend.

Example
Write a complete C++ program which incorporates a friend function mean that is used to
compute and return the average of two numbers contained in an object. The class has an inline
member function for inputting any two numbers. Include a main function to implement the class.

#include<iostream>
using namespace std;
class Sample
{
//Friend function declaration
friend double Mean(Sample &);
public:
void getValues(){
cout<<"Enter two numbers:"<<endl;
cin>>a>>b;
}
private:
double a,b;
};

// Friend function defination

double Mean(Sample & s)
{
return (s.a+s.b)/2;
}
// main function defination
int main()
{
Sample X;
X.getValues();
//call the friend function
cout<<"The mean value is:"<<Mean(X)<<endl;
return 0;
}

SMA2176 Computer Programming II Notes ~ A. Kamau Page 14 of 16

 Note
A class can also be a friend to another class. All the functions in the friend class can access the
private elements of another class. This is useful when class objects are managed by another
class. E.g. the following declaration makes an entire class to be a friend of another class.

friend class Otherclass; // all member functions in Otherclass are friends

Syntax:

class A{
…………..
………….
type fun1(); // member function of X
………...
};

class B{
…………..
friend class A; // all member functions of A are friends to B
};

Example
The following is a C++ program that demonstrates how a friend function can be used as a bridge
between two classes (i.e ability of a function to access objects in two separate classes)

#include<iostream>
#include<iomanip>
using namespace std;
class ABC;
class XYZ
{
int x;
public:
void setValue(int i){ x=i;}
friend void Max(XYZ &, ABC &);
};

class ABC
{
int a;
public:
void setValue(int i){ a=i;}
friend void Max(XYZ &, ABC &);
};

void Max(XYZ & m, ABC & n) // definition of friend

SMA2176 Computer Programming II Notes ~ A. Kamau Page 15 of 16

 {
if (m.x>=n.a)
cout<<m.x<<endl;
else
cout<<n.a<<endl;
}

int main()
{
ABC abc;
abc.setValue(10);

XYZ xyz;
xyz.setValue(20);

Max(xyz,abc);
return 0;
}

SMA2176 Computer Programming II Notes ~ A. Kamau Page 16 of 16