C++ Public, Protected and Private Inheritance
In object-oriented programming, new classes can be created by inheriting properties and methods from the existing classes. This mechanism is known as “inheritance” and involves using a base class to derive a new class. Inheritance is a process where new classes, called “derived classes” or “child classes,” are created from existing classes, known as “base classes” or “parent classes.” The derived class inherits all the properties of the base class without altering them and can also add new features unique to itself. These additional features in the derived class do not impact the base class, making the derived class a specialized version of the base class.
A derived class is declared using the following syntax:
The base specifications may include an access specifier, indicated by the keywords public, protected, or private — that can be used in inheritance to control the accessibility of the inherited members. These access specifiers determine how the derived class can access the members inherited from the base class. By default, the access level is private in a class, but public in a struct or union. In a class, access specifiers can be used in any order and as many times as needed.
Access specifiers
In a member-specification of a class, struct, or union, access specifiers are used to define the accessibility of subsequent members. In a base-specifier of a derived class declaration, access specifiers are used to define the accessibility of inherited members of the subsequent base class.
The syntax for access specifiers is as follows:
- public: member-declarations (public access)
- protected: member-declarations (protected access)
- private: member-declarations (private access)
- public base-class (public inheritance)
- protected base-class (protected inheritance)
- private base-class (private inheritance)
Public Inheritance:
In C++, public inheritance means that the public and protected members of the base class maintain their access level in the derived class, regardless of the access specifier used in the derived class. Public inheritance is the most common form of inheritance and represents an “is-a” relationship between the base and derived classes.
Protected Inheritance:
In C++, with protected inheritance, the public and protected members of the base class listed after the access specifier become protected members in the derived class. Protected inheritance is less common and has limited use cases. It provides a level of access between private and public inheritance.
Private Inheritance:
In C++, under private inheritance, the public and protected members of the base class listed after the access specifier are treated as private members in the derived class. This means that these members will have private access within the derived class, regardless of their original access levels in the base class.
Explanation:
The access level of every class member (static, non-static, function, type, etc.) is associated with a “member access”. When a member name is used in any part of a program, its access is verified. If the access does not adhere to the specified rules, the program will fail to compile.
Access specifiers in C++ allow the author of a class to determine which class members are accessible to the users of the class (the interface) and which members are meant for internal use within the class (the implementation).
Public inheritance
In public inheritance, when a class uses the public member access specifier to derive from a base class, all public members of the base class are accessible as public members of the derived class, and all protected members of the base class are accessible as protected members of the derived class. Private members of the base class are not directly accessible unless they are friended.
Public inheritance in C++ represents the subtyping relationship in object-oriented programming, where the derived class object is considered an instance of the base class object. References and pointers to a derived object should be usable by any code that expects references or pointers to any of its public bases, following the Liskov Substitution Principle (LSP). In terms of Design by Contract (DBC), a derived class should maintain the class invariants of its public bases and should not strengthen any preconditions or weaken any postconditions of a member function it overrides.
Protected inheritance
In protected inheritance, when a class uses the protected member access specifier to derive from a base class, all public and protected members of the base class become accessible as protected members of the derived class. Private members of the base class remain inaccessible unless they are declared as friends.
Protected inheritance is often used for “controlled polymorphism” where the relationship between the derived class and the base class is more restricted. Within the members of the derived class and all further-derived classes, the derived class is considered a type of the base class. This means that references and pointers to the derived class can be used in situations where references and pointers to the base class are expected.
Private inheritance
In private inheritance, when a class uses the private member access specifier to derive from a base class, all public and protected members of the base class become accessible as private members of the derived class. Private members of the base class remain inaccessible unless they are friended.
Private inheritance is commonly employed in policy-based design, where policies are typically empty classes. Using them as bases enables static polymorphism and takes advantage of empty-base optimization.
Additionally, private inheritance can be utilized to establish the composition relationship, where the base class subobject is treated as an implementation detail of the derived class object. This approach offers better encapsulation and is preferred unless the derived class specifically requires access to protected members (including constructors) of the base, needs to override a virtual member of the base, requires the base to be constructed before and destructed after another base subobject, needs to share a virtual base, or needs to control the construction of a virtual base. Using member objects to implement composition is not feasible in cases of multiple inheritance from a parameter pack or when the identities of the base classes are determined at compile time through template metaprogramming.
Similar to protected inheritance, private inheritance can also be employed for controlled polymorphism within the members of the derived class, where the derived class is considered a type of the base class, but this relationship does not extend to further-derived classes.
Member-Access Control
Member Access in Base Class
Access Control in Derived Classes
When it comes to accessing members of a base class in a derived class, two factors play a crucial role:
- Whether the derived class declares the base class using the public access specifier.
- The level of access to the member in the base class. These same factors also determine the accessibility of inherited members in the derived class.
Conclusion
In conclusion, the differences between private, protected, and public inheritance in C++ lie in the accessibility of the inherited members. Private inheritance makes the base class members private in the derived class, protected inheritance makes them protected, and public inheritance keeps them accessible as public. Understanding these differences is crucial when designing class hierarchies and managing the visibility of inherited members.
