Access Modifiers in C++

Access modifiers are used to implement an important aspect of Object-Oriented Programming known as Data Hiding. Consider a real-life example: 
The Research and analysis wing (R&AW), having 10 core members has come in possession of sensitive confidential information regarding national security. Now we can corelate these core members to data members or member functions of a class which in turn can be corelated to the R&A wing. These 10 members can directly access confidential information from their wing (the class), but anyone apart from these 10 members can’t access this information directly i.e. outside functions other than those prevalent in the class itself can’t access information that is not entitled to them, without having either assigned privileges (such as those possessed by friend class and inherited class as will be seen in this article ahead) or access to one of these 10 members who is allowed direct access to the confidential information (similar to how private members of a class can be accessed in the outside world through public member functions of the class that have direct access to private members). This is what data hiding is in practice. 
Access Modifiers or Access Specifiers in a class are used to assign the accessibility to the class members. That is, it sets some restrictions on the class members not to get directly accessed by the outside functions.
There are 3 types of access modifiers available in C++: 

  1. Public
  2. Private
  3. Protected

Note: 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.

Let us now look at each one these access modifiers in details:
 1. Public: 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: 

CPP

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to demonstrate public
// access modifier
 
#include<iostream>
using namespace std;
 
// class definition
class Circle
{
    public:
        double radius;
         
        double  compute_area()
        {
            return 3.14*radius*radius;
        }
     
};
 
// main function
int main()
{
    Circle obj;
     
    // accessing public datamember outside class
    obj.radius = 5.5;
     
    cout << "Radius is: " << obj.radius << "\n";
    cout << "Area is: " << obj.compute_area();
    return 0;
}

chevron_right


Output: 



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(). 
 2. Private: 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 are allowed to access the private data members of a class. 

Example: 

CPP

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to demonstrate private
// access modifier
 
#include<iostream>
using namespace std;
 
class Circle
{  
    // private data member
    private:
        double radius;
      
    // public member function   
    public:   
        double  compute_area()
        {   // member function can access private
            // data member radius
            return 3.14*radius*radius;
        }
     
};
 
// main function
int main()
{  
    // creating object of the class
    Circle obj;
     
    // trying to access private data member
    // directly outside the class
    obj.radius = 1.5;
     
    cout << "Area is:" << obj.compute_area();
    return 0;
}

chevron_right


Output

 In function 'int main()':
11:16: error: 'double Circle::radius' is private
         double radius;
                ^
31:9: error: within this context
     obj.radius = 1.5;
         ^

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

However, we can access the private data members of a class indirectly using the public member functions of the class. 

Example: 

CPP

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to demonstrate private
// access modifier
 
#include<iostream>
using namespace std;
 
class Circle
{  
    // private data member
    private:
        double radius;
      
    // public member function   
    public:   
        void compute_area(double r)
        {   // member function can access private
            // data member radius
            radius = r;
             
            double area = 3.14*radius*radius;
             
            cout << "Radius is: " << radius << endl;
            cout << "Area is: " << area;
        }
     
};
 
// main function
int main()
{  
    // creating object of the class
    Circle obj;
     
    // trying to access private data member
    // directly outside the class
    obj.compute_area(1.5);
     
     
    return 0;
}

chevron_right


Output

Radius is: 1.5
Area is: 7.065

3. Protected: Protected access modifier is similar to private access modifier in the sense that it can’t be accessed outside of it’s class unless with the help of 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. 

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

Example: 

CPP

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to demonstrate
// protected access modifier
#include <bits/stdc++.h>
using namespace std;
 
// base class
class Parent
{  
    // protected data members
    protected:
    int id_protected;
    
};
 
// sub class or derived class from public base class
class Child : public Parent
{
    public:
    void setId(int id)
    {
         
        // Child class is able to access the inherited
        // protected data members of base class
         
        id_protected = id;
         
    }
     
    void displayId()
    {
        cout << "id_protected is: " << id_protected << endl;
    }
};
 
// main function
int main() {
     
    Child obj1;
     
    // member function of the derived class can
    // access the protected data members of the base class
     
    obj1.setId(81);
    obj1.displayId();
    return 0;
}

chevron_right


Output

id_protected is: 81

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :


71


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.