Encapsulation in C++

A key idea in object-oriented programming (OOP) is encapsulation, which permits data hiding and gives classes a way to isolate their implementation details from their clients. C++ is an OOP language that provides several features for implementing encapsulation, such as access specifiers and member functions. In this post, we'll examine the C++ implementation of the encapsulation principle.

Encapsulation in C++:

The act of encapsulating involves combining data and the methods that manipulate it into a single entity, referred to as a class. A class in C++ is a user-defined data type that has member methods and data members. The member functions are methods that work on the data members, which are variables that hold an object's state.

Access specifiers:

C++ provides three access specifiers, public, private, and protected, to control the accessibility of class members. Anywhere in the programme can access the members thanks to the public access specifier. Only the member functions of the class are permitted access to the members thanks to the private access specifier. The member functions of the class and its derived classes are able to access the members thanks to the protected access specifier.

By default, all the members of a class are private. Therefore, we need to specify the access specifiers explicitly to control the accessibility of the members.

Member functions:

Member functions are functions that are defined inside a class and operate on the data members of that class. Because they are a component of the class, member functions can access the private members of the class. Member functions can be classified into two types: accessor functions and mutator functions.

Accessor functions are member functions that provide read-only access to the data members of a class. Accessor functions do not modify the state of the object. Examples of accessor functions include get() and display() functions.

Mutator functions are member functions that modify the state of the object by changing the value of the data members. Mutator functions have access to and control over a class's private members. Examples of mutator functions include set() and update() functions.

Data hiding:

Data hiding is an important aspect of encapsulation that enables the data members of a class to be hidden from the clients of the class. By making the data members private and enabling accessor and mutator functions to access and modify the data members, data hiding can be accomplished.

Here's a simple example of encapsulation in C++:

#include <iostream>
using namespace std;

class Employee {
private:
    int empId;
    string empName;
    float empSalary;

public:
    void setEmpId(int id) {
        empId = id;
    }

    void setEmpName(string name) {
        empName = name;
    }

    void setEmpSalary(float salary) {
        empSalary = salary;
    }

    int getEmpId() {
        return empId;
    }

    string getEmpName() {
        return empName;
    }

    float getEmpSalary() {
        return empSalary;
    }
};

int main() {
    Employee emp;
    emp.setEmpId(101);
    emp.setEmpName("John Doe");
    emp.setEmpSalary(5000.0);

    cout << "Employee ID: " << emp.getEmpId() << endl;
    cout << "Employee Name: " << emp.getEmpName() << endl;
    cout << "Employee Salary: " << emp.getEmpSalary() << endl;

    return 0;
}

In this example, we have defined a class named Employee that has three private data members: empId, empName, and empSalary. We have also defined six public member functions: setEmpId(), setEmpName(), setEmpSalary(), getEmpId(), getEmpName(), and getEmpSalary().

The values of the private data members are set using the set functions, which are mutator functions. The values of the private data members are retrieved using the get functions, which are accessor functions.

In the main() function, we have created an object of the Employee class and used the mutator functions to set the values of the private data members. We have then used the accessor functions to get the values of the private data members and printed them to the console.

Output:

Employee ID: 101
Employee Name: John Doe
Employee Salary: 5000

In this way, encapsulation is implemented in C++ using access specifiers and member functions. The private data members are hidden from the outside world, and the public member functions provide a controlled interface to access and modify them.

Benefits of encapsulation:

Encapsulation provides several benefits, including:

Improved code maintainability: Encapsulation helps in improving the code maintainability by providing a clear separation between the implementation details of a class and its clients.
Data hiding: Encapsulation enables data hiding, which protects the data members of a class from being accessed and modified by the clients of the class.
Code reuse: Encapsulation helps in code reuse by providing a modular design that can be easily extended and modified.
Security: Encapsulation provides security by preventing unauthorized access to the data members of a class.

Conclusion:

In conclusion, encapsulation is a fundamental concept in object-oriented programming that enables data hiding and provides a mechanism for separating the implementation details of a class from its clients. C++ provides several features for implementing encapsulation, such as access specifiers and member functions. Encapsulation provides several benefits, including improved code maintainability, data hiding, code reuse, and security. Therefore, encapsulation is an essential concept in C++ programming that should be understood and applied correctly.

Next TopicOpenGL C++

← prev next →