Access Specifiers: Public, Private, Protected

Access specifiers are crucial in C++ programming as they determine the accessibility of class members. They play a vital role in encapsulation, a core principle of object-oriented programming. In this detailed blog post, we will explore the three primary access specifiers in C++: public, private, and protected. We will delve into their syntax, usage, and significance, providing examples to illustrate their differences.

Understanding Access Specifiers

Access specifiers define how the members of a class can be accessed. They control the visibility and accessibility of class members from outside the class. In C++, there are three main access specifiers:

1. Public
2. Private
3. Protected

1. Public Access Specifier

Members declared as public are accessible from anywhere in the program. This means you can access public members from outside the class, as well as from within the class itself and its derived classes. Public access specifier is often used for member functions that need to be called from outside the class.

Syntax:

class ClassName {
public:
    // Public members
    dataType memberName;
    void memberFunction();
};

Example:

#include <iostream>
using namespace std;

class Car {
public:
    string brand;
    int year;

    void displayInfo() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

int main() {
    Car myCar;
    myCar.brand = "Toyota";
    myCar.year = 2020;
    myCar.displayInfo(); // Output: Brand: Toyota, Year: 2020
    return 0;
}

In this example, the brand and year data members and the displayInfo member function are declared as public. Consequently, you can access them directly from the main function.

2. Private Access Specifier

Members declared as private are only accessible within the class itself. You cannot access private members from outside the class, nor from derived classes. The private access specifier is useful for data hiding, a principle of encapsulation, where internal details of a class are hidden from the outside world.

Syntax:

class ClassName {
private:
    // Private members
    dataType memberName;
    void memberFunction();
};

Example:

#include <iostream>
using namespace std;

class Car {
private:
    string brand;
    int year;

public:
    void setBrand(string b) {
        brand = b;
    }

    void setYear(int y) {
        year = y;
    }

    void displayInfo() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

int main() {
    Car myCar;
    myCar.setBrand("Toyota");
    myCar.setYear(2020);
    myCar.displayInfo(); // Output: Brand: Toyota, Year: 2020
    return 0;
}

In this example, brand and year are private members. Therefore, you cannot access them directly from the main function. Instead, we use public member functions setBrand and setYear to set their values, and displayInfo to display them.

3. Protected Access Specifier

Members declared as protected are accessible within the class itself and its derived classes. However, they are not accessible from outside the class. The protected access specifier is often used in inheritance to allow derived classes to access base class members while keeping them hidden from the outside world.

Syntax:

class ClassName {
protected:
    // Protected members
    dataType memberName;
    void memberFunction();
};

Example:

#include <iostream>
using namespace std;

class Vehicle {
protected:
    string brand;
    int year;

public:
    void setBrand(string b) {
        brand = b;
    }

    void setYear(int y) {
        year = y;
    }
};

class Car : public Vehicle {
public:
    void displayInfo() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

int main() {
    Car myCar;
    myCar.setBrand("Toyota");
    myCar.setYear(2020);
    myCar.displayInfo(); // Output: Brand: Toyota, Year: 2020
    return 0;
}

In this example, brand and year are protected members of the Vehicle class. The Car class, which is derived from Vehicle, can access these protected members. However, you cannot access them directly from the main function.

Choosing the Right Access Specifier

Choosing the appropriate access specifier is essential for achieving proper encapsulation and data hiding. Here are some guidelines to help you decide:

• Public: Use public access specifier for member functions and variables that need to be accessible from outside the class. This includes functions that are part of the class’s public interface.

• Private: Use private access specifier for member functions and variables that should not be accessible from outside the class. This includes internal data that should be hidden from external access to maintain the integrity of the class.

• Protected: Use protected access specifier for member functions and variables that need to be accessible to derived classes but not from outside the class. This is useful in inheritance scenarios.

Summary

Access specifiers are a fundamental aspect of C++ programming, providing control over the visibility and accessibility of class members. By using public, private, and protected access specifiers appropriately, you can achieve better encapsulation and data hiding, leading to more robust and maintainable code. Understanding these access specifiers and their implications is crucial for any C++ programmer aiming to write efficient and secure object-oriented code.