C++ Inheritance Types Described with Examples

One of the four foundations of object-oriented programming (OOPs) is inheritance. It's a feature that lets one class inherit the traits and attributes of another class. Because the derived class or child class can inherit the members of the base class, inheritance enables web developers to reuse your work.

To grasp inheritance clearly, think about a real-world example. A child gets certain traits from his or her parents, such the capacity to walk, talk, eat, and so forth. However, his parents are not the only ones who inherited these qualities. These characteristics are inherited by his parents from the animal class. These traits are also derived from the animal class by this class of mammals. It's the same way with inheritance.

Depending on the chosen visibility option, the data members of the base class are copied into the derived class during inheritance and are then accessible. Accessibility is always arranged from public to protected, or in descending order. This article will primarily cover five different types of inheritance in C++.

In the following order the inheritances are listed:

The following inheritance patterns exist:

Single, Multiple, Multilevel, Hierarchical, and Hybrid.

What does C++'s Inheritance Mean?

One class can inherit properties from its parent class by using the inheritance mechanism. A feature called inheritance allows one new class to be descended from the ones that already exist. The existing class is referred to as the parent or base class, and the newly derived class is called a derived class. The important aspect of object-oriented programming is inheritance. You can inherit the data functions of an existing class instead of defining new ones when you create a new one. All of the parent class's properties are inherited by the derived class, which also gains some additional functionality. For instance, you may use inheritance to provide a new class the members' names and descriptions

Parent and Child Classes: What Are They?

You must become familiar with the phrases "child class" and "parent class," which serve as the foundation for the entire notion of inheritance, in order to comprehend it fully.

Child class: A class is referred to as a "derived class" when it takes on the attributes of another class. The type of inheritance determines how many child classes can be inherited from a single parent class. Depending on the visibility option chosen when the child class is declared, its members of the parent class's data will be accessible to the child class.

Parent class: Also referred to as the base class, this is the class from which the properties of the child class are inherited. Hierarchical inheritance allows for the inheritance of several child classes from a single parent class, whereas multiple parent classes can inherit a single base class. The many forms of inheritance in C++ will determine this.

The C++ syntax provided below defines the parent and child classes for all forms of inheritance:

class parent_class

{

//class definition of the parent class

};

class child_class : visibility_mode parent_class

{

//class definition of the child class

};

Syntax explanation

parent_class: The parent class or base class name is indicated by the variable parent_class.

child_class: The child or derived class name is indicated by the variable child_class.

visibility_mode: The visible mode (private, protected, and public) explains how the data members of the child class are inherited from parents.

Inheritance's Significance in C++

Reusing existing material is always preferable than creating it from scratch because it saves time and improves dependability. Code from pre-existing classes can be reused in C++ using inheritance. C++ strongly endorses the reusability idea. When two classes in software share a domain and the properties of the class and its superclass must not change, inheritance is employed. C++ uses inheritance as a way to reuse code from pre-existing classes. C++ aggressively promotes reuse as a notion.

How to Use Inheritance in C++

The following syntax should be used to build a parent class that derives from the base class below:

class

<derived_class_name> : <access-specifier>

<base_class_name>

{

/ /body

}

The class keyword in this case creates a new class, the derived_class_name is the new class name, inherits properties from a base class, the access-specifier specifies the mode (public, private, or protected) in which the derived class was created, and the base class name is the name of the base class.

Public Inheritance: The protected members of the derived class maintain their public status, just as the public elements of the base class do.

Private Inheritance: confers protection to protected and public members of the base class in the derived class. The private members of the base class are not accessible to the derived class. The Public and protected members are shielded from the base class of the derived class using protected inheritance.

When to Use Inheritance and Why?

Because of its advantages, inheritance improves programming efficiency and is utilized in software. Below is a discussion of inheritance's most significant applications:

1. Reusability of Code: Reusing the code is one of the primary benefits of using inheritance. Think of the Tiger, Lion, and Panther groups of animals as distinct classes, for instance. You can construct member functions for these classes such as canine () (because all three animals have canine teeth for hunting), predator () (since they are all predators), and claws() (since all three animals have large, sharp claws). Currently, creating distinct functions for each of the three functions will result in data redundancy and raise the possibility of error because all three functions are the same for these classes. Therefore, inheritance can be used here instead of this. The tiger, lion, and panther classes can inherit these functions if you construct a base class called Carnivores and add these functions to it.

2. Transitive Nature: The transitive nature of inheritance makes it useful as well. As an illustration, consider a derived class mammal whose attributes are derived from the base class animal. The properties of the class "animal" will now be inherited by all of the child classes of "mammal," due to the transitive nature of inheritance. This is really helpful in debugging. Your base class's flaws can be fixed, and all inherited classes will be automatically debugged.

Modes of Visibility

The derived class's inheritance of the base class's features is determined by the visible mode. For all varieties of inheritance in C++, there are three different visibility modes:

Mode of Public Visibility

It keeps all of the base class members' accessibility when in the public visibility mode. The members that are designated as private, protected, and public in the base class also remain so in the derived class, in that order. Thus, the derived class and all other classes have access to the public members. Only the derived class and its members have access to the protected members. Nevertheless, the derived class cannot access the private members.

The derived class can be made to use the public visibility mode by using the following code snippet:

class base_class_1

{

// class definition

};

class derived_class: public base_class_1

{

// class definition

};

The public visibility mode is demonstrated by the code using each of the base class's three access specifiers, as follows:

class base_class

{

private:

//class member

int base_private;

protected:

//class member

int base_protected;

public:

//class member

int base_public;

};

class derived_class : public base_class

{

private:

int derived_private;

// int base_private;

protected:

int derived_protected;

// int base_protected;

public:

int derived_public;

// int base_public;

};

int main()

{

// Accessing members of base_class using object of the //derived_class:

derived_class obj;

obj.base_private; // Not accessible

obj.base_protected; // Not accessible

obj.base_public; // Accessible

}

The derived class in the example above inherits the public nature of the base class. The derived class has no access whatsoever to the private members. The protected members can only be accessed within the derived class; they cannot be accessed outside of it. Furthermore, the public members are reachable both within and beyond the classroom.

Private Visibility Mode

When using this mode, all base class members in the derived class are made private. This limits these members' access to resources outside of the derived class. The only derived class's member functions have access to them. Furthermore, in this instance, the private members are not inherited by the derived class.

The derived class can be made to use the private visibility mode by referring to the following code snippet.

class base_class_1

{

// class definition

};

class derived_class: private base_class_1

{

// class definition

};

The code demonstrates how the base class's three access specifiers—private visibility mode and—work together:

class base_class

{

private:

//class member

int base_private;

protected:

//class member

int base_protected;

public:

//class member

int base_public;

};

class derived_class : private base_class

{

private:

int derived_private;

// int base_private;

// int base_protected;

// int base_public

protected:

int derived_protected;

public:

int derived_public;

};

int main()

{

// Accessing members of base_class using object of the derived_class:

derived_class obj;

obj.base_private; // Not accessible

obj.base_protected; // Not accessible

obj.base_public; // Not Accessible

}

The derived class in the example above privately inherits the base class. Thus, in the derived class, every member of the base class has been made private. When an object of a derived class attempts to access these members outside of the class, an error is raised.

Protected Visibility Mode

All base class members become protected members of the derived class when in the protected visibility mode. Only the derived class and its member functions have access to these members at this time. These members are available to the inherited subclasses and are also inheritable. These members are not accessible from outside the class by objects of the derived classes, though.

The derived class can be made to use the protected visibility mode by using the following line of code:

class base_class_1

{

// class definition

};

class derived_class: protected base_class_1

{

// class definition

};

Using each of the base class's three access specifiers, the protected visibility mode is demonstrated by the code that follows:

class base_class

{

private:

//class member

int base_private;

protected:

//class member

int base_protected;

public:

//class member

int base_public;

};

class derived_class : protected base_class

{

private:

int derived_private;

// int base_private;

protected:

int derived_protected;

// int base_protected;

// int base_public

public:

int derived_public;

};

int main()

{

// Accessing members of base_class using object of the derived_class:

derived_class obj;

obj.base_private; // Not accessible

obj.base_protected; // Not accessible

obj.base_public; // Not Accessible

}

In protected mode, the derived class in the example above inherits from the base class. Now, all of the base class's members are exclusively available within the derived class—they are not available outside of it. Therefore, if the object obj of the derived class attempts to access these members outside of the class, it throws an error.

The control that the derived classes have on base class members in various visibility modes is shown in the following table.

BASE CLASS	DERIVED CLASS	DERIVED CLASS	DERIVED CLASS
PUBLIC	PROTECTED	PRIVATE
PUBLIC	Public	Protected	Private
PROTECTED	Protected	Protected	Private
PRIVATE	Remains Private / Not Inherited /	Remains Private / Not Inherited	Remains Private / Not Inherited

Different C++ Inheritance Types

Depending on how the derived class gets its characteristics from the base class, there are five different kinds of inheritance in C++. Here are these five categories:

Single Inheritance

Of all the inheritance kinds in C++, single inheritance is the most basic. In this inheritance scheme, the properties of a base class are passed down to a single class. The derived class can access all of the base class's data members in accordance with the visibility mode—private,

Syntax

class base_class_1

{

// class definition

};

class derived_class: visibility_mode base_class_1

{

// class definition

};

Description

One base class is inherited by one derived class. To specify the control of base class members within the derived class, the visibility_mode is specified when the derived class is declared.

As an illustration

The C++ sample that follows demonstrates single inheritance:

#include <iostream>

using namespace std;

// base class

class electronicDevice

{

public:

// constructor of the base class

electronicDevice()

{

cout << "I am an electronic device.\n\n";

}

};

// derived class

class Computer: public electronicDevice

{

public:

// constructor of the derived class

Computer()

{

cout << "I am a computer.\n\n";

}

};

int main()

{

// create object of the derived class

Computer obj; // constructor of base class and

// derived class will be called

return 0;

}

The base class electronic Device in public mode is inherited by the subclass Computer in the example above. Thus, the class computer has immediate access to all of the public and protected member functions and data members of the class electronic device. This is Single Inheritance since there is just one derived class that is inheriting from one base class.

Multiple Inheritances

Numerous inheritances are the type of inheritance where a class can have more than one base class, or it can inherit or derive properties from numerous classes. When inheritance occurs, access specifiers are specified individually for each base class. The data members of all the base classes are accessible to the derived or child class in accordance with the access specifiers, and the derived class can derive the combined features of all these classes.

Syntax

class base_class_1

{

// class definition

};

class base_class_2

{

// class definition

};

class derived_class: visibility_mode_1 base_class_1, visibility_mode_2 base_class_2

{

// class definition

};

Description

The traits of base classes base class_1 and base class_2 are passed down to the derived_class. When declaring a derived class, each base class has a visibility_mode given. Each base class may have a varied set of these modes.

As an illustration

The C++ sample that follows demonstrates multiple inheritance:

#include <iostream>

using namespace std;

// class_A

class electronicDevice

{

public:

// constructor of the base class 1

electronicDevice()

{

cout << "I am an electronic device.\n\n";

}

};

// class_B

class Computer

{

public:

// constructor base class 2

Computer()

{

cout << "I am a computer.\n\n";

}

};

// class_C inheriting class_A and class_B

class Linux_based : public electronicDevice, public Computer

{};

int main()

{

// create object of the derived class

Linux_based obj; // constructor of base class A,

// base class B and derived class

// will be called

return 0;

}

The basic classes electronic Device and Computer are distinct in the example above. Both of these classes are inherited by the derived class Linux_based, creating a Multiple Inheritance structure. In public mode, the derived class Linux_based has inherited both base classes' attributes. The constructors of both base classes are called when an object of the derived class is created.

Multi-level Inheritance

Multilevel inheritance is the type of inheritance where a class can inherit from another derived class. Assume A, B, and C are the three courses. Class B gives rise to a base class called A. Thus, A's derived class is B. The class that is descended from class B is now C. This creates class B, which is derived from class A but serves as the base class for class C. We refer to this situation as Multilevel Inheritance. Based on the designated visibility modes, the derived classes of each base class can access the data members of that class.

Syntax

class class_A

{

// class definition

};

class class_B: visibility_mode class_A

{

// class definition

};

class class_C: visibility_mode class_B

{

// class definition

};

Description

The subclass class_B inherits the class_A. The subclass class_C inherits the class_B. In every subsequent level, a subclass inherits a single class.

As an illustration

The C++ example that follows demonstrates multilevel inheritance:

#include <iostream>

using namespace std;

// class_A

class electronicDevice

{

public:

// constructor of the base class 1

electronicDevice()

{

cout << "I am an electronic device.\n\n";

}

};

// class_B inheriting class_A

class Computer: public electronicDevice

{

public:

// constructor base class 2

Computer()

{

cout << "I am a computer.\n\n";

}

};

// class_C inheriting class_B

class Linux_based : public Computer

{

public:

// constructor of the derived class

Linux_based()

{

cout << "I run on Linux.\n\n";;

}

};

int main()

{

// create object of the derived class

Linux_based obj; // constructor of base class 1,

// base class 2, derived class will be called

return 0;

}

In the example above, the subclass Computer inherits from the base class electronic Device, and the subclass Linux_based inherits from that subclass as well. It is called multilevel inheritance because only one class is inherited by one class at a time. The members of the classes electronic Device and Computer are directly accessible to the object of the derived class Linux_based.

Inheritance in Hierarchy

Hierarchical inheritance is the inheritance where a single base class inherits several derived classes. Because each class serves as a base class for one or more child classes, this inheritance has a structure like a tree. Each derived class specifies its own visible mode during inheritance, and it uses the appropriate data members.

Syntax

class class_A

{

// class definition

};

class class_B: visibility_mode class_A

{

// class definition

};

class class_C : visibility_mode class_A

{

// class definition

};

class class_D: visibility_mode class_B

{

// class definition

};

class class_E: visibility_mode class_C

{

// class definition

};

Description

The base class class_A's attributes are passed down to the subclasses class_B and class_C. Additionally, class_D and class_E, two additional subclasses, inherit these two subclasses.

As an illustration

The C++ example that follows demonstrates Hierarchical Inheritance.:

#include <iostream>

using namespace std;

// base class

class electronicDevice

{

public:

// constructor of the base class 1

electronicDevice()

{

cout << "I am an electronic device.\n\n";

}

};

// derived class inheriting base class

class Computer: public electronicDevice

{};

// derived class inheriting base class

class Linux_based : public electronicDevice

{};

int main()

{

// create object of the derived classes

Computer obj1; // constructor of base class will be called

Linux_based obj2; // constructor of base class will be called

return 0;

}

The basic class electronic Device in the example above is inherited by the two subclasses, Computer and Linux_based. Hierarchical Inheritance is represented by the class structure. Access to the public members of the base class electronic Device is available to both derived types. It calls the base class constructor for each object when it generates an instance of either of these two derived classes.

Inheritance Hybrid

As the name implies, hybrid inheritance is the blending of two or more inheritance models. For instance, a program's classes may be arranged so that they simultaneously display hierarchical and single inheritance. We refer to this type of arrangement as hybrid inheritance. Out of all the inheritance types in C++, this one is probably the most complicated. Access to the base class's data members will be granted based on the designated visibility mode.

Syntax

class class_A

{

// class definition

};

class class_B

{

// class definition

};

class class_C: visibility_mode class_A, visibility_mode class_B

{

// class definition

};

class class_D: visibility_mode class_C

{

// class definition

};

class class_E: visibility_mode class_C

{

// class definition

};

Description

Two base classes, class A and class B, are inherited by the derived class class C. This is how multiple inheritance is structured. Additionally, class C is inherited by two subclasses, class D and class E. This is how hierarchical inheritance is set up. Multiple inheritance types are included in the hybrid inheritance framework.

As an illustration

The C++ example that follows demonstrates hybrid inheritance:

#include <iostream>

using namespace std;

// base class 1

class electronicDevice

{

public:

// constructor of the base class 1

electronicDevice()

{

cout << "I am an electronic device.\n\n";

}

};

// base class 2

class Computer

{

public:

// constructor base class 2

Computer()

{

cout << "I am a computer.\n\n";

}

};

// derived class 1 inheriting base class 1 and base class 2

class Linux_based : public electronicDevice, public Computer

{};

// derived class 2 inheriting derived class 1

class Debian: public Linux_based

{};

int

main()

{

// create an object of the derived class

Debian obj; // constructor of base classes and

// derived class will be called

return 0;

}

The three classes Linux_based, Computer, and electronic Device make up the Multiple Inheritance structure in the example above. Additionally, the class Linux_base is inherited by the class Debian, creating the single inheritance structure. The constructors of all of its superclasses are invoked upon the creation of an object of the derived class Debian.

Diamond Issue

When a derived class inherits the characteristics of two superclasses that share a base class, this is known as the diamond dilemma in inheritance. The structure of a diamond problem is shown in the following diagram

Two copies of the Base class are created in a diamond problem when classes class_1 and class_2 inherit the same base class. Thus, uncertainty arises when an object of the derived_class accesses a member of the base class. It's unclear which copy of the base_class member has to be accessed, which leads to this confusing scenario. Additionally, the compiler generates an error in this scenario.

The unclear circumstance brought about by an inheritance with a diamond structure is demonstrated by the example that follows.

#include <iostream>

using namespace std;

// base class

class Base_class

{

public:

int x;

};

// class 1

class class_1 : public Base_class

{

public:

int y;

};

// class 2

class class_2 : public Base_class

{

public:

int z;

};

// derived class 3

class derived_class : public class_1, public class_2

{

public:

int sum;

};

int main()

{

// create an object of the derived_class

derived_class obj;

obj.x = 10; // ambiguous

obj.y = 20;

obj.z = 30;

obj.sum = obj.x + obj.y + obj.z;

cout << "The sum is: " << obj.sum << "\n\n";

return 0;

}

Due to the uncertainty created, an error is thrown in the case above. This occurs as a result of the base class's data member "x" being duplicated twice, once for class_1 and once for class_2. The copy of the variable "x" that should be utilized is not stated when the object "obj" of the derived_class attempts to access this member variable.

There are two approaches to steer clear of the unclear diamond difficulty scenario.

1. Applying the operator for scope resolution.
2. Applying the keyword virtual base class.

The operation of the scope resolution operator to eliminate uncertainty in the diamond issue is demonstrated in the example that follows.

#include <iostream>

using namespace std;

// base class

class Base_class

{

public:

int x;

};

// class 1

class class_1 : public Base_class

{

public:

int y;

};

// class 2

class class_2 : public Base_class

{

public:

int z;

};

// derived class 3

class derived_class : public class_1, public class_2

{

public:

int sum;

};

int main()

{

// create an object of the derived_class

derived_class obj;

obj.class_1::x = 10; // it is now unambiguous

obj.y = 20;

obj.z = 30;

obj.sum = obj.class_1::x + obj.y + obj.z;

cout << "The sum is: " << obj.sum << "\n\n";

return 0;

}

The scope resolution operator in the example above is used in the following statement to indicate which copy of "x" should be utilized.

object.class_1::x;

This is where the "x" version of class_1 is accessed. Since the ambiguous statement has been resolved to become unambiguous, no error is raised in this instance.

The scope resolution operator eliminates the ambiguity and yields accurate output, although the base class is still duplicated twice. The virtual keyword can help if you just need one copy of the base class. The virtual keyword restricts the creation of base class copies to one, while the derived class object can access base class members normally.

The virtual keyword's ability to eliminate uncertainty in the diamond problem is demonstrated in the example that follows.

#include <iostream>

using namespace std;

// base class

class Base_class

{

public:

int x;

};

// class 1

class class_1 : virtual public Base_class

{

public:

int y;

};

// class 2

class class_2 : virtual public Base_class

{

public:

int z;

};

// derived class 3

class derived_class : public class_1, public class_2

{

public:

int sum;

};

int main()

{

// create an object of the derived_class

derived_class obj;

obj.x = 10; // it is now unambiguous

obj.y = 20;

obj.z = 30;

obj.sum = obj.x + obj.y + obj.z;

cout << "The sum is: " << obj.sum << "\n\n";

return 0;

}

Two classes, class_1 and class_2, in the example above inherit the base class as virtual. There is only one copy of the base_class produced by any multiple inheritance involving these subclasses. As a result, the base_class is now only present in one copy in the derived_class, making the following statement clear and correct.

obj.x is 10;

How Can an Inheritable Private Member Be Created?

When inheritance occurs, derived classes do not inherit the private members of a base class. Therefore, the objects of the derived class cannot access these members of the base class. The derived classes can only access and inherit the public and protected members.

There are two methods to make the base class's private members inheritable:

1. Turning on public visibility instead of private visibility

The derived classes can inherit the private member's access modifier if it is made public. But there's an issue with this strategy. For that member, the data hiding feature is no longer available because it may now be accessed by all other program features.

2. Swapping the Private visibility mode for Protected

The private member's data-hiding property is preserved using this method. When a private member's access specifier is changed to read "protected," the derived class can inherit and use it. These members should be inherited as public if they must be inheritable beyond the class from which they are directly derived. If not, the inheritance hierarchy should stop at the directly derived class and they should be inherited as private.

The Benefits of C++ Inheritance

Code Reusability

By creating new classes based on preexisting ones, inheritance in C++ enables you to reuse code and save recreating the same function from scratch. Thus, creating new applications could end up saving you a ton of time and work.

Overriding

In C++, you can change the functions in a derived class to change a program's behavior without altering the original code. This is a great way to adapt preexisting code to your requirements.

Polymorphism

Polymorphism is the ability to create objects through inheritance that can take on different forms depending on the parent class from which they inherit. This enhances the code's adaptability and responsiveness to shifting requirements.

Organization

Inheritance in C++ facilitates the logical and hierarchical structure of your code. You can create a hierarchy of related classes by creating classes that inherit from other classes, which makes it easier for you to understand how your code functions.

In C++, Base Class and Derived Class

Fundamental Class: A base class is sometimes known as a parent class. An existing class that gets its properties from other classes is called a base class. The class that inherits the base class has all of its members, plus the ability to add additional attributes.

Derived Class: The derived class is also known as child class. This class is a subclass of an existing class. Functions from a base class are passed down to the derived class. With a few extra properties, the derived class can inherit the operations from the base class.

C++ Access Control

Data can be hidden via access control in object-oriented programming. You can differentiate between a class's protected parts, which are only available to derived classes, and its public interface using access controls. The non-private members of a base class are accessible to derived classes. Consequently, the base class should make private any base-class characteristics that aren't accessible to member functions of derived classes.

A public class that derives from a public base class has its protected members become protected members of the derived class and its base class's members become public members of the derived class. This is known as a publicly derived class. A derived class does not immediately provide access to the private members of the base class.

Privately Derived Class: A class created by private inheritance has its Public and protected elements changed into private members of the base class. This suggests that the methods of the base class are not inherited by the public interface of the derived Object.

Methods of Inheritance

A base class's features can be derived secretly, publicly, or under protection, depending on the visibility mode that the derived class's specification specifies. The characteristics of the base class can be inherited either publicly or privately, depending on the visibility mode. The access specifier for inheritable base-class elements in the derived class is managed by the visibility modes.

Public Visibility Mode: Under the Public Visibility mode, the basic class's attributes offer the least privacy. If the visibility mode is set to Public, the derived class can access the base class's protected and public members but not its private members.

Private Visibility: The mode that gives the base class properties the greatest privacy is called Private Visibility Mode. The Public and protected members of a base class can be covertly accessed by the derived class if the visibility mode is set to private.

Protected Visibility Mode: This mode sits in between the public and private visibility levels. When the visibility mode is protected, the derived class can safely access the protected and public members of the base class.

Last Words of Wisdom!

You began this thorough tutorial on C++ inheritance types with a quick overview of the language and the idea of parent and child classes. You now know why and when to employ different inheritance types in C++, as well as the various visibility modes that can be applied to classes and members.

You comprehended the use-cases, illustrations, and essential distinctions between the five various forms of inheritance. You have studied the diamond problem and its solution, which is a prevalent issue that results from numerous inheritances. You now saw how to allow inheritance for a private member.

While mastering inheritance in C++ is necessary for writing complex programs, broadening your programming expertise to include a variety of languages and frameworks can boost your chances of getting hired. If you want to move from C++ to web development and broaden your knowledge beyond C++, a java full stack developer course can help you work on both the client and server sides of an application, making you a versatile asset in the IT industry.

For more interesting articles click the link: Academic Learning Solutions

Search This Blog

Academic Learning Solutions