Difference Between Abstraction And Encapsulation In C++

Here in this post, I am going to discuss the difference between abstraction and encapsulation in C++. Here also understand the difference and also many students are confused about abstraction and encapsulation.

What is Abstraction?

Abstraction is a concept in object-oriented programming that “shows” only the most important features while “hiding” the rest. The basic goal of abstraction is to keep consumers away from unnecessary details. Abstraction is the process of picking data from a bigger pool in order to present the user only the relevant details of an item. It aids in the reduction of programming effort and complexity. It is one of the most crucial OOP ideas.

Example Of Abstraction:

#include <iostream> 
using namespace std; 

class Multiplication { 
   private: 
      // private variables 
      int Num1, Num2, Num3 
   public: 
      void mul(int num1, int num2) 
      { 
          Num1 = Num1; 
          Num2 = num2; 
          Num3 = num1 * num2; 
          cout << "Multiplication of the two number is : " << Num3< <endl; 
      } 
}; 
int main() 
{ 
    Summation myMul; 
    myMul.mul(5, 4); 
    return 0; 
} 

Output:

Multiplication of the two number is: 9 

The variables Num1, Num2, and Num3 are private in this case, and so inaccessible to any code outside of the class Multiplication. The variables in this example are set to values supplied as arguments to the sum method. This isn’t a perfect example because the values aren’t always set right before being used in this way, but it illustrates the reality of the implementation.

What is Encapsulation?

Encapsulation is a technique for making a complex system more user-friendly. The user does not need to be concerned about the system’s internal details or complications. Encapsulation is a method of combining data and the code that manipulates it into a single entity. It can be thought of as a protective wrapper that prevents random access to code declared outside of it.

Example Of Encapsulation:

#include <iostream> 
using namespace std; 

class EncapsulationExample { 
    private: 
        // we declare a as private to hide it from outside 
        int numeric; 
        
        public: 
        // set() function to set the value of a 
        void set(int input1) 
        { 
            numberic = input1; 
        } 
        
        // get() function to return the value of a 
        int get() 
        { 
            return numeric; 
        } 
}; 

// main function 
int main() 
{ 
    EncapsulationExample myInstance; 
    myInstance.set(10);
    cout << myInstance.get() << endl; 
    return 0; 
} 

Output:

10

The variable numeric is made private in this program so that it can only be read and edited using the methods get() and set() that are available within the class. As a result, we can conclude that the variable a, as well as the methods, set() and get(), have been bound together, resulting in encapsulation. There’s nothing remarkable about the method names “get()” or “set()” – there might be other ways that manipulate the variable numeric…this is what encapsulation is all about.

Encapsulation Example-2:

//Account And Sales Using Encapsulation

#include <iostream>

using namespace std;

class Account
{
private:
    int account_number;
    string account_holder_name;

public:
    void set_account(int ac_num, string ac_name)
    {
        account_number = ac_num;
        account_holder_name = ac_name;
    }

    void get_account()
    {
        cout << "Account Holder Name: " << account_holder_name << " Account_number: " << account_number;
    }
};

class Sales : public Account
{
private:
    int person_id;
    string person_name;

public:
    void set_sales(int p_id, string p_name)
    {
        person_id = p_id;
        person_name = p_name;
    }

    void get_sales()
    {
        cout << "\nSales Person Name: " << person_name << " Sales Person Id: " << person_id;
    }
};

class Organizaation : public Sales
{
public:
    Organizaation()
    {
        set_account(42325, "QWERTY");
        set_sales(5235, "Gopal");
    }
};

int main()
{
    Organizaation O;
    O.get_account();
    O.get_sales();
    return 0;
}

Output:

Account Holder Name: QWERTY Account_number: 42325
Sales Person Name: Gopal Sales Person Id: 5235 

Difference between Abstraction and Encapsulation: