Object Oriented Programming

using VC++
Introduction
Program Set of instruction written in a high
level language
High level language used for writing programs is
also called as Programming Language
Every Programming language has a compiler or
an interpreter which merely translates the
instructions issued in high level language to low
level language that is understandable by the
computer.
Machine language comprises of zeros and ones
(0 and 1)
Programming Paradigms
Paradigm is nothing but a style of programming
Few paradigms are
Structured Programming (C)
Object Oriented Programming (C++,Java,C#,VB .Net)
Object Based Programming (Java Script, VB Script)
Event driven Programming (Visual Basic)
Service Oriented Programming (Any web application)
Component Based Programming (COM, CORBA)
Object Oriented Programming
OOP is a programming style that is focused on
objects
Features of OOP
Modularity
Reusability
Readability
Maintainability
Inheritance
Polymorphism
Abstraction
Encapsulation
Structured Vs OOP
Structured OOP
Focuses on
Process
Focuses on
Object
Follows Top
Down Approach
Follows Bottom
Up Approach
Approaches in Software
Development
Top Down approach
A Single module will be split into several smaller
modules
General to Specific
Bottom Up approach
Lot of small modules will be grouped to form a single
large module
Specific to General
If the requirements are clear at the first instance
we can go for Top down approach
In circumstances where the requirements may
keep on adding, we go for Bottom up approach
OOP Significance
In real world scenario, for developing a
software, we need requirements.
But practically speaking, requirements
keep on changing and request to add new
features will keep on accumulating.
So its better if we follow a bottom up
approach I.e. Object Oriented
Programming Strategy
OOP Extension
With the advent of OOP, databases too
started implementing the concept.
Databases that make use of objects are
called as Object Oriented Databases
This simple maps a class in OOP to a
table
More explanation on notes page
Modularity
Feature that enables us to split a single
large module to several small sub modules

Enables easy maintainability of code
Enables easy readability and
understandability of code

Achieved in OOPS using functions
Maintainability and Readability
Functions in OOPS enables maintainability
and readability of code

The presence of comments in code,
enables the readability of the code
Also in future if we want to get the
functionality of our code, then comments
will definitely of great help.
Reusability
This feature enables us to re use the
objects (functions, variables)

Write Once, Use Any where, any number
of times
Since functions are independent piece of
code, they can be used any number of
times
Abstraction
Showing only the essential features and hiding
the unnecessary features
The access modifiers in C++ or any OOP
language, provides abstraction
Functions also provide abstraction
If a variable is declared as private, then other
classes cannot access it
The function name that is used in function call
hides the implementation details from user. It
shows only the outline of functionality that the
function provides.
Encapsulation
The process of bringing together the data
and method of an object is called as
encapsulation
The data and method are given in the
class definition
Classes provides us with this feature -
Encapsulation
Inheritance
Feature that enables the characteristics or
properties of a parent to reach its child

C++ supports inheritance
A class can inherit one or more classes
Inherited class is called as parent class or
super class or base class
Class that inherits a parent class is called
as child class or sub class or derived class
Polymorphism
Poly Many
Morph Form
Polymorphism is the characteristic that
enables an entity to co exist in more than
one form
C++ supports function overloading and
operator overloading to implement
polymorphism
Writing a simple C++ Program
Open Microsoft Visual Studio -> Visual C++
Click File -> New
In the dialog box, select Project Tab
Select Windows Console Application
Give a name for the project
Click Files Tab
Select C++ source files
Give File name
Click OK
Writing a simple C++ Program
In the editor opened, type the code given
at the notes page
Save the file
Compile the file
This generates an exe for the project
Build the file
This generates an obj file for the source file
Execute the file
Writing an OOP in C++
#include<iostream.h>
class Person // Class declaration
{
private: // Access specifier Private can be accessed
int id; // with in the class and objects of the class
char name[10];
public: // Access specifier Public can be accessed
void getDetails(); // with in class and also outside class
void showDetails();
};
void Person::getDetails() // :: is called as scope resolution operator. Refer Notes page
{
cout << Enter Id:;
cin >> id; // characters entered through key board is pushed to variable id
cout << Enter Name:;
cin >> name;
}
Writing an OOP in C++
void Person::showDetails()
{
cout << Id: << id << endl;
cout << Name: << name << endl;
}

int main()
{
Person p; // Creating object for class Person
p.getDetails(); // invoking the classs method
p.showDetails();
return 0;
}
Conditions
if

if..else

If..elseif..else

switch case
Loops
While
while(condn)
{
Statements;
}

Do while
do
{
statements;
}while(condn);

For
for( initialization; condition cheking; increment/decrement )
{
body of for loop
}
Variables
Variable names are case sensitive
Variables can contain _, alphabets and
numbers
Variables should either start with an
alphabet or an _ (underscore)
Variable names should not be a reserved
word
Data types
Integer
int a;
Float
float b;
Double
double c;
Char
char d;
Inline Functions
By default all functions that are defined
with in a class definition are inline
functions
If we wish to define a function outside
class definition, and still want it to behave
like an inline function, we need to use the
keyword inline before the function return
type in the function definition
Inline Functions
If a function is declared as inline, then the
function call will be directly replaced by the
body of the function
In non inline functions, if a function call is
encountered, then the program execution
saves the current context in stack and
jumps to the memory location where the
function is defined, executes it and returns
back to the entry point.
Inline Functions
Advantages with inline function
Execution is made faster
Stack overhead reduced
Inline function is similar to preprocessor
directives in C.
If we give #define MAX 5 in C, then wherever
MAX comes in the program, it will be replaced
by 5
Inheritance
Feature by which an entity gets the
characteristics or properties of its ancestors
A class can derive properties and methods
belonging to another class by means of
inheritance
The former is called as derived class or child
class or sub class
The latter is called as base class or parent class
or super class
Types of Inheritance
Simple
A derived class inherits from one base class
Multi level
Inheritance in several levels One class per level
Multiple
A class inherits from more than one base class
Hierarchical
Several derived class inherits from a single base
class
Hybrid
Combination of multiple and hierarchical inheritance.
Also called as diamond inheritance
Inheritance
A class can inherit the members and
methods of another class in 3 ways:
Public
Private
Protected
Private members cannot be inherited
Only public or protected members can be
inherited
Constructors
Constructors are used for initializing data
members of a class
Constructors are always to be defined under
public access
Constructor is invoked whenever an object is
created
Name of the constructor is the class name
Constructor should not contain a return type
Constructor can contain one or more parameters
Destructors
Destructors are used to release the memory
used by the objects
Destructors cannot have parameters or return
type
There is only one destructor for a class
Destructors are invoked before the program
execution ends
Name of the destructor is a tilde symbol (~)
followed by class name and parenthesis
~cls() { }
Polymorphism
Ability of an entity to co exist in more than
one form
Two types of polymorphism:
Static or compile time polymorphism
Dynamic or run time polymorphism
Static polymorphism is called as early
binding
Dynamic polymorphism is called as late
binding
Static Polymorphism
Three types of static polymorphism
Constructor overloading
A class can contain more than one constructors
Function overloading
A class can contain more than one function with
the same name
Operator overloading
In a class, the normal behavior of an operator can
be changed. I.e in addition to its normal behavior
we can give additional functionality
Constructor Overloading
Constructor overloading is said to be done
on constructors if
The number of parameters for the
constructors are different
If data type of the parameters for the
constructors are different
Eg. Class called Sample having constructors
like Sample(), Sample(int a), Sample(int a,
float b) and so on
Function Overloading
Two or more functions with same name
can co exist in the same class if they are
overloaded. They are said to be
overloaded functions if
Return types of the functions are different
Number of parameters in them are different
Data types of parameters are different
Operator Overloading
Syntax:
<Return type> operator <operator to be
overloaded> (<parameter list>)
{
body of the function
}
Usage:
Obj.operator<overloaded operator> (values)
Dynamic Polymorphism
Implemented via abstract classes and virtual
function
If we have given a function in base class as
virtual function, then it means that its definition
can be altered in the derived classes.
Example:
virtual int area() = 0;
We can give the definition for the function in the
derived class
Templates
Templates enforces reusability property of
object oriented programming
We can write functions using generic data
types and while creating objects or calling
functions, we can specify the data types
Accordingly functions definition or classs
definition will be changed to the required
data type
Function templates
template <class T>
T max(T a, T b)
{
return a>b?a:b;
}
int main()
{
cout << max<int>(1,2);
}
Class Templates
template <class T>
class Test
{
T val;
Test(T a)
{
val = a;
}
};
int main()
{
Test <int> t1(10); //a is treated as int
Test <double> t2(1.3); // a is treated as double
return 0;
}
Exception Handling
Exception Error occurring at the run time or
during execution
Exceptions are not recognized during
compilation
C++ implements exception handling using try
catch mechanism
The portion of code that may cause exception is
written with in try block.
The catch block contains the code that need to
be executed when exception occurs.
Example
int main()
{
int a=10;
int b=0;
try
{
cout << a/b; //throws an exception
throw(b);
}
catch(int e)
{
cout << divide by zero exception: << e;
}
}

We can also reassign value of b and make the program to continue its execution in the catch
block, instead of stopping the execution
If catch() is present, then it is called as default exception
Namespaces
Allows to group entities like classes,
objects, functions under a name
Format:
namespace <<namespace_name>>
{
declarations and definitions
}
Using namespaces
We can change the namespace that is being
used currently by means of using directive
We can declare alternate names for existing
namespaces according to the following format:
namespace new_name = current_name;
using <<namespace_name>>;
We can access members of namespace using a
:: operator (scope resolution operator)
<namespace_name>::<<member_name>>