How can you use inheritance and polymorphism in C++?

Inheritance and polymorphism are two fundamental concepts in object-oriented programming that allow you to create relationships between classes and reuse code efficiently. In C++, you can use inheritance and polymorphism as follows:

Inheritance

1. Inheritance: Inheritance allows you to create a new class (derived class) that is a modified version of an existing class (base class). The derived class inherits all the members of the base class, including its variables and functions. To use inheritance in C++, you can define a derived class that inherits from a base class using the following syntax:

class BaseClass {
    // base class members
};

class DerivedClass : public BaseClass {
    // derived class members
};

In this example, the derived class DerivedClass inherits from the base class BaseClass using the public access specifier. This means that all the public members of the base class are accessible from the derived class. You can then add new members or modify the inherited members in the derived class as needed.[How can you use inheritance and polymorphism in C++?]

Example of polymorphism in C++

2. Polymorphism: Polymorphism allows you to write code that can work with objects of different classes generically. C++ supports two types of polymorphism: compile-time polymorphism (also called function overloading) and run-time polymorphism (also called virtual functions). To use run-time polymorphism in C++, you can define a virtual function in the base class and override it in the derived class as follows:

class BaseClass {
public:
    virtual void doSomething() {
        // base class implementation
    }
};

class DerivedClass : public BaseClass {
public:
    virtual void doSomething() override {//example of polymorphism in c++
        // derived class implementation
    }
};

In this example, the base class BaseClass defines a virtual function doSomething() that can be overridden by the derived class DerivedClass. The override keyword ensures that the function is actually being overridden in the derived class. You can then use a pointer or reference of the base class to call the virtual function on objects of both the base and derived classes, and the correct implementation will be called at run-time based on the actual type of the object. This allows you to write code that is more generic and reusable.[How can you use inheritance and polymorphism in C++?]

Quora question link