Home C++ Tutorial Properties of OOPs

Properties of OOPs

by Adarsh Pal
160 minutes read
  • Encapsulation
  • Inheritance
  • Polymorphism
  • Abstraction

Encapsulation

Encapsulation can be defined as wrapping up of data members and member functions in a single entity, encapsulation is done for data hiding or information hiding, by using encapsulation we can make our class “Read Only”. fully encapsulated class is a class where all data members are private, given below is a simple demonstration of Encapsulation.

Lightbox
#include<iostream>
using namespace std;
class Secret{
  private:
   int rank=5;
  public:
  //getter function
   int getRank(){
    return rank;
   } 
};
int main(){
  Secret person1;
  cout<<person1.getRank()<<endl;
  return 0;
}

The above code follow the “read only” feature of Encapsulation, since we can not modify data members we can only read it by getter( ) function.

Inheritance

The capability of a class to derive or inherit properties or characteristics from another class defines the Inheritance, Inheritance is one of the most important features of OOPs.

Given below is a simple demonstration of Inheritance

#include<iostream>
using namespace std;
class Parent{
  private:
   int rank=5;
   char ID='A';
  public:
   int getRank(){
    return rank;
   } 
};
class Child:public Parent{
    public:
    string name;
    void setName(string name){
        this->name=name;
    }
};
int main(){
  Child obj;
  cout<<obj.getRank()<<endl;
  return 0;
}

Output

5

Here Child is a derived class and Parent is a base class.

Mode of Inheritance

Lightbox

Above table shows how the child class can use the data members of the base class, a child class can never access the private data members of base class even if the type of Inheritance is Public, Protected or Private, hence we can conclude that a Private data member of any class can’t be Inherited.

Type of Inheritance

  • Single Inheritance
  • Multi-level Inheritance
  • Multiple Inheritance
  • Hybrid Inheritance
  • Hierarchical inheritance

1) Single Inheritance

Single Inheritance is all about one subclass and one base class, basically in Single Inheritance the class is allowed to Inherit properties from only one class.

// inheritance.cpp
#include <iostream> 
using namespace std; 
class base    //single base class
{
   public:
     int x;
   void getdata()
   {
     cout << "Enter the value of x = "; cin >> x;
   }
 };
class derive : public base    //single derived class
{
   private:
    int y;
   public:
   void readdata()
   {
     cout << "Enter the value of y = "; cin >> y;
   }
   void product()
   {
     cout << "Product = " << x * y;
   }
 };
 
 int main()
 {
    derive a;     //object of derived class
    a.getdata();
    a.readdata();
    a.product();
    return 0;
 }       

Output

Enter the value of x = 25
Enter the value of y = 15
Product = 375

2) Multi-level Inheritance

In multi-level Inheritance a derived class is defined from another derived class.

// inheritance.cpp
#include <iostream>
using namespace std;
class base //single base class
{
 	public:
 	int x;
 	void getdata()
 	{
    	cout << "Enter value of x= "; cin >> x;
 	}
};
class derive1 : public base // derived class from base class
{
 	public:
 	int y;
 	void readdata()
 	{
 	    cout << "\nEnter value of y= "; cin >> y;
 	}
};
class derive2 : public derive1   // derived from class derive1
{
 	private:
 	int z;
 	public:
 	void indata()
 	{
    	cout << "\nEnter value of z= "; cin >> z;
 	}
 	void product()
 	{
 	    cout << "\nProduct= " << x * y * z;
 	}
};
int main()
{
     derive2 a;      //object of derived class
     a.getdata();
     a.readdata();
     a.indata();
     a.product();
     return 0;
}            

Output

Enter value of x= 58
Enter value of y= 64
Enter value of z= 48
Product= 178176

3) Multiple Inheritance

Multiple Inheritance is concept in which a class can inherit properties and features from more than one class, in multiple Inheritance more than one base class are present.

// multiple inheritance.cpp
#include<iostream>
using namespace std;
class A
{
 	public:
 	int x;
 	void getx()
    {
 	    cout << "enter value of x: "; cin >> x;
    }
};
class B
{
 	public:
 	int y;
 	void gety()
 	{
 	    cout << "enter value of y: "; cin >> y;
 	}
};
class C : public A, public B   //C is derived from class A and class B
{
 	public:
 	void sum()
 	{
 	    cout << "Sum = " << x + y;
 	}
};

int main()
{
 	 C obj1; //object of derived class C
 	 obj1.getx();
 	 obj1.gety();
 	 obj1.sum();
 	 return 0;
}   	

Output

enter value of x: 54
enter value of y: 965
Sum = 1019

4) Hierarchical inheritance

In hierarchical Inheritance more than one sub class is Inherited from single parent class or base class.

// hierarchial inheritance.cpp
#include <iostream> 
using namespace std;

class A //single base class
{
    public:
 	int x, y;
 	void getdata()
 	{
   	    cout << "\nEnter value of x and y:\n"; cin >> x >> y;
 	}
};
class B : public A //B is derived from class base
{
    public:
 	void product()
 	{
 	    cout << "\nProduct= " << x * y;
 	}
};
class C : public A //C is also derived from class base
{
    public:
 	void sum()
 	{
        cout << "\nSum= " << x + y;
 	}
};
int main()
{
    B obj1;          //object of derived class B
    C obj2;          //object of derived class C
    obj1.getdata();
    obj1.product();
    obj2.getdata();
    obj2.sum();
    return 0;
}  

Output

Enter value of x and y:
45 45
Product= 2025
Enter value of x and y:
48 65
Sum= 113

5) Hybrid Inheritance:

Hybrid Inheritance is basically an implementation which is using more than one type of Inheritance, In the above diagram the multilevel inheritance and hierarchical Inheritance is used.

#include <iostream>
using namespace std;

class A
{
 	public:
 	int x;
};
class B : public A
{
 	public:
 	B()      //constructor to initialize x in base class A
 	{
 	   x = 10;
 	}
};
class C
 {
 	public:
 	int y;
 	C()   //constructor to initialize y
 	{
 	    y = 4;
        }
};
class D : public B, public C   //D is derived from class B and class C
{
 	public:
 	void sum()
 	{
 	    cout << "Sum= " << x + y;
 	}
};

int main()
{
         D obj1;          //object of derived class D
 	obj1.sum();
 	return 0;
}               

Output

Sum= 14

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.

An operation may exhibit different behaviours in different instances.

C++ supports operator overloading and function overloading.

  • Operator Overloading
#include<iostream>
using namespace std;

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 << '\n'; }
};

int main()
{
	Complex c1(10, 5), c2(2, 4);
	Complex c3 = c1 + c2;
	c3.print();
}
  • Function Overloading
#include <iostream>
using namespace std;


void add(int a, int b)
{
cout << "sum = " << (a + b);
}

void add(double a, double b)
{
	cout << endl << "sum = " << (a + b);
}

int main()
{
	add(10, 2);
	add(5.3, 6.2);

	return 0;
}

Abstraction

Abstraction is used for implementation hiding, it is one of the most important features of OOPs, Abstraction is basically showing only essential information and hiding the details of the program.

For example: while using a online banking mobile application the user can easily make a payment without any access of the backend of the application, this way Abstraction can be utilised for security purposes.

// C++ Program to Demonstrate the
// working of Abstraction
#include <iostream>
using namespace std;

class implementAbstraction {
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()
{
	implementAbstraction obj;
	obj.set(10, 20);
	obj.display();
	return 0;
}

Output

a = 10
b = 20

related posts

Leave a Comment

Enable Notifications OK No thanks