object oriented programming using vc++. introduction program – set of instruction written in a...

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

• Integerint a;

• Floatfloat b;

• Doubledouble c;

• Charchar 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 function’s definition or class’s 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.

Exampleint main(){

int a=10;int b=0;try{

cout << a/b; //throws an exceptionthrow(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>>