Type conversions in class hierarchies involve converting objects of one class to another class within the inheritance hierarchy. This concept is also known as object slicing and polymorphic behavior. Let's understand type conversions in class hierarchies with an example:=

#include <iostream>

// Base class
class Shape {
protected:
    int width;
    int height;

public:
    Shape(int w, int h) : width(w), height(h) {}

    virtual void displayArea() {
        std::cout << "Shape area: " << width * height << std::endl;
    }
};

// Derived class
class Rectangle : public Shape {
public:
    Rectangle(int w, int h) : Shape(w, h) {}

    void displayArea() override {
        std::cout << "Rectangle area: " << width * height << std::endl;
    }
};

// Another derived class
class Triangle : public Shape {
public:
    Triangle(int w, int h) : Shape(w, h) {}

    void displayArea() override {
        std::cout << "Triangle area: " << 0.5 * width * height << std::endl;
    }
};

int main() {
    Rectangle rectangle(5, 6);
    Triangle triangle(4, 3);

    Shape* shapePtr;

    shapePtr = &rectangle;  // Upcasting: Converting Rectangle object to Shape pointer
    shapePtr->displayArea();  // Output: Rectangle area: 30

    shapePtr = &triangle;  // Upcasting: Converting Triangle object to Shape pointer
    shapePtr->displayArea();  // Output: Triangle area: 6

    return 0;
}

In this example, we have a base class Shape, and two derived classes Rectangle and Triangle. Each class has a displayArea() function that calculates and displays the area of the respective shape.

In the main() function, we create objects of Rectangle and Triangle. We then create a pointer shapePtr of type Shape* which can point to objects of Shape and its derived classes.

Using upcasting, we assign the address of the Rectangle object to the shapePtr, which is a pointer to the base class Shape. This conversion is possible because a derived class object can be treated as its base class object. Similarly, we assign the address of the Triangle object to the shapePtr.

When we call the displayArea() function using the shapePtr, the appropriate version of the function is called based on the actual object being pointed to at runtime. This is known as polymorphic behavior, where the correct function is determined dynamically based on the object's type.

The output shows that even though we are using a pointer to the base class, the correct version of the displayArea() function is invoked based on the actual object being pointed to.

Type conversions in class hierarchies allow you to treat derived class objects as base class objects, enabling polymorphic behavior and flexibility in working with different objects within the same inheritance hierarchy.