Acess Specifiers in C++

Access specifiers in C++ are used to define the level of access that a class member variable or function can have. In C++, there are three access specifiers: public, private, and protected. The public access specifier is used to specify that a class member can be accessed from anywhere, both inside and outside the class. This means that any function or object can access the public members of the class. The public members of a class are typically used to represent the interface of the class. The private access specifier is used to specify that a class member can only be accessed from within the class. This means that any function or object outside the class cannot access the private members of the class. The private members of a class are typically used to represent the implementation of the class and are hidden from the outside world.

The protected access specifier is used to specify that a class member can be accessed from within the class and its derived classes. This means that any function or object outside the class hierarchy cannot access the protected members of the class. The protected members of a class are typically used to represent the implementation of a class that should be accessible to its derived classes. The choice of access specifier to use for a class member depends on the intended use of the member. If a member variable or function needs to be accessed from outside the class, it should be declared as public. If a member variable or function needs to be used only within the class, it should be declared as private. If a member variable or function needs to be used within the class hierarchy, it should be declared as protected. One important aspect of access specifiers is encapsulation. Encapsulation is the process of hiding the implementation details of a class from the outside world. By using access specifiers, a class can control the level of access to its members and thus control the level of encapsulation.

C++ Code

#include <iostream>
using namespace std;
class MyClass {
public:
    int publicVar;      // can be accessed from anywhere
    void publicFunc() { // can be accessed from anywhere
        cout << "This is a public function" << endl;
    }
private:
    int privateVar;     // can only be accessed from within the class
    void privateFunc() {// can only be accessed from within the class
        cout << "This is a private function" << endl;
    }
protected:
    int protectedVar;   // can only be accessed from within the class and its derived classes
    void protectedFunc(){// can only be accessed from within the class and its derived classes
        cout << "This is a protected function" << endl;
    }
};
class DerivedClass : public MyClass {
public:
    void derivedFunc() {
        // can access protectedVar and protectedFunc() from base class
        cout << "Derived function accessing protectedVar: " << protectedVar << endl;
        protectedFunc();
    }
};
int main() {
    MyClass obj;
    obj.publicVar = 10;
    obj.publicFunc();

    //obj.privateVar = 20; // error: private member cannot be accessed
    //obj.privateFunc();   // error: private member cannot be accessed
    //obj.protectedVar = 30; // error: protected member cannot be accessed
    //obj.protectedFunc();   // error: protected member cannot be accessed
    DerivedClass dObj;
    //dObj.privateVar = 40; // error: private member cannot be accessed
    //dObj.privateFunc();   // error: private member cannot be accessed
    dObj.publicVar = 50;
    dObj.publicFunc();
    //dObj.protectedVar = 60; // error: protected member cannot be accessed
    dObj.derivedFunc();      // okay: can access protected member from derived class
    return 0;
}

Explanation:

In this example, we have a class called MyClass with three member variables and three member functions. The member variables and functions are declared with different access specifiers. We also have a derived class called DerivedClass that inherits from MyClass. In the main function, we create an object of MyClass called obj and demonstrate that we can access the public member variables and functions, but not the private or protected ones.

Then, we create an object of DerivedClass called dObj and demonstrate that we can access the public member variables and functions, as well as the protected ones from within the derived class. However, we cannot access the private member variables or functions from the derived class. Overall, this example demonstrates how access specifiers control the level of accessibility of class members in C++.

Next TopicAdd Two Matrix in C++

← prev next →