Access Modifiers in C++

In C++, access modifiers or access specifiers in a class are used to assign the accessibility to the class members, i.e., they set some restrictions on the class members so that they can’t be directly accessed by the outside functions. Access modifiers are used to implement an important aspect of Object-Oriented Programming known as Data Hiding.

There are 3 types of access modifiers available in C++:

1. Public
2. Private (default)
3. Protected

Let us now look at each one of these access modifiers in detail.

1. Public Specifier

All the class members declared under the public specifier will be available to everyone. The data members and member functions declared as public can be accessed by other classes and functions too. The public members of a class can be accessed from anywhere in the program using the direct member access operator (.) with the object of that class. 

Example:

#include<iostream>
using namespace std;

// Class definition
class Circle {
public: 
    double radius;
    double  compute_area() {
        return 3.14*radius*radius;
    }
    
};

int main() {
    Circle obj;
    
    // Accessing public members outside class
    obj.radius = 5.5;
    cout << "Radius is: " << obj.radius << "\n";
    cout << "Area is: " << obj.compute_area();
    
    return 0;
}

Radius is: 5.5
Area is: 94.985

In the above program, the data member radius is declared as public so it could be accessed outside the class and thus was allowed access from inside main(). Same with the member function compute_area(). If we do not specify any access modifiers for the members inside the class, then by default the access modifier for the members will be Private.

2. Private Specifier

The class members declared as private can be accessed only by the member functions inside the class. They are not allowed to be accessed directly by any object or function outside the class. Only the member functions or the friend functions/ friend class are allowed to access the private data members of the class.

Example:

#include<iostream>
using namespace std;

class Circle {  
    
// private members
private: 
    double radius;
    double  compute_area() {

        // member function can access private 
        // data member radius
        return 3.14*radius*radius;
    }
    
};

int main() {
    Circle obj;
    
    // trying to access private data member
    // directly outside the class
    obj.radius = 1.5;
    cout << "Area is:" << obj.compute_area();
    
    return 0;
}

Output

main.cpp: In function ‘int main()’:
main.cpp:22:9: error: ‘double Circle::radius’ is private within this context
   22 |     obj.radius = 1.5;
      |         ^~~~~~
main.cpp:7:16: note: declared private here
    7 |         double radius;
      |                ^~~~~~
main.cpp:23:43: error: ‘double Circle::compute_area()’ is private within this context
   23 |     cout << "Area is:" << obj.compute_area();
      |                           ~~~~~~~~~~~~~~~~^~
main.cpp:8:17: note: declared private here
    8 |         double  compute_area() {

The output of the above program is a compile time error because we are not allowed to access the private data members of a class directly from outside the class. Yet an access to obj.radius is attempted, but radius being a private data member, we obtained the above compilation error.

How to Access Private Members?

The standard way to access the private data members of a class is by using the public member functions of the class. The function that provides the access is called getter method and the function that updates the value is called the setter method. 

Example: 

#include<iostream>
using namespace std;

class Circle {  
    
// private members
private: 
    double radius;
    
public:

    // Returns the private variable (getter)
    double getRadius() {
        return radius;
    }
    
    // Set the private variable (setter)
    void setRadius(double val) {
        radius = val;    
    }
    
    double  compute_area() {
        return 3.14*radius*radius;
    }
    
};

int main() {
    Circle obj;
    
    // Accessing private variables using public getter and setter methods
    obj.setRadius(1.5);
    cout << "Radius is: " << obj.getRadius() << endl;
    cout << "Area is: " << obj.compute_area();
    
    return 0;
}

Radius is: 1.5
Area is: 7.065

3. Protected Specifier

The protected access modifier is similar to the private access modifier in the sense that it can’t be accessed outside of its class unless with the help of a friend class. The difference is that the class members declared as Protected can be accessed by any subclass (derived class) of that class as well. 

Example: 

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

// base class
class Parent {   
protected:
    int id_protected;

};

// Derived class from public base class
class Child : public Parent {
    public:
    void setId(int id) {
        
        // Child class is able to access inherited 
        // protected data members of base class
        id_protected = id;
        
    }
    
    int getId() {
        return id_protected;
    }
};

int main() {
    Child obj1;
    
    obj1.setId(81);
    cout << "ID: " << obj1.getId();
    return 0;
}

ID: 81

Note: This access through inheritance can alter the access modifier of the elements of base class in derived class depending on the mode of Inheritance.

kartik

Follow

Improve

Article Tags :

• C++

Practice Tags :

• CPP