Access Specifiers and Inheritance in C++: A Comprehensive Guide

In object-oriented programming, access control is fundamental to encapsulation. C++ offers three access specifiers that define the accessibility of class members, ensuring code safety and modularity. This article starts from basic concepts and progressively explores the behavior of access specifiers in inheritance, helping developers master the relevant rules.

Overview of Access Specifiers

C++ access specifiers include public, protected, and private, which control member access from different contexts. Public members are accessible from outside the class via objects; protected members allow access within derived classes; private members are restricted to the class itself. For instance, defining a simple class:

class MyClass {
public:
    int a;
protected:
    int b;
private:
    int c;
};

int main() {
    MyClass obj;
    obj.a = 10;     // Allowed
    obj.b = 20;     // Not allowed, compiler error
    obj.c = 30;     // Not allowed, compiler error
}

This code demonstrates the basic rules: in the main function, only the public member a is accessible, while protected and private members are not.

Inheritance and Access Specifiers

Inheritance is a key feature for code reuse in C++, and when combined with access specifiers, it can be categorized into public, private, and protected inheritance. Each type alters the access levels of base class members in the derived class. A crucial rule is that private members of a base class are never accessible from derived classes, preserving encapsulation.

Public Inheritance

In public inheritance, public members of the base class remain public in the derived class, and protected members remain protected. This means the derived class can access public and protected members, but external code can only access public members of the derived class. Example:

class Base {
public:
    int a;
protected:
    int b;
private:
    int c;
};

class Derived : public Base {
    void doSomething() {
        a = 10;  // Allowed
        b = 20;  // Allowed
        c = 30;  // Not allowed, compiler error
    }
};

int main() {
    Derived obj;
    obj.a = 10;  // Allowed
    obj.b = 20;  // Not allowed, compiler error
    obj.c = 30;  // Not allowed, compiler error
}

Here, the Derived class can access a and b, but in main, only a is accessible.

Private Inheritance

Private inheritance converts public and protected members of the base class into private members of the derived class, restricting further inheritance. This is often used for implementation inheritance rather than interface inheritance. Example:

class Base {
public:
    int a;
protected:
    int b;
private:
    int c;
};

class Derived : private Base {
    void doSomething() {
        a = 10;  // Allowed
        b = 20;  // Allowed
        c = 30;  // Not allowed, compiler error
    }
};

class Derived2 : public Derived {
    void doSomethingMore() {
        a = 10;  // Not allowed, compiler error, a is private in Derived
        b = 20;  // Not allowed, compiler error, b is private in Derived
        c = 30;  // Not allowed, compiler error
    }
};

int main() {
    Derived obj;
    obj.a = 10;  // Not allowed, compiler error
    obj.b = 20;  // Not allowed, compiler error
    obj.c = 30;  // Not allowed, compiler error
}

In Derived2, a and b are inaccessible as they have become private members of Derived.

Protected Inheritance

Protected inheritance converts public and protected members of the base class into protected members of the derived class, allowing access further down the inheritance chain but limiting external access. Example:

class Base {
public:
    int a;
protected:
    int b;
private:
    int c;
};

class Derived : protected Base {
    void doSomething() {
        a = 10;  // Allowed
        b = 20;  // Allowed
        c = 30;  // Not allowed, compiler error
    }
};

class Derived2 : public Derived {
    void doSomethingMore() {
        a = 10;  // Allowed, a is protected in Derived
        b = 20;  // Allowed, b is protected in Derived
        c = 30;  // Not allowed, compiler error
    }
};

int main() {
    Derived obj;
    obj.a = 10;  // Not allowed, compiler error
    obj.b = 20;  // Not allowed, compiler error
    obj.c = 30;  // Not allowed, compiler error
}

This shows that Derived2 can access a and b since they remain protected after protected inheritance.

Key Considerations

Access specification is per-class, not per-object: for example, in a copy constructor, all members of the passed object can be accessed because it belongs to the same class. A derived class can only access members of its own base class, not members of other objects, as seen in the example where derived::f(Myclass& obj) attempting to access obj.x results in a compiler error. Additionally, friend functions or classes can bypass access restrictions to access private and protected members, but this should be used judiciously to enhance encapsulation rather than break it. For instance, friend can be used for operator overloading or testing classes.

In summary, a proper understanding of access specifiers and inheritance rules is essential for designing robust C++ programs. By appropriately using public, private, and protected inheritance, developers can control interface exposure and code reuse while maintaining encapsulation principles.