Detailed explanation of C++ function inheritance: How to avoid the "diamond inheritance" problem?

Diamond inheritance problem: The problem that occurs when a derived class inherits the same function from multiple base classes at the same time cannot determine which function version to call. Solution: Virtual inheritance: Create a virtual table pointer of the base class to ensure that function calls always point to the most specific base class implementation. Practical case: The Cylinder class inherits from Circle and Rectangle, uses virtual inheritance to avoid diamond inheritance, and ensures that the getArea() function implementation of the Cylinder class is always called.

Detailed explanation of C function inheritance: dealing with "diamond inheritance"

Introduction

Function inheritance is a powerful feature in C that allows derived classes to access and reuse functions of a base class. However, when multiple base classes have the same functions, a problem called "diamond inheritance" can arise. This article will discuss diamond inheritance and its solutions, and provide practical cases.

Diamond inheritance

Diamond inheritance occurs when a derived class inherits the same function from two or more base classes at the same time. This results in the inability to determine which function version was called in the derived class.

class Base1 {
public:
    void print() {
        std::cout << "Base1 print" << std::endl;
    }
};

class Base2 {
public:
    void print() {
        std::cout << "Base2 print" << std::endl;
    }
};

class Derived : public Base1, public Base2 {
public:
    void print() {
        // 调用哪个基类的 print() 函数？
    }
};

In the above example, the Derived class inherits from Base1 and Base2, both base classes have the same print() function. When Derived::print() is called, it cannot be determined whether Base1::print() or Base2::print() is called.

Avoid diamond inheritance

A common solution to avoid diamond inheritance is to use virtual inheritance. Virtual inheritance creates a vtable pointer to the base class instead of copying the base class object. This ensures that function calls to a derived class always point to the most specific base class implementation.

class Base1 {
public:
    virtual void print() {
        std::cout << "Base1 print" << std::endl;
    }
};

class Base2 {
public:
    virtual void print() {
        std::cout << "Base2 print" << std::endl;
    }
};

class Derived : public virtual Base1, public virtual Base2 {
public:
    void print() override {
        std::cout << "Derived print" << std::endl;
    }
};

In the above example, Base1 and Base2 use virtual inheritance. This ensures that Derived::print() will always call the implementation of the Derived class.

Practical case

Consider an example of calculating the area of ​​a graphic. We have a base class Shape that defines the getArea() function for calculating area. We also have two derived classes, Circle and Rectangle, which provide shape-specific area calculations.

class Shape {
public:
    virtual double getArea() = 0;
};

class Circle : public Shape {
public:
    Circle(double radius) : _radius(radius) {}
    double getArea() override {
        return 3.14 * _radius * _radius;
    }
private:
    double _radius;
};

class Rectangle : public Shape {
public:
    Rectangle(double width, double height) : _width(width), _height(height) {}
    double getArea() override {
        return _width * _height;
    }
private:
    double _width;
    double _height;
};

To implement the "sleeve" shape, we created a derived class Cylinder, which inherits from Circle and Rectangle. However, since both Circle and Rectangle have getArea() functions, Cylinder will face diamond inheritance issues.

class Cylinder : public Circle, public Rectangle {
public:
    Cylinder(double radius, double height) : Circle(radius), Rectangle(radius, height) {}
};

To avoid diamond inheritance, we use virtual inheritance:

class Cylinder : public virtual Circle, public virtual Rectangle {
public:
    Cylinder(double radius, double height) : Circle(radius), Rectangle(radius, height) {}
};

Now, the getArea() function of the Cylinder class is always called on its derived The implementation of the most specific class (i.e. Cylinder).

The above is the detailed content of Detailed explanation of C++ function inheritance: How to avoid the "diamond inheritance" problem?. For more information, please follow other related articles on the PHP Chinese website!