Author: admin

Encapsulation is defined as the wrapping up of data(variable) under a single unit. Encapsulation is an important concept of OOP in C++ that binds data and functions inside a class together that manipulate them. Data encapsulation leads to the important concept called data hiding.

It makes sure that the ‘sensitive’ data are hidden from the user and an access specifier is used to achieve this. private specifier is used to hide sensitive data, it makes the data inaccessible from outside the class. But to modify or read those data, we need to use the getter and setter (i.e. get and set) method. It prevents from accessing the data directly.

Example of specifiers to bind data:

class Square
{
   private:
      double side;  


   public:
      void setSide(int s) 
      {
        if (s >= 0)
         side = s;
      }
};

Let us go through an example in C++ to understand the concept of hiding data.

---

Data Hiding Using the private Specifier in C++

#include <iostream>
using namespace std;

class Rectangle 
{
   //private members
   private:
      float length;
      float breadth;

   public:

     // Setter for length and breadth
     void setLength(float l) 
     {
       length = l;
     }
     void setBreadth(float b) 
     {
       breadth = b;
     }

     // Getter for length and breadth
     float getLength() 
     {
       return length;
     }
     float getBreadth() 
     {
       return breadth;
     }
    
     // area function
     float getArea() 
     {
       return length * breadth;
     }
};

//main function
int main() 
{
  Rectangle rect;

  //setting the length and breadth value
  rect.setLength(10);
  rect.setBreadth(6.5);

  // getting the length and breadth value
  float length = rect.getLength();
  cout << "Length: " << length << endl;

  float breadth = rect.getBreadth();
  cout << "Breadth: " << breadth << endl;

  // Area
  cout << "Area of a rectangle: " << rect.getArea();

  return 0;
}

Output:

Length: 10
Breadth: 6.5
Area of a rectangle: 65

In the above program length and breadth in Rectangle class is a private member which means they are not accessible from outside the class. So to get and set the value of length and breadth, we created a setter (pass the value) and getter (return the value). Hence the private members are not accessible directly, making it hidden.

---

Benefits of Encapsulation:

• Data- hiding in Java.
• The class field can be made read-only or write-only.
• It provides the class the total control over the data.

---

The interface is implemented using an abstract class in C++, hence the word interface and abstract class are used interchangeably.

Abstraction classes are the way to achieve abstraction and abstraction is a technique in programming to hide the internal details and only show the necessary functionalities.

The classes with at least one pure virtual function are said to be abstract classes. A pure virtual function is has a signature as “0” and of course with a virtual keyword itself as shown below.

virtual void fun() = 0;

And the above function can be called an abstract function as it has no body. The purpose of an abstract class is to serve as an interface and provide a base class from which other classes can inherit. Also, the instance of an abstract class cannot be created.

Let us understand through an example in C++ for abstract classes.

---

C++ Abstract class example

In the program below, we have three classes Animal (parent class), Cat, and Dog (derived class). The sound() function for each animal (dog and cat) is different but they have the same function name, so the function sound() is made pure virtual function in the parent class, Animal.

#include <iostream>
using namespace std;

class Animal
{
   public:
     //Pure Virtual Function
     virtual void sound() = 0;

     //Parent member Function
     void eat()
     {
       cout << "Animals eat.";
     }
};

//Cat class inherits Animal
class Cat: public Animal
{
   public:
     void sound()
     {
        cout << "Meow" << endl;
     }
};

//Dog class inherits Animal
class Dog: public Animal
{
   public:
     void sound()
     {
       cout << "Woof" << endl;
     }
};

//main function
int main()
{
   Dog d;
   Cat c;

   d.sound();
   c.sound();
   d.eat();

   return 0;
}

Output:

Woof
Meow
Animals eat.

---

Data abstraction is the process of hiding the details but only displaying the relevant information to the users. This is one of the main advantages of using abstraction.

It is a programming way or a technique through which we can separate the interface with the implementation details.

Take a real-life example:
Suppose a person is typing with the help of a keyboard on his/her computer. That person knows that pressing any alphabet on the keyboard, displays that alphabet on the screen of the monitor but he/she doesn’t know how the internal mechanism is working to display the alphabet.
Therefore, hiding the internal mechanism and showing only its output is an abstraction in this example.

C++ also provides a great level of abstraction such as the function pow() we use in a program to calculate the power of some number is internally implemented. Although we do not know how it is implemented. We just use it by calling pow() without knowing its algorithm.

There is another example such as private and public modifiers or sort()function that we use in a program.

In C++, abstraction can be achieved in two ways.

• Abstraction using classes
• Abstraction in header files.

---

Abstraction using Classes:

Classes are used o achieve abstraction in C++. A class grouped the class members that is data members and member function into a single unit using access specifiers. A class can decide which members are relevant to show to the outside world and which to hide.

Abstraction in Header files:

Another way to achieve abstraction is through header files. For example, consider the use of function pow() in a program to calculate the power of some number that is present in math.h header file, and this function is internally implemented. Although we do not know how it is implemented. We just use it by calling pow() without knowing its algorithm.

Access Specifiers for abstraction:

Access specifiers are the main way to implement abstraction and enforce the restriction on class members in C++.

• private: The members declared private are only accessible to the class They are not allowed to access outside the class, hence making it secure.
• public: The members declared public can be accessed from anywhere in the program.

Let us understand through a C++ example for abstraction using the above two specifiers.

Example of C++ data abstraction using classes

//C++ program to demonstrate the abstraction

#include <iostream>
using namespace std;

class Average
{
   // delaring private members 
   private:
      int num1, num2, avg;

   // public members 
   public_colon
   void set(int x, int y)
   {
      num1 = x;
      num2 = y;
   }

   void display()
   {
      avg = (num1 + num2) / 2;
      cout << "Average: " << avg << endl;
   }
};

int main()
{
   Average ag;

   ag.set(10, 10);
   ag.display();

   return 0;
}

Output:

Average: 10

As you can see in the above program the private variables num1, num2 and avg cannot be accessed outside the class. Only the public member functions are allowed to access.

---

Advantage of data abstraction

• When you need to modify the code in the future, you only need to modify the higher-level class and no need to modify the lower-level class.
• It also avoids code duplication increases the reusability of the code.
• Since the abstraction separates the interface and implementation, the internal changes can be easily made without affecting the user-level code.
• The abstracting of the data itself increases the security as no user can access the internal hidden mechanism.

---

Virtual function in C++ is a member function in the base class that we redefined in a derived class. With the use of a virtual function, we ensure that the function is overridden.

A virtual function lets the compiler know to perform dynamic linkage or late binding on the function (that is the called function needs to be resolved at run time).

A keyword ‘virtual‘ is used preceding with the function to be overridden. A virtual function cannot be a static member nor we can have a virtual constructor.

Let us understand through an example, we will first see a program without the use of virtual keywords and next with the use of virtual.

---

C++ Program Overriding a non-virtual function

// C++ program for function overriding without virtual function

#include <iostream>
using namespace std;

class Animal
{
   public:
   void display()
   {
      cout << "I am Animal" << endl;
   }
};

class Dog: public Animal
{
   public:
   void display()
   {
      cout << "I am a Dog" << endl;
   }
};

int main(void)
{
   Animal *a;
   Dog d;
   
   a = &d;
   a->display();

   return 0;
}

Output:

I am Animal

As you can see in the above program that we created a pointer object for the base class and the function is the same in both of the classes which are to be overridden. But even though the object of the base class points to the derived class (a = &d;), when we call it through an object a, we still get the display() function of the base class.

Therefore, here we need a virtual function in order to get access to the member of the derived class which we will see in the program below.

---

C++ Program Overriding using a virtual function

// C++ program for function overriding with virtual function

#include <iostream>
using namespace std;

class Animal
{
   public:
   virtual void display() //virtual function
   {
      cout << "I am Animal" << endl;
   }
};

class Dog: public Animal
{
   public:
   void display()
   {
      cout << "I am a Dog" << endl;
   }
};

int main(void)
{
   Animal *a;
   Dog d;
   
   a = &d;
   a->display();

   return 0;
}

Output:

I am a Dog

As you can see above is the same first program but with a virtual display() function. And now the result is different, the base object a which is pointed to the derived class gives the display() function of the derived class indicating the virtual function of the base class is overridden by the derived class.

---

Function overriding allows us to define a function at a derived class that is already present in a base class. And that base is said to be overridden. Both derived and base class has the member function with the same name, same return type, and same arguments list.

And the decision made to call the required function is done at the run time. Hence, it is used to achieve the Runtime polymorphism.

Let us understand through an example of function overriding using C++. It involves inheritance in a program given below.

Example of Function Overriding in C++

// C++ program for function overriding

#include <iostream>
using namespace std;

class Animal
{
   public:
   void display()
   {
      cout << "I am Animal" << endl;
   }
};

class Dog: public Animal
{
   public:
   void display()
   {
      cout << "I am a Dog" << endl;
   }
};

int main(void)
{
   Animal anim = Animal();
   anim.display();	//parent class object 

   Dog dg = Dog();
   dg.display();	// derived class object

   return 0;
}

Output:

I am Animal
I am a Dog

---