Encapsulation in C++

Last Updated on March 28, 2023 by Prepbytes

A lot of developers nowadays uses something called the object-oriented programming paradigm. It is widely used because it can help make your code more reusable, maintainable, and modular. One key idea in OOP is called encapsulation. This means putting related data and functions together in a way that makes sense. We will learn encapsulation in C++, the features of encapsulation, and how we can implement encapsulation in C++ in this article.

What is Encapsulation in C++?

To put it simply, encapsulation is the act of limiting the parts of an object’s components to prevent users from having direct access to all of an object’s variables. It deals with hiding the complexity of the program. Encapsulation in C++ refers to the grouping of related data and functions into a single entity known as a class. By encapsulating these functions and related data, we protect them from any external change. This concept is also known as information or data concealment. Encapsulation is demonstrated in coding via containers, which group data and methods into a single package.

Features of Encapsulation in C++

Here are some features of encapsulation in C++:

• Data Hiding: Encapsulation allows us to hide the implementation details of a class from the outside world. In other words, we can say, that the internal workings and implementation of a class are kept hidden from other parts of the program.
• Abstraction: Encapsulation enables us to abstract the complex details of a class and present a simpler and more abstract interface to the outside world.
• Access Control: Encapsulation allows us to control access to the data and functions within a class. By using access specifiers such as public, private, and protected, we can control which parts of the program can access and modify the data and functions.
• Modularity: Encapsulation allows us to write self-contained chunks of code that can be reused in different parts of the program without rewriting the same code again

Role of Access Specifiers in Encapsulation

Access specifiers are an essential part of encapsulation in C++. They are used to control the visibility and accessibility of the data and functions within a class. In C++, access specifiers are classified as public, private, and protected.

• Public Access Specifier
  The public access specifier allows the data and functions to be accessed from anywhere in the program. This means that anyone outside the class can access or modify the public members of the class.

• Private Access Specifier
  The private access specifier limits the access of data and functions only within the class. The data and functions declared private can be accessed only by the member functions of the same class. So if someone tries to access private data and functions from outside the class it will result in a compile-time error.

• Protected Access Specifier
  The protected access specifier is similar to private, but the difference is that it allows the derived classes to access the members. The protected members can be accessed by member functions of the derived class or a friend function.

In short words, we can say, access specifiers, are an important feature of encapsulation in C++. They allow us to control the visibility and accessibility of the data and functions within a class, and enforce the principle of information hiding. By using access specifiers, we can create more secure, robust, and maintainable code that is easier to understand and modify over time.

Implementation of Encapsulation in C++

To implement encapsulation in C++, we can define a class with private data members and public member functions. The private data members can only be accessed through the public member functions. Here’s an example of how to implement encapsulation in C++:

#include <bits/stdc++.h>
using namespace std;

class Person {
private:
    string name;
    int age;
public:
    Person(string name, int age) {
    this->name = name;
    this->age = age;
    }
    void setName(string name) {
    this->name = name;
    }
    string getName() {
    return name;
    }
    void setAge(int age) {
    this->age = age;
    }
    int getAge() {
    return age;
    }
};

int main() {
Person person("Manoj", 21);

cout << "Name: " << person.getName() << endl;
cout << "Age: " << person.getAge() << endl;

person.setName("Himanshu");
person.setAge(25);

cout << "Name: " << person.getName() << endl;
cout << "Age: " << person.getAge() << endl;

return 0;
}

Output

Name: Manoj
Age: 21
Name: Himanshu
Age: 25

Explanation: In the above example, we have defined a class called Person which has private data members i.e name and age. The setters are used to set the values, while the getters are used to retrieve the value of these private data members.

Conclusion
In conclusion, encapsulation in C++ is an important concept that helps to protect data from unauthorized access and modification. By wrapping data and functions into a single unit, encapsulation improves code organization, readability, and security.

FAQs

Here are some frequently asked questions on encapsulation in C++.

Q1: What is the difference between private and protected access specifiers in C++?
Ans: Private members can only be accessed by member functions of the same class, while protected members can be accessed by member functions of both the same class and any derived classes.

Q2: How does encapsulation in C++ enhance the security of our data?
Ans: Encapsulation in C++ enhances the security of data by controlling access to the data within a class. Only the member functions of the class can access the data, which helps to prevent unauthorized access and modification.

Q3: Can private members of a class be accessed by a derived class?
Ans: No, private members of a class cannot be accessed by a derived class. Only protected members can be accessed by a derived class.

Q4: What is the role of getters and setters in encapsulation in C++?
Ans: Getters and setters are used to access and modify the private data members of a class from outside the class, while still maintaining encapsulation. They allow controlled access to private members, which helps to keep the data secure.

Q5: Is it possible to change the access specifiers of a class during runtime?
Ans: No, it is not possible to change the access specifiers of a class during runtime. They are set at the time of declaration and remain fixed.