Opp concept in c++

Is Opp
Different functions
Different data type
User define data type
Builtin data type
C++

INSERT LOGO HERE
Introduction object oriented programming
The object-oriented programming (OOP) is a different approach to programming.
Object oriented technology supported by C++ is considered the latest technology
in software development. It is regarded as the ultimate paradigm for the modelling
of information, be that data or logic.
. Object oriented programming – As the name suggests uses objects in programming.
Object oriented programming aims to implement real world entities like inheritance,
hiding, polymorphism etc in programming. The main aim of OOP is to bind together the
data and the functions that operates on them so that no other part of code can access
this data except that function.
to divide complex problems into smaller sets by creating objects is called oop.

Advantage of OOPs over Procedure-oriented programming language
1) OOPs makes development and maintenance easier where as in Procedure-oriented programming language it is not easy to
manage if code grows as project size grows.
2) OOPs provides data hiding whereas in Procedure-oriented programming language a global data can be accessed
from anywhere.
igure: Data Representation in Procedure-Oriented Programming
3) OOPs provides ability to simulate real-world event much more effectively. We can provide the
solution of real word problem if we are using the Object-Oriented Programming language.

Main concept are 2
Class ( blue print )
Object ( real world example )
OOP
Basic Concepts

C++ Classes and Objects
Class: The building block of C++ that leads to Object Oriented programming is a Class. It is a user defined
data type, which holds its own data members and member functions, which can be accessed and used by
creating an instance of that class. A class is like a blueprint for an object.
A class have some properties.
1 A Class is a user defined data-type which has data members and member functions.
2 Data members are the data variables and member functions are the functions used to manipulate these variables and
together these data members and member functions defines the properties and behavior of the objects in a Class.
Objectis an instance of a Class. When a class is defined, no memory is allocated but when it is instantiated (i.e. an
object is created) memory is allocated.
Class syntax ========= class class_name{ body of a class }; // it is out of main
Object syntax ========= class_name object ; // it is inside of main

Inheritance The capability of a class to derive properties and
characteristics from another class is called Inheritance
In normal terms ENCP is defined as wrapping up of data and information under
a single unit. In Object Oriented Programming, Encapsulation is defined as
binding together the data and the functions that manipulates them.
Abstraction means displaying only essential information and hiding the details.
Data abstraction refers to providing only essential information about the data
to the outside world, hiding the background details or implementation.
Classes It is a user defined data type, which holds its own data members and member
functions, which can be accessed and used by creating an instance of that class.
A class is like a blueprint for an object. For Example: Consider the Class of Cars.
Class ( blue print
Data abstrauction
Data encapsulation
Inheretance
Polymorphism
The word polymorphism means having many forms. In simple words,
we can define polymorphism as the ability of a message to be
displayed in more than one form.

1 Abstraction
Abstraction using Classes: We can implement Abstraction in C++ using classes.
Class helps us to group data members and member functions using available
access specifiers. A Class can decide which data member will be visible to
outside world and which is not.
• Members declared as public in a class, can be accessed from anywhere in the program.
• Members declared as private in a class, can be accessed only from within the class. They are
not allowed to be accessed from any part of code outside the class.

Example :
#include <iostream>
using namespace std;
class car
{
private:
int a, b;
public:
// method to set values of
// private members
void set(int x, int y)
{
a = x;
b = y;
}
void display()
{
cout<<"a = " <<a << endl;
cout<<"b = " << b << endl;
}
};
int main()
{
car obj;
obj.set(10, 20);
obj.display();
return 0;
}

2 Encapsulation
Encapsulation also lead to data abstraction or hiding. As using encapsulation also hides the data. In the
above example the data of any of the section like sales, finance or accounts is hidden from any other section.
 Role of access specifiers in encapsulation
As we have seen in above example, access specifiers plays an important role in implementing encapsulation in
C++. The process of implementing encapsulation can be sub-divided into two steps:
The data members should be labeled as private using the private access specifiers
The member function which manipulates the data members should be labeled as public using the public access
specifier
 In C++ encapsulation can be implemented using Class and access modifiers.

// c++ program to explain
// Encapsulation
#include<iostream>
class Encapsulation{
private:
// data hidden from outside world
int x;
public:
// function to set value of
// variable x
void set(int a)
{
x =a;
}
// function to return value of
// variable x
int get() {
return x;
}
};
// main function
int main()
{
Encapsulation obj;
obj.set(5);
cout<<obj.get();
return 0;
}

Sub Class: The class that inherits properties from another class is called Sub class or Derived Class.
Super Class:The class whose properties are inherited by sub class is called Base Class or Super class.
The article is divided into following subtopics:
1 Why and when to use inheritance?
2 Modes of Inheritance
3 Types of Inheritance
1 Why and when to use inheritance?
Consider a group of vehicles. You need to create classes for Bus, Car and Truck. The methods fuelAmount(), capacity(),
applyBrakes() will be same for all of the three classes. If we create these classes avoiding inheritance then we have to
write all of these functions in each of the three classes as shown in below figure:
This is inheritance in class

Implementing inheritance in C++: For creating a sub-class which is inherited from the base class we have to
follow the below syntax.
Note: A derived class doesn’t inherit access to private data members. However, it does inherit a full parent object, which
contains any private members which that class declares.
class subclass_name : access_mode base_class_name
{ //body of subclass };

Modes of Inheritance
1.Public mode: If we derive a sub class from a public base class. Then
the public member of the base class will become public in the derived
class and protected members of the base class will become protected
in derived class.
2.Protected mode: If we derive a sub class from a Protected base
class. Then both public member and protected members of the base
class will become protected in derived class.
3.Private mode: If we derive a sub class from a Private base class.
Then both public member and protected members of the base class will
become Private in derived class.
Note : The private members in the base class cannot be directly
accessed in the derived class, while protected members can be directly
accessed. For example, Classes B, C and D all contain the variables x,
y and z in below example. It is just question of access.
// C++ Implementation to show that a derived class
// doesn’t inherit access to private data members.
// However, it does inherit a full parent object
class A
{
public:
int x;
protected:
int y;
private:
int z;
};
class B : public A
{
// x is public
// y is protected
// z is not accessible from B
};
class C : protected A
{
// x is protected
// y is protected
// z is not accessible from C
};
class D : private A // 'private' is default for classes
{
// x is private
// y is private
// z is not accessible from D
};

Types of Inheritance in C++
Single Inheritance: In single inheritance, a class is allowed to inherit from only one class. i.e. one sub class is inherited by
one base class only.
class subclass_name : access_mode base_class
// C++ program to explain
// Single inheritance
#include <iostream>
// base class
class Vehicle {
public:
Vehicle()
{
cout << "This is a Vehicle" << endl;
}
};
// sub class derived from two base classes
class Car: public Vehicle{
};
// main function
int main()
{
// creating object of sub class will
// invoke the constructor of base classes
Car obj;
return 0;
}

Multiple Inheritance: Multiple Inheritance is a feature of C++ where a class can inherit from more than one
classes. i.e one sub class is inherited from more than one base classes.
Syntax:
class subclass_name : access_mode base_class1, access_mode base_class2, ....
// C++ program to explain
// multiple inheritance
#include <iostream>
// first base class
class Vehicle {
public:
Vehicle()
{
}
};
// second base class
class FourWheeler {
public:
FourWheeler()
{
cout << "This is a 4 wheeler Vehicle" <<
endl;
}
};
class Car: public Vehicle, public FourWheeler {
};
// main function
int main()
{
// creating object of sub class will
// invoke the constructor of base
classes
Car obj;
return 0;
}

Multilevel Inheritance: In this type of inheritance, a derived class is created from another derived class.
// C++ program to implement
// Multilevel Inheritance
#include <iostream>
// base class
class Vehicle
{
public:
Vehicle()
{
}
};
class fourWheeler: public Vehicle
{ public:
fourWheeler()
{
cout<<"Objects with 4 wheels are
vehicles"<<endl;
}
};
class Car: public fourWheeler{
public:
car()
{
cout<<"Car has 4 Wheels"<<endl;
}
};
// main function
int main()
{
//creating object of sub class will
//invoke the constructor of base
classes
Car obj;
return 0;
}

Hierarchical Inheritance: In this type of inheritance, more than one sub class is inherited from a single
base class. i.e. more than one derived class is created from a single base class.
// C++ program to implement
// Hierarchical Inheritance
#include <iostream>
// base class
class Vehicle
{
public:
Vehicle()
{
}
};
// first sub class
class Car: public Vehicle
{
};
// second sub class
class Bus: public Vehicle
{
};
// main function
int main()
{
// creating object of sub
class will
// invoke the constructor
of base class
Car obj1;
Bus obj2;
return 0;
}

Hybrid (Virtual) Inheritance: Hybrid Inheritance is
implemented by combining more than one type of
inheritance. For example: Combining Hierarchical
inheritance and Multiple Inheritance.
// C++ program for Hybrid Inheritance
#include <iostream>
// base class
class Vehicle
{
public:
Vehicle()
{
}
};
//base class
class Fare
{
public:
Fare()
{
cout<<"Fare of Vehiclen";
}
};
// first sub class
class Car: public Vehicle
{
};
// second sub class
class Bus: public Vehicle, public Fare
{
};
// main function
int main()
{
// creating object of sub class
will
// invoke the constructor of base
class
Bus obj2;
return 0;
}

Polymorphism in C++
In C++ polymorphism is mainly divided into two types:
•Compile time Polymorphism
•Runtime Polymorphism
Compile time polymorphism: This type of polymorphism is achieved by function overloading or
operator overloading.
•Function Overloading: When there are multiple functions with same name but different
parameters then these functions are said to be overloaded. Functions can be overloaded
by change in number of arguments or/and change in type of arguments.
Rules of Function Overloading
In C++, following function declarations cannot be overloaded.
1) Function declarations that differ only in the return type. For example,
the following program fails in compilation.
2) Member function declarations with the same name and the name
parameter-type-list cannot be overloaded if any of them is a static member
function declaration. For example, following program fails in compilation.

Function Overloading: When there are multiple functions with same name
but different parameters then these functions are said to be overloaded.
Functions can be overloaded by change in number of
arguments or/and change in type of arguments.
// C++ program for function overloading
#include <bits/stdc++.h>
class Geeks{
public:
// function with 1 int parameter
void func(int x){
cout << "value of x is " << x << endl;
}
// function with same name but 1 double
parameter
void func(double x) {
cout << "value of x is " << x << endl;
}
// function with same name and 2 int
parameters
void func(int x, int y) {
cout << "value of x and y is " << x <<
", " << y << endl;
}
};
int main() {
Geeks obj1;
// Which function is called will
depend on the parameters passed
// The first 'func' is called
obj1.func(7);
// The second 'func' is called
obj1.func(9.132);
// The third 'func' is called
obj1.func(85,64);
return 0;
}

Operator Overloading: Operator overloading is a technique by which
operators used in a programming language are implemented in user-
defined types
// CPP program to illustrate
// Operator Overloading
#include<iostream>
class Complex {
private:
int real, imag;
public:
Complex(int r = 0, int i =0)
{real = r; imag = i;}
// This is automatically called when '+' is used with
// between two Complex objects
Complex operator + (Complex const &obj) {
Complex res;
res.real = real + obj.real;
res.imag = imag + obj.imag;
return res;
}
void print() { cout << real << " + i" << imag << endl; }};
int main(){
Complex c1(10, 5), c2(2, 4);
Complex c3 = c1 + c2; // An example call to "operator+"
c3.print();}
What is the use of operator overloading?
Operator overloading allows you to redefine the way
operator works for user-defined types only (objects,
structures). It cannot be used for built-in types (int,
float, char etc.). Two operators = and & are already
overloaded by default in C++. For example:
To copy objects of same class, you can directly
use = operator.

Runtime polymorphism: This type of polymorphism is achieved by Function Overriding.
•Function overriding on the other hand occurs when a derived class has a definition for one of the member
functions of the base class. That base function is said to be overridden.
// C++ program for function
overriding
#include <bits/stdc++.h>
// Base class
class Parent
{
public:
void print()
{
cout << "The Parent print
function was called" << endl;
}
};
// Derived class
class Child : public Parent
{
public:
// definition of a member
function already present in Parent
void print()
{
cout << "The child print
function was called" << endl;
}
};
//main function
int main()
{
//object of parent class
Parent obj1;
//object of child class
Child obj2 = Child();
// obj1 will call the print function
in Parent
obj1.print();
// obj2 will override the print
function in Parent
// and call the print function in
Child
obj2.print();
return 0;
}

Difference between Encapsulation and Abstraction
Encapsulate hides variables or some implementation that may be changed so often in a class to prevent
outsiders access it directly. They must access it via getter and setter methods.
Abstraction is used to hiding something too but in a higher degree(class, interface). Clients use an abstract
class(or interface) do not care about who or which it was, they just need to know what it can do.
Encapsulation: It is the process of hiding the implementation complexity of a specific class from the client that is going to
use it, keep in mind that the "client" may be a program or event the person who wrote the class.
Abstraction: Is usually done to provide polymorphic access to a set of classes. An abstract class cannot be instantiated thus
another class will have to derive from it to create a more concrete representation.
Encapsulation is wrapping, just hiding properties and methods. Encapsulation is used for hide the code and
data in a single unit to protect the data from the outside the world. Class is the best example
of encapsulation.Abstraction on the other hand means showing only the necessary details to the intended user.

Difference between inheritance and polymorphism in c++
The main difference is polymorphism is a specific result of inheritance.Polymorphism is where the method
to be invoked is determined at runtime based on the type of the object. This is a situation that results when you
have one class inheriting from another and overriding a particular method
Polymorphism and Inheritance are major concepts in Object Oriented Programming. The difference
between Polymorphism and Inheritance in OOP is that Polymorphism is a common interface to multiple
forms and Inheritance is to create a new class using properties and methods of an existing class. Both
concepts are widely used in Software Development.
Polymorphism vs Inheritance in OOP
Polymorphism is an ability of an object to behave in multiple ways.
Inheritance is to create a new class using properties and methods
of an existing class.
Usage
Polymorphism is used for objects to call which form of methods at
compile time and runtime.
Inheritance is used for code reusability.
Implementation
Polymorphism is implemented in methods. Inheritance is implemented in classes.
Categories
Polymorphism can be divided into overloading and overriding.
Inheritance can be divided into single-level, multi-level,
hierarchical, hybrid, and multiple inheritance.

Opp concept in c++

More Related Content

What's hot (10)

Similar to Opp concept in c++ (20)

Recently uploaded (20)

Opp concept in c++

Editor's Notes