C++多重继承类层级下可存储全类对象的指针数组创建方法

• 你代码的核心错误违反了C++继承的指针转型规则：只有基类指针可以指向派生类对象（向上转型，安全合法），派生类指针不能指向基类对象（向下转型，属于非法行为，无法通过编译）
• 你定义的是MyChildClass**类型的数组，只能存储MyChildClass类型的指针，无法存储两个父类的对象指针，自然无法实现存储该层级所有类对象的需求。

方案1：添加公共顶层虚基类（推荐，类型安全） #

给两个父类添加共同的虚基类，数组用顶层基类的指针类型，即可安全存储所有层级的类对象指针，示例代码如下：

#include <iostream>
using namespace std;

// 新增公共顶层基类
class Base {
public:
    // 必须加虚析构函数，避免子类对象销毁时内存泄漏
    virtual ~Base() = default;
};

class MyClass : public virtual Base {
public:
    void myFunction() {
        cout << "Some content in parent class." << endl;
    }
};

class MyOtherClass : public virtual Base {
public:
    void myOtherFunction() {
        cout << "Some content in another class." << endl;
    }
};

class MyChildClass: public MyClass, public MyOtherClass {
};

int main() {
    // 数组类型用顶层基类Base的指针数组
    Base** v = new Base*[3];
    v[0] = new MyClass();
    v[1] = new MyOtherClass();
    v[2] = new MyChildClass();

    // 使用时用dynamic_cast做类型安全转换
    if (auto* cls = dynamic_cast<MyClass*>(v[0])) {
        cls->myFunction();
    }
    if (auto* otherCls = dynamic_cast<MyOtherClass*>(v[1])) {
        otherCls->myOtherFunction();
    }
    if (auto* childCls = dynamic_cast<MyChildClass*>(v[2])) {
        childCls->myFunction();
        childCls->myOtherFunction();
    }

    // 销毁对象，避免内存泄漏
    for (int i=0; i<3; i++) {
        delete v[i];
    }
    delete[] v;
    return 0;
}

方案2：使用void*数组（不推荐，类型不安全） #

如果不想修改原有类结构，可以用void**存储所有类型的指针，但使用时必须手动强转对应类型，没有类型安全检查，容易出运行时错误：

#include <iostream>
using namespace std;

class MyClass {
public:
    void myFunction() {
        cout << "Some content in parent class." ;
    }
};

class MyOtherClass {
public:
    void myOtherFunction() {
        cout << "Some content in another class." ;
    }
};

class MyChildClass: public MyClass, public MyOtherClass {
};

int main() {
    void** v = new void*[3];
    v[0] = new MyClass();
    v[1] = new MyOtherClass();
    v[2] = new MyChildClass();

    static_cast<MyClass*>(v[0])->myFunction();
    static_cast<MyOtherClass*>(v[1])->myOtherFunction();
    static_cast<MyChildClass*>(v[2])->myFunction();

    // 销毁时也要转对应类型避免内存泄漏
    delete static_cast<MyClass*>(v[0]);
    delete static_cast<MyOtherClass*>(v[1]);
    delete static_cast<MyChildClass*>(v[2]);
    delete[] v;
    return 0;
}

内容的提问来源于stack exchange，提问作者Gnar Bot