Access Modifiers in C++: public, private & protected Explained

In C++, when you declare members inside a class or struct without specifying an access modifier, the language assigns a default access level. This default behavior is an important part of access control and affects encapsulation and data hiding.

• For classes:
  The default access specifier is private. This means that if you do not explicitly specify public, protected, or private, all members are only accessible within the class itself.
• For structs and unions:
  The default access specifier is public. Members are accessible from anywhere in the program unless you specify otherwise.

Example:

class MyClass 
{ 
int x; // here, x is private by default
}; 
struct MyStruct 
{ 
int y; // y is public by default 
};

In the example above:

• x in MyClass is private, so it cannot be accessed from outside the class.
• y in MyStruct is public, so it can be accessed from anywhere.

This​‍​‌‍​‍‌​‍​‌‍​‍‌ difference is helpful in that it allows classes to hide their data (which is a good thing in terms of encapsulation), whereas structs can still be used as mere data holders with freely accessible members.

Note:

Unions in C++ also default their member access to public, similar to structs.

C++ has three fundamental access modifiers: public, private, and protected. These are three different levels of access to class members implemented to control the access given to other ​‍​‌‍​‍‌​‍​‌‍​‍‌components.

Usage Examples of Access Modifiers in C++

1. Public Access Modifier in C++

In C++, access modifiers determine the visibility and accessibility of class members (variables and functions) within and outside the class. The public access modifier is the most permissive of all, allowing members to be accessed from any part of the program.

Characteristics of Public Members:

1. Accessible Everywhere: When a class member is declared as public, it can be accessed from within the class itself, from derived (child) classes, and even from external functions or objects outside the class. There are no restrictions on accessing or modifying public members.
2. Forms the Interface of a Class: Typically, public members define the interface of a class, allowing users of the class to interact with its data and functions. Functions declared as public act as a bridge between the class's internal data and the external world.
3. No Encapsulation for Public Variables: While making variables public offers ease of access, it also violates the principle of encapsulation, as data can be modified freely from outside the class. This can lead to unintended modifications, causing potential security risks or logical errors in the program.

Example: Public Members in a Class

Let's take a simple example of Access Modifiers in C++ where the Rectangle class is defined with public variables and ​‍​‌‍​‍‌​‍​‌‍​‍‌methods.

Code Implementation:

#include <iostream>

class Rectangle {
public:
    // Public member variables
    double length;
    double width;

    // Public member function to calculate the area
    double calculateArea() {
        return length * width;
    }
};

int main() {
    // Creating an object of Rectangle class
    Rectangle rect;

    // Directly accessing and modifying public members
    rect.length = 5.0;
    rect.width = 3.0;

    // Calling the public member function
    std::cout << "Area of rectangle: " << rect.calculateArea() << std::endl;

    return 0;
}

Explanation of the Code:

Class Definition (Rectangle): The Rectangle class has two public data members: length and width. It also has a public function, calculateArea(), which computes and returns the area of the rectangle.

Object Creation and Direct Access: In main(), an object rect of class Rectangle is created. The length and width members are directly accessed and modified using dot notation (rect.length = 5.0; and rect.width = 3.0;). The calculateArea() function is then called to compute the area.

Output

Area of rectangle: 15

Improved Version with Encapsulation:

#include <iostream>

class Rectangle {
private:
    double length;
    double width;

public:
    // Setter methods to control data modification
    void setDimensions(double l, double w) {
        if (l > 0 && w > 0) {
            length = l;
            width = w;
        } else {
            std::cout << "Invalid dimensions! Length and width must be positive." << std::endl;
        }
    }

    // Getter method to calculate the area
    double calculateArea() {
        return length * width;
    }
};

int main() {
    Rectangle rect;
    
    // Using setter to assign values
    rect.setDimensions(5.0, 3.0);

    // Calling a public function to get the area
    std::cout << "Area of rectangle: " << rect.calculateArea() << std::endl;

    return 0;
}

Explanation

The​‍​‌‍​‍‌​‍​‌‍​‍‌ given code demonstrates a class Rectangle which has two data members length and width encapsulated within the class. The code uses setter functions for these variables which also perform the validation to check if these variables are positive or not thereby the code promotes good programming practice and maintains data integrity. There is a function calculateArea whose task is to do the calculation of the rectangle area and return the result. In the main function, the values of the rectangle are given by the setter function, and then the calculation of the area is done by calling the public method. This example is a good one for the concept of encapsulation, which shows how you can control the access of data in a class and, at the same time, ensure that valid input is given.

Output

Area of rectangle: 15

2. Private Access Modifier in C++

Access Modifiers in C++ control how and where the class members (variables and functions) that are turned on by the different access modifiers can be seen and used. The private access modifier is a tool that is put to use in the class to ensure that the members of such a class only get accessed and changed within the class itself.

Characteristics of Private Members

1. Accessible Only Within the Class: Private members are not allowed to be exposed directly outside the class. Only member functions of the same class have the right to modify private variables.
2. Ensures Data Hiding and Encapsulation: One of the ways private members bolster the data-hiding mechanisms is by not letting one directly modify the internal state of an object through them. This is indeed a way of introducing and enforcing data integrity as well as preventing the occurrence of unintended changes or the instantiation of the improper values.
3. Requires Public Methods for Interaction: The benefit of having private members is that you are sure that no one other than the class holder will tamper with these members, thus ensuring security and data consistency. To still be able to interact with these private members, we have to write public methods, which are essentially getters and setters that expose these members in a controlled ​‍​‌‍​‍‌​‍​‌‍​‍‌way.

Example: Private Members in a Class

#include <iostream>

class Rectangle {
private:
    double length;
    double width;

public:
    // Setter method to assign values (controlled access)
    void setDimensions(double l, double w) {
        if (l > 0 && w > 0) {
            length = l;
            width = w;
        } else {
            std::cout << "Invalid dimensions! Length and width must be positive." << std::endl;
        }
    }

    // Getter method to calculate the area
    double calculateArea() {
        return length * width;
    }
};

int main() {
    Rectangle rect;

    // Using setter to assign values
    rect.setDimensions(5.0, 3.0);

    // Calling a public function to get the area
    std::cout << "Area of rectangle: " << rect.calculateArea() << std::endl;

    return 0;
}

Explanation of the Code:

1. Class Definition (Rectangle): The Rectangle class has two private data members: length and width. A public method setDimensions(), is used to assign values to these private members. A public method calculateArea(), computes and returns the area of the rectangle.
2. Object Creation and Access Control: In main(), an object rect of class Rectangle is created. The function setDimensions(5.0, 3.0) is called to set values for length and width. Direct access like rect.length = 5.0 would cause a compilation error because length is private. The function calculateArea() is called to compute and return the area.

Output

Area of rectangle: 15

What Happens if We Try to Access Private Members Directly?

If we attempt to modify length or width directly, like this:

Rectangle rect;
rect.length = 5.0;  // Compilation Error: 'length' is private
rect.width = 3.0;   // Compilation Error: 'width' is private

We get a compilation error stating that length and width are private and cannot be accessed outside the class.

Why Use Private Members? (Advantages of Encapsulation)

Prevents Direct Modification: By keeping member variables private, we prevent unintended changes and protect object integrity.

Ensures Controlled Access: We can enforce validation inside setter methods to ensure valid data is stored. Example: Preventing negative values in setDimensions().

Enhances Maintainability: Changes to internal implementation won’t affect external code as long as the public interface (methods) remains the same.

3. Protected Access Modifier in C++

In C++, access modifiers determine the visibility and accessibility of class members (variables and functions). Private and the protected access modifier are comparable, however there is a crucial difference:

• Protected members cannot be accessed from outside the class (just like private members).
• However, they can be accessed within derived (child) classes.

This feature is especially helpful in inheritance, where a base class may want to give access to its members for derived classes but prohibiting direct access from outside the class hierarchy.

Characteristics of Protected Members

1. Not Accessible Outside the Class: Similar to private members, protected members cannot be accessed directly using an object of the class.
2. Accessible in Derived Classes: Unlike private members, protected members can be inherited and used by derived (child) classes. This allows controlled access while still maintaining encapsulation.
3. Useful in Inheritance Hierarchies: In case of designing a class that is going to be inherited, protected members give the possibility to the derived classes to use and change the base class data and at the same time, the data remains inaccessible to the ​‍​‌‍​‍‌​‍​‌‍​‍‌outside.

Example: Using Protected Members in an Inheritance Hierarchy

#include <iostream>

// Base class
class Shape {
protected:
    double area;  // Protected member
};

// Derived class inheriting from Shape
class Rectangle : public Shape {
private:
    double length;
    double width;

public:
    // Public method to set dimensions and calculate area
    void setDimensions(double l, double w) {
        length = l;
        width = w;
        area = length * width;  // Accessing protected member of base class
    }

    // Public method to display the area
    void displayArea() {
        std::cout << "Area of rectangle: " << area << std::endl;
    }
};

int main() {
    Rectangle rect;

    // Setting dimensions
    rect.setDimensions(5.0, 3.0);

    // Displaying the area
    rect.displayArea();

    return 0;
}

Explanation

The​‍​‌‍​‍‌​‍​‌‍​‍‌ code introduces a base class Shape that has a protected member area. The derived class Rectangle extends the Shape and has private members length and width. In the Rectangle class, the setDimensions method assigns the values to length and width, and also calculates the area which is then stored in the protected area member. The displayArea method outputs the area of the rectangle that has been calculated. At the end of the program, the main function instantiates a Rectangle object, sets its dimensions, and prints the ​‍​‌‍​‍‌​‍​‌‍​‍‌area.

Output

Area of rectangle: 15

What Happens If We Try to Access Protected Members Outside the Class?

If we try to access area directly from main(), like this:

int main() {
    Rectangle rect;
    rect.area = 20;  //  Compilation Error: 'area' is protected
    return 0;
}

Example: Extending Inheritance with More Derived Classes

When dealing with several derived classes, protected members are extremely helpful.

#include <iostream>

// Base class
class Shape {
protected:
    double area;
};

// First derived class
class Rectangle : public Shape {
private:
    double length;
    double width;

public:
    void setDimensions(double l, double w) {
        length = l;
        width = w;
        area = length * width;  // Accessing protected member
    }

    void displayArea() {
        std::cout << "Rectangle Area: " << area << std::endl;
    }
};

// Second derived class
class Circle : public Shape {
private:
    double radius;

public:
    void setRadius(double r) {
        radius = r;
        area = 3.14159 * radius * radius;  // Accessing protected member
    }

    void displayArea() {
        std::cout << "Circle Area: " << area << std::endl;
    }
};

int main() {
    Rectangle rect;
    Circle circ;

    rect.setDimensions(5.0, 3.0);
    circ.setRadius(4.0);

    rect.displayArea();
    circ.displayArea();

    return 0;
}

Explanation

The given code introduces a parent class, Shape, having a protected member area. Two child classes, Rectangle and Circle, inherit from Shape, and both have instance methods to get the area. The Rectangle class, after setting the length and width through setDimensions, calculates the area. On the other hand, the Circle class obtains the area through the radius. Both classes use the area variable from the base class, which is protected, to store and later display the obtained area. 

Output

Rectangle Area: 15
Circle Area: 50.2654

Both Rectangle and Circle classes derive from Shape. They also share a protected member area, which is a demonstration of one of the uses of the protected members in multiple inheritance.

Quick Recap

C++ provides three access modifiers, public, private, and protected, each defining how class members can be accessed.

• Public members are available from any place and usually constitute the class interface. They can be freely accessed but may lead to encapsulation being broken if used as data variables.
• Private members can only be accessed from within the class they are declared in. They serve as data hiding mechanisms and hence, require the use of getters and setters for controlled access which in turn increases class reliability and ensures data integrity.
• Protected members are similar to private members in that they are not visible to other classes, but unlike them, they can also be accessed by derived classes. They are important in inheritance hierarchies where internal data needs to be shared among different levels, but still be under some control.

These three modifiers, when used together, determine how data is transferred between classes, provide safer code boundaries, and support the principles of object-oriented ​‍​‌‍​‍‌​‍​‌‍​‍‌design. 

Access control in inheritance determines how the access specifiers (public, protected, private) of base class members affect their accessibility in derived classes. The rules governing this behavior are essential for understanding how encapsulation and data hiding work across class hierarchies in C++.

Key Rules for Access Control in Inheritance

• Base Member Access vs. Inheritance Mode
  When a class is inherited, the accessibility of its base members in the derived class depends on:
  
  • The original access specifier of the member in the base class.
  • The inheritance mode (public, protected, or private) used in the derived class declaration.
• Effect of Inheritance Modes
  
  • Public Inheritance:
    
    • public base members remain public in the derived class.
    • protected base members remain protected in the derived class.
    • private base members are not accessible in the derived class.
  • Protected Inheritance:
    
    • public and protected base members become protected in the derived class.
    • private base members remain inaccessible.
  • Private Inheritance:
    
    • public and protected base members become private in the derived class.
    • private base members remain inaccessible.
• Default Inheritance Mode
  
  • If the inheritance mode is not specified:
    
    • For classes, inheritance is private by default.
    • For structs, inheritance is public by default.
• Access to Private Members
  
  • Private members of the base class are never accessible directly in derived classes, regardless of the inheritance mode.
• Multiple Inheritance and Virtual Base Classes
  
  • In multiple inheritance, if a member can be reached through more than one path with different access levels, the compiler uses the most accessible path.
  • Virtual​‍​‌‍​‍‌​‍​‌‍​‍‌ base class in C++ may change how access paths are figured, and the maximum access that is allowed will be used.
• Pointer and Reference Conversions
  
  • Access control can restrict pointer or reference conversions to base classes if the inheritance mode is private or protected.

Example Table: Member Accessibility After Inheritance

Example Scenario

Suppose you have:

class Base {
public:
    int pub;

protected:
    int prot;

private:
    int priv;
};

class Derived1 : public Base {
    // pub remains public
    // prot remains protected
    // priv is inaccessible
};

class Derived2 : protected Base {
    // pub becomes protected
    // prot remains protected
    // priv is inaccessible
};

class Derived3 : private Base {
    // pub becomes private
    // prot becomes private
    // priv is inaccessible
};

Special Case:

If you use a pointer or reference to a derived class with private or protected inheritance, you may not be able to convert it to a base class pointer/reference outside the derived class.

Access modifiers in C++ form the foundation of secure and well-structured object-oriented programming. They​‍​‌‍​‍‌​‍​‌‍​‍‌ control the flow of data inside and outside of classes, thus, making sure that an object is only exposed to the necessary parts. With the help of public, private, and protected access levels, which are used effectively, developers are able to protect internal data, create stable interfaces, and design class hierarchies that are not only flexible but also easy to maintain. Knowing these modifiers thoroughly is necessary when you want to write C++ code that is neat, strong, and can grow in size, no matter if you are making simple models or complex, multi-layered ​‍​‌‍​‍‌​‍​‌‍​‍‌systems.

Points to Remember

• public, private, and protected control how class members can be accessed.
• Private is ideal for protecting data and enforcing encapsulation.
• Public defines the external interface of a class, exposing behavior, not internal data.
• Protected supports inheritance by allowing controlled access in derived classes.
• Default access: class → private, struct/union → public.
• Private members are never accessible in derived classes; protected members are.
• Before setting a value to a private attribute, use a getter to validate the data.
• Choose inheritance mode carefully; public, private, and protected inheritance affect access.
• Encapsulation makes the program more secure, less error-prone, and easier for long-term maintenance.

1. What are access modifiers in C++?

Access modifiers in C++ are three keywords - public, private, and protected through which the visibility and accessibility of class members are controlled, thus maintaining the principles of data encapsulation and ensuring the security of the data.

2. What do you mean by default access modifier in C++?

The default access modifier for classes is private, which indicates that the members are accessible only within the same class unless specified otherwise explicitly.

3. What is the difference between private and protected?

Private members are only accessible within the class itself, while protected members can also be accessed in derived (child) classes.

4. Can a private member be accessed outside the class?

No, private members cannot be accessed directly outside the class. However, they can be accessed using public member functions or friend functions/classes.

5. How does the public access modifier work in inheritance?

If a class inherits another class publicly, then all public members of the parent class will stay public in the child class, and the protected members will remain protected.

6. What is the role of friend functions in access control?

A friend function can access the private and protected members of a class, even though it is not a member of that class. It is specified using the friend keyword.

7. Why is private used more than public in class design?

By making the data members private, the principle of encapsulation is better upheld since direct modification is prevented and the access to the data is controlled via getter and setter methods.

8. Can constructors and destructors have access modifiers?

Yes, constructors and destructors can have access modifiers. Making a constructor private is useful in singleton design patterns to restrict object creation.