Encapsulation in C++

Encapsulation is defined as the wrapping up of data and information in a single unit. In Object Oriented Programming, encapsulation is defined as binding together the data and the functions that manipulate them.

Consider a real-life example of encapsulation, in a company, there are different sections like the accounts section, finance section, sales section, etc. Now,

• The finance section handles all the financial transactions and keeps records of all the data related to finance. All the financial processes are done by this section.
• Similarly, the sales section handles all the sales-related activities and keeps records of all the sales.

This is what Encapsulation is.

Encapsulation in C++

In C++, OOPs encapsulation is implemented using classes and access specifiers that keeps the data, and the manipulating methods enclosed inside a single unit. The direct advantage of this packaging is that only the required components are visible to the user, and other information is hidden.

Example

class Person {
public:
    
    // Data/information
    int socialID;
    string name;

    // Functions that work in this data
    Person(string n, int id) {}
    bool validateID() {}
};

In the above, encapsulation is demonstrated through the Person class, which encapsulates both data and the methods that represents the details of a real-world person.

Encapsulation facilitates data hiding in C++ by using private, protected and public access specifiers for restricting access to the class member functions and data members. For example, the above class Person can be rewritten as:

class Person {
    
    // Data/information not accessible outside
    int socialID;
    string name;
    
public:

    // Functions that work in this data
    Person(string n, int id) {}
    bool validateID() {}
};

The class has two private data members: socialID and name. The private access specifier ensures that the socialID and name cannot be accessed directly from outside the class, enforcing data hiding. But there may be cases where you need to access or modify the private members such as name. This can be done by using getter and setter methods:

#include <iostream>
using namespace std;

// Class that represents a person
class Person {
    
    // private members that will be hidden
    int socialID;
    string name;
public:

    // public members that are accessible
    Person(string n, int id) {
        name = n;
        socialID = id;
    }
    string getName() {
        return name;
    }
    bool validateID() {
        if (socialID <= 1001 && socialID >= 0)
            return true;
        else
            return false;
    }
};

int main() {
    
    Person p1("Shubham", 503);
    if (!p1.validateID()) cout << "Invalid SocialID\n";
    
    cout << p1.getName();
    return 0;
}

Abhishek

Public method getName() provide controlled access to the name data. Similar function to modify the name can also be created.

Note: The general encapsulation can be implemented using techniques other than classes but in OOPs language, it is implemented using classes.

Advantages

Below are some main advantages of encapsulation:

• Modularity: Encapsulation promotes modularity by organizing code into separate objects that handle specific tasks, making the program more structured and easier to manage.
• Code Maintenance: Encapsulation helps in maintaining and updating the code more easily.
• Improved Security: By hiding data and restricting unauthorized access to it, encapsulation improves the security of the program.
• Decoupling: It helps in reducing the dependency between components of a system, allowing them to function independently and making the system easier to maintain and extend.
• Facilitates Implementation of Other OOP Features: It also makes it possible to implement other OOPs features such as polymorphism, inheritance, abstraction, etc.

Encapsulation and Abstraction

Encapsulation also leads to abstraction. Abstraction can be viewed as showing only the important information and ignoring the unimportant details and its internal working. In a class, public members functions are provided to the user without telling him/her about how it is implemented. That data remains hidden.

While both contribute to good OOP design, there are differences between encapsulation and abstraction:

Encapsulation is fundamentally about bundling data with the methods that operate on it to control access and prevent unintended modifications. Abstraction, on the other hand, is about interface design and simplification, presenting a high-level view while hiding complex implementation details.

Encapsulation is also different from data hiding. It is the technique that facilitates data hiding using access specifiers in OOPs language, but not the data hiding itself.