C++ - Access Specifiers

Access Specifiers in C++

Introduction

In C++, access specifiers are used to define the accessibility (visibility) of the members (variables and functions) of a class. These specifiers allow you to control how the class members can be accessed and modified from outside the class. There are three primary access specifiers in C++:

• Public
• Private
• Protected

Understanding and using access specifiers properly is key to achieving good encapsulation and data protection in object-oriented programming.

Key Concepts

• Encapsulation: The process of bundling data and the functions that operate on that data into a single unit (class). Access specifiers help enforce this principle by restricting how data can be accessed or modified.
• Data Hiding: By using private and protected access specifiers, you can hide implementation details from the outside world, making your class more secure and easier to maintain.
• Member Functions: Functions inside a class can have varying levels of access to the class's data, depending on the access specifier applied to the data members.

Types of Access Specifiers

1. Public Access Specifier

The public access specifier makes the members of the class accessible from anywhere. This means that any function or object can access the public members of the class.

Syntax:

class ClassName {
public:
    // Public members
    int publicVar;
    void publicMethod();
};
    

Example:

class Student {
public:
    string name;
    int age;

    void displayInfo() {
        cout << "Name: " << name << endl;
        cout << "Age: " << age << endl;
    }
};

int main() {
    Student student;
    student.name = "John";  // Public member accessed directly
    student.age = 20;       // Public member accessed directly
    student.displayInfo();
    return 0;
}
    

In this example, the name and age members are public, so they can be directly accessed and modified in the main() function.

2. Private Access Specifier

The private access specifier restricts access to the members of the class. Private members can only be accessed by member functions of the same class. They cannot be accessed directly from outside the class.

Syntax:

class ClassName {
private:
    // Private members
    int privateVar;
    void privateMethod();
};
    

Example:

class Student {
private:
    string name;
    int age;

public:
    void setInfo(string studentName, int studentAge) {
        name = studentName;  // Private member accessed by member function
        age = studentAge;    // Private member accessed by member function
    }

    void displayInfo() {
        cout << "Name: " << name << endl;
        cout << "Age: " << age << endl;
    }
};

int main() {
    Student student;
    student.setInfo("John", 20);  // Private members accessed via public setter function
    student.displayInfo();
    return 0;
}
    

In this example, the name and age members are private, so they can only be modified or accessed by the public member function setInfo() and displayInfo().

3. Protected Access Specifier

The protected access specifier is similar to the private specifier, but with one key difference: protected members can be accessed by member functions of the same class and by derived classes (i.e., subclasses). However, protected members cannot be accessed directly from outside the class.

Syntax:

class ClassName {
protected:
    // Protected members
    int protectedVar;
    void protectedMethod();
};
    

Example:

class Base {
protected:
    string name;
    int age;

public:
    Base(string studentName, int studentAge) {
        name = studentName;
        age = studentAge;
    }
};

class Derived : public Base {
public:
    void displayInfo() {
        cout << "Name: " << name << endl;  // Protected member accessed in derived class
        cout << "Age: " << age << endl;    // Protected member accessed in derived class
    }
};

int main() {
    Derived student("John", 20);
    student.displayInfo();
    return 0;
}
    

In this example, the name and age members are protected in the Base class, so they are accessible from the Derived class but not from outside the class hierarchy.

Access Specifier in Practice

Example of Combining Access Specifiers

Access specifiers can be combined in a class to allow different levels of access. You can have private, protected, and public members within the same class.

class Account {
private:
    int balance;  // Private member

public:
    void deposit(int amount) {
        if (amount > 0) {
            balance += amount;  // Public function modifies private member
        }
    }

    void displayBalance() {
        cout << "Balance: " << balance << endl;  // Public function accesses private member
    }
};

int main() {
    Account myAccount;
    myAccount.deposit(100);  // Public function called
    myAccount.displayBalance();
    return 0;
}
    

Explanation of Code

• Private Members: The balance is a private member, so it cannot be accessed directly from outside the class.
• Public Functions: The functions deposit() and displayBalance() are public and can modify or access the private members of the class.

Summary of Access Specifiers

Access specifiers are an important part of class design in C++. They allow you to control how the data within a class can be accessed, ensuring proper encapsulation and data security. By using public, private, and protected access, you can design robust and secure classes that hide implementation details while providing necessary functionality to other parts of the program.