Access specifiers are a crucial part of Object-Oriented Programming in C++. They define the scope and visibility of class members (variables and methods). By controlling access, specifiers help implement the principle of encapsulation, ensuring that sensitive data is not exposed unnecessarily. In this blog, we’ll explore the three main access specifiers in C++: public, private, and protected.

What Are Access Specifiers?

Access specifiers in C++ determine how class members can be accessed in your program. They allow you to control which parts of a program can interact with certain class properties and methods. This is a fundamental feature that supports encapsulation and data hiding in object-oriented programming.

Types of Access Specifiers in C++

C++ provides three types of access specifiers:

• Public: Members declared as public can be accessed from anywhere in the program.
• Private: Members declared as private can only be accessed within the class itself.
• Protected: Members declared as protected can be accessed within the class and by derived classes.

Public Access Specifier

When a class member is declared as public, it is accessible from outside the class. Public members are typically used when you want your class interface (functions) to be used freely by other parts of the program.

    #include <iostream>
    using namespace std;

    class MyClass {
    public:
        int x;
    };

    int main() {
        MyClass obj;
        obj.x = 10;  // Allowed
        cout << "Value: " << obj.x;
        return 0;
    }
    

Private Access Specifier

Private members cannot be accessed directly from outside the class. They are only accessible within the class itself. This helps in securing the data and allows controlled access through public methods.

    #include <iostream>
    using namespace std;

    class MyClass {
    private:
        int x;

    public:
        void setX(int val) {
            x = val;
        }

        int getX() {
            return x;
        }
    };

    int main() {
        MyClass obj;
        obj.setX(25);
        cout << "Value: " << obj.getX();
        return 0;
    }
    

Here, x is private and can only be accessed through the public methods setX() and getX().

Protected Access Specifier

Protected members are like private members but with one key difference: they can be accessed by derived classes. This is useful in inheritance when you want child classes to have access to certain data members of the parent class.

    #include <iostream>
    using namespace std;

    class Base {
    protected:
        int x;
    };

    class Derived : public Base {
    public:
        void setX(int val) {
            x = val;
        }

        void display() {
            cout << "Value: " << x;
        }
    };

    int main() {
        Derived obj;
        obj.setX(40);
        obj.display();
        return 0;
    }
    

In this example, x is a protected member of the base class and is accessible within the derived class.

Default Access Specifier

In C++, the default access specifier for class members is private if no specifier is explicitly mentioned. However, in structures (struct), the default is public.

    class MyClass {
        int x;  // private by default
    };

    struct MyStruct {
        int x;  // public by default
    };
    

When to Use Each Specifier

• Use private for data members that should not be directly accessed from outside the class.
• Use public for methods that need to be used by other classes or functions.
• Use protected when you expect to create derived classes that need access to certain members.

Conclusion

Access specifiers in C++ are essential tools for defining how members of a class can be accessed and used. By using public, private, and protected wisely, you can create well-structured, secure, and maintainable object-oriented programs. Understanding how and when to use each access specifier is a critical skill for any C++ programmer.