如何用C++父类数组存储不同子类对象并访问子类成员？

直接通过Item*访问子类专属成员blockChance或sharpness会编译失败，因为编译器仅识别指针的静态类型为Item，不知道实际指向子类对象。可以通过以下方式解决：

1. 安全运行时类型转换（dynamic_cast） #

适合不确定指针实际类型的场景，要求基类包含至少一个虚函数（通常添加虚析构函数，既支持RTTI，也能避免子类对象内存泄漏）。

先修改基类Item：

class Item
{
public:
    int x;
    // 虚析构函数，确保子类对象能正确释放，同时支持类型转换
    virtual ~Item() = default;
};

之后使用dynamic_cast转换并验证：

// 访问Shield的blockChance
Shield* shieldPtr = dynamic_cast<Shield*>(items[2]);
if (shieldPtr != nullptr) {
    int chance = shieldPtr->blockChance;
}

// 访问Sword的sharpness
Sword* swordPtr = dynamic_cast<Sword*>(items[0]);
if (swordPtr != nullptr) {
    int sharp = swordPtr->sharpness;
}

2. 静态类型转换（static_cast） #

如果你完全确定数组对应位置的指针类型（比如构造函数明确第0、1位是Sword，2、3位是Shield），可以用static_cast，但此方式不安全——若指针类型不匹配，会触发未定义行为：

// 已知items[2]是Shield，直接转换
int chance = static_cast<Shield*>(items[2])->blockChance;

// 已知items[0]是Sword，直接转换
int sharp = static_cast<Sword*>(items[0])->sharpness;

3. 多态设计（更推荐） #

如果需求是使用子类的专属功能，建议把功能封装为基类虚函数，子类重写实现，无需直接访问成员，更符合面向对象设计：

class Item
{
public:
    int x;
    virtual ~Item() = default;
    // 纯虚函数，使Item成为抽象类，强制子类实现
    virtual void use() = 0;
};

class Sword : public Item
{
public:
    int sharpness = 10;
    void use() override {
        // 剑的专属逻辑
        std::cout << "使用剑，锋利度：" << sharpness << std::endl;
    }
};

class Shield : public Item
{
public:
    int blockChance = 2;
    void use() override {
        // 盾的专属逻辑
        std::cout << "使用盾，格挡率：" << blockChance << std::endl;
    }
};

// 使用时直接调用虚函数，无需关心实际类型
player p;
p.items[0]->use(); // 执行Sword的use逻辑
p.items[2]->use(); // 执行Shield的use逻辑

额外注意：player类的items是私有成员，需提供访问接口才能外部使用；同时要在player的析构函数中遍历items，逐个delete对象，避免内存泄漏。

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