Access Specifiers in C++: Public, Private, and Protected

C++ is an object-oriented programming language that provides various mechanisms to manage access control for class members. Access specifiers—public, private, and protected—define how the members (attributes and methods) of a class can be accessed. Understanding these access levels is crucial for implementing data encapsulation, abstraction, and inheritance effectively in C++.

This article provides an in-depth discussion of access specifiers in C++, including their purpose, implementation, and impact on object-oriented programming.

1. Understanding Access Specifiers

Access specifiers determine the scope and visibility of class members. The three primary access specifiers in C++ are:

• public: Members are accessible from anywhere.
• private: Members are accessible only within the same class.
• protected: Members are accessible within the same class and derived classes.

By default, members of a class are private unless explicitly specified otherwise.

2. Public Access Specifier

Definition

A member declared as public can be accessed from outside the class. This means that objects of the class and other classes can access public members directly.

Example

#include <iostream>
using namespace std;

class Car {
public:
    string brand;

    void displayBrand() {
        cout << "Car brand: " << brand << endl;
    }
};

int main() {
    Car myCar;
    myCar.brand = "Tesla";  // Allowed because 'brand' is public
    myCar.displayBrand();
    return 0;
}

Key Points

• Public members can be accessed by objects and functions outside the class.
• They provide an interface for external code to interact with the class.
• Overuse of public members can violate encapsulation.

3. Private Access Specifier

Definition

A member declared as private is accessible only within the same class. Neither objects of the class nor derived classes can access private members directly.

Example

#include <iostream>
using namespace std;

class BankAccount {
private:
    double balance;

public:
    void setBalance(double amount) {
        balance = amount;
    }

    double getBalance() {
        return balance;
    }
};

int main() {
    BankAccount account;
    // account.balance = 1000; // Error: 'balance' is private
    account.setBalance(1000);
    cout << "Account balance: " << account.getBalance() << endl;
    return 0;
}

Key Points

• Private members cannot be accessed outside the class directly.
• They support data hiding and encapsulation.
• Access is usually provided through public getter and setter methods.

4. Protected Access Specifier

Definition

A member declared as protected behaves like a private member but with one exception: it can be accessed by derived classes.

Example

#include <iostream>
using namespace std;

class Employee {
protected:
    int salary;

public:
    void setSalary(int s) {
        salary = s;
    }
};

class Manager : public Employee {
public:
    void showSalary() {
        cout << "Salary: " << salary << endl;  // Allowed because 'salary' is protected
    }
};

int main() {
    Manager mgr;
    mgr.setSalary(50000);
    mgr.showSalary();
    return 0;
}

Key Points

• Protected members cannot be accessed outside the class, except in derived classes.
• Useful in inheritance where base class members need controlled access by derived classes.

5. Access Specifiers and Inheritance

Access specifiers influence how base class members are inherited. The following table summarizes how members of a base class behave in a derived class:

Example

#include <iostream>
using namespace std;

class Base {
public:
    int x;
protected:
    int y;
private:
    int z;
};

class Derived : public Base {
public:
    void show() {
        cout << x << endl;  // Allowed (inherited as public)
        cout << y << endl;  // Allowed (inherited as protected)
        // cout << z;      // Error: 'z' is private in Base
    }
};

int main() {
    Derived obj;
    obj.x = 10;   // Allowed
    // obj.y = 20; // Error: 'y' is protected
    obj.show();
    return 0;
}

6. Best Practices for Using Access Specifiers

• Use private for data members to enforce encapsulation.
• Use public for member functions that provide controlled access.
• Use protected when designing a class intended for inheritance.
• Avoid excessive use of public data members as it can lead to poor encapsulation.
• Consider getter and setter methods instead of making data members public.

Conclusion

Access specifiers in C++ play a crucial role in controlling the visibility of class members. Understanding the differences between public, private, and protected helps in implementing encapsulation, inheritance, and abstraction effectively. By following best practices, you can write robust and maintainable C++ programs.

Would you like to see a more advanced topic, such as friend functions or access control in multiple inheritance? Let us know in the comments!