将子类实例赋值给基类后丢失子类引用的解决方案咨询

我尝试实现一个可动态处理不同类型对象的Runner类，要求该类与具体处理的对象类型无关，通过抽象类方法调用子类负责实现的功能。但将子类对象赋值给基类类型后，子类引用丢失，Runner无法识别子类实现。以下是相关代码、错误输出及期望输出，求该架构的最佳实现方案。

原代码 #

#include <vector>
#include <iostream>

class GenericItem{
    public:
        virtual void f() {};
};

class GenericList {
    public:
        virtual void f() {};
        std::vector<GenericItem*> list;
};

class Apple: public GenericItem{
    public:
        Apple(int color){
            this->color = color;
        }
        int color;
};

class House: public GenericItem{
    public:
        int size;
};

class AppleList: public GenericList{
    public:
        std::vector<Apple*> list;
};

class HouseList: public GenericList{
    public:
        std::vector<House*> list;
};

class GenericManager{
    public:
        virtual GenericList* getList() = 0;
};

class AppleManager: public GenericManager{
    public:
        AppleManager(){}
        AppleList* getList() {
            AppleList* list = new AppleList();
            list->list.push_back(new Apple(5));
            list->list.push_back(new Apple(7));
            list->list.push_back(new Apple(9));
            return list;
        }
};

class Runner{
    public:
        Runner(GenericManager* manager){
            this->manager = manager;
        }
        GenericItem* chooseItem(){
            GenericList* list = this->manager->getList();
            std::cout << "Vector size: " << list->list.size() << std::endl;
            return list->list.front();
        }
        GenericManager* manager;
};

int main (){
    Runner runner(new AppleManager());
    Apple* apple = dynamic_cast<Apple*>(runner.chooseItem());
    std::cout << "Apple color: " << apple->color << std::endl;
};

实际输出 #

Vector size: 0
Segmentation fault (core dumped)

期望输出 #

Vector size: 3
Apple color: 5

问题根源 #

AppleList中重新定义的std::vector<Apple*> list是子类的独立成员，并非覆盖基类GenericList的std::vector<GenericItem*> list。当AppleList指针被转为GenericList指针后，代码访问的是基类中未填充元素的空vector，导致输出size为0，后续调用front()触发空容器访问的段错误。

最佳实现方案 #

方案1：复用基类容器，保持多态一致性 #

重构子类，不再重新定义vector成员，直接使用基类的容器存储子类对象指针（子类指针可安全转换为基类指针），同时完善内存管理：

#include <vector>
#include <iostream>

class GenericItem{
public:
    virtual ~GenericItem() = default; // 增加虚析构，确保子类对象正确销毁
    virtual void f() {};
};

class GenericList {
public:
    virtual ~GenericList() {
        // 清理容器内的元素，避免内存泄漏
        for (auto item : list) {
            delete item;
        }
    }
    virtual void f() {};
    std::vector<GenericItem*> list;
};

class Apple: public GenericItem{
public:
    Apple(int color) : color(color) {} // 使用初始化列表更规范
    int color;
};

class House: public GenericItem{
public:
    int size;
};

// 子类无需重新定义list，直接继承基类的容器
class AppleList: public GenericList{};
class HouseList: public GenericList{};

class GenericManager{
public:
    virtual ~GenericManager() = default;
    virtual GenericList* getList() = 0;
};

class AppleManager: public GenericManager{
public:
    AppleList* getList() override { // 显式标注override，增强可读性
        AppleList* list = new AppleList();
        // Apple*自动转换为GenericItem*，存入基类容器
        list->list.push_back(new Apple(5));
        list->list.push_back(new Apple(7));
        list->list.push_back(new Apple(9));
        return list;
    }
};

class Runner{
public:
    Runner(GenericManager* manager) : manager(manager) {}
    ~Runner() {
        delete manager; // 清理manager对象
    }
    GenericItem* chooseItem(){
        GenericList* list = manager->getList();
        std::cout << "Vector size: " << list->list.size() << std::endl;
        // 注意：此处不要删除list，否则返回的item会变成野指针，需根据实际场景规划内存管理
        return list->list.front();
    }
private:
    GenericManager* manager;
};

int main (){
    Runner runner(new AppleManager());
    Apple* apple = dynamic_cast<Apple*>(runner.chooseItem());
    if (apple) { // 检查动态转换是否成功，避免空指针访问
        std::cout << "Apple color: " << apple->color << std::endl;
    }
    // 注意：Apple对象的内存由GenericList的析构函数负责清理
};

方案2：使用模板实现类型安全容器（可选） #

如果需要更强的类型安全，可引入模板类，但会牺牲部分多态灵活性：

#include <vector>
#include <iostream>

class GenericItem{
public:
    virtual ~GenericItem() = default;
    virtual void f() {};
};

template<typename T>
class GenericList {
public:
    virtual ~GenericList() {
        for (auto item : list) delete item;
    }
    std::vector<T*> list;
};

class Apple: public GenericItem{
public:
    Apple(int color) : color(color) {}
    int color;
};

class House: public GenericItem{
public:
    int size;
};

using AppleList = GenericList<Apple>;
using HouseList = GenericList<House>;

class GenericManager{
public:
    virtual ~GenericManager() = default;
    virtual GenericList<GenericItem*>* getList() = 0;
};

// 此方案下Manager需做类型转换，适合对类型安全要求高的场景
class AppleManager: public GenericManager{
public:
    GenericList<GenericItem*>* getList() override {
        auto* list = new AppleList();
        list->list.push_back(new Apple(5));
        list->list.push_back(new Apple(7));
        list->list.push_back(new Apple(9));
        return reinterpret_cast<GenericList<GenericItem*>*>(list);
    }
};

// Runner需配合模板使用，保持类型无关性
template<typename T>
class Runner{
public:
    Runner(GenericManager* manager) : manager(manager) {}
    ~Runner() { delete manager; }
    T* chooseItem(){
        auto* list = reinterpret_cast<GenericList<T*>*>(manager->getList());
        std::cout << "Vector size: " << list->list.size() << std::endl;
        return list->list.front();
    }
private:
    GenericManager* manager;
};

int main (){
    Runner<Apple> runner(new AppleManager());
    Apple* apple = runner.chooseItem();
    std::cout << "Apple color: " << apple->color << std::endl;
};

方案说明 #

• 方案1更贴合原架构的多态设计需求，代码改动小，保持了Runner与具体类型的解耦。
• 方案2适合需要严格类型检查的场景，但会增加代码复杂度，且需要注意指针转换的安全性。

内容的提问来源于stack exchange，提问作者gbriones.gdl