C++ Access Specifiers & Its Types (with Examples)

Encapsulation is one of the biggest features of C++ and Access Specifers are one of the practical ways to implement it. In this article, we will explore Access Specifiers in C++, their types with examples.

What are Access Specifiers in C++?

Access specifiers in C++ are keywords that determine the visibility and accessibility of class members. They play a crucial role in encapsulation, which is the principle of hiding implementation details and exposing only necessary interfaces.

They define the level of access that other parts of the program have to the members of a class. C++ provides three access specifiers:

1. Public: Public members are accessible from anywhere in the program. They can be accessed by objects of the class, derived classes, and even from outside the class. Public members represent the interface of the class, providing access to the functionality that the class exposes.
2. Private: Private members are only accessible within the class itself. They cannot be accessed by objects of the class or any other code outside the class. Private members encapsulate the internal implementation details of the class, ensuring data integrity and preventing direct modification.
3. Protected: Protected members are similar to private members in that they are not accessible from outside the class. However, they are accessible by derived classes. Protected members provide a way to expose certain data and functionality to derived classes while still hiding them from other parts of the program.

Let's consider an example to demonstrate the usage of access specifiers in C++:

#include <iostream>

class MyClass {
public:
int publicVar;

private:
int privateVar;

protected:
int protectedVar;
};

int main() {
MyClass obj;
obj.publicVar = 42; // Accessing public member
// obj.privateVar = 0; // Error: private member inaccessible
// obj.protectedVar = 0; // Error: protected member inaccessible

return 0;
}

In this example, we define a class named `MyClass` with three member variables: `publicVar`, `privateVar`, and `protectedVar`.

The `publicVar` is declared as public, meaning it can be accessed from outside the class. The `privateVar` is declared as private, restricting access to within the class. The `protectedVar` is declared as protected, allowing access from derived classes but not from outside the class. In the `main()` function, we demonstrate the accessibility of the members.

Role of Access Specifiers in Encapsulation

Access specifiers play a crucial role in encapsulation, which is the process of bundling data and methods into a single unit, known as a class. Encapsulation provides data hiding and abstraction, allowing the internal implementation details to be hidden from external code. Access specifiers facilitate encapsulation by controlling the visibility of members and enforcing information hiding.

By declaring data members as private, you prevent direct access from outside the class. This ensures that the internal state of the class remains consistent and allows you to enforce necessary constraints or perform additional operations when the data is accessed or modified.

Public members serve as the interface to the class, providing a controlled way to interact with the class from external code. They define the operations that can be performed on the class objects and allow access to the necessary functionality.

Protected members are primarily used in inheritance scenarios, where derived classes need access to certain members. They strike a balance between public and private access, providing controlled accessibility to derived classes while still maintaining the encapsulation and data integrity of the base class.

How to Access Private Members of a Class in C++?

Private members are inaccessible from outside the class. However, C++ provides a mechanism to access private members using member functions or friend functions. Member functions are class functions that have access to private members, allowing them to read or modify the private data.

Friend functions, on the other hand, are functions declared as friends within the class, granting them access to private members.

Here's an example demonstrating the usage of member functions to access private members:

#include <iostream>

class MyClass {
private:
int privateVar;

public:
void setPrivateVar(int value) {
privateVar = value;
}

int getPrivateVar() const {
return privateVar;
}
};

int main() {
MyClass obj;
obj.setPrivateVar(42); // Accessing and modifying private member
std::cout << "PrivateVar: " << obj.getPrivateVar() << std::endl; // Accessing private member

return 0;
}

In this example, the `setPrivateVar()` member function allows us to set the value of the private member `privateVar`, while the `getPrivateVar()` member function enables us to retrieve the value. These member functions act as intermediaries, providing controlled access to the private member.

Conclusion

Access specifiers in C++ are essential for controlling the visibility and accessibility of class members. Armed with this knowledge, you can effectively design and organize your C++ classes, promoting secure and maintainable code.