C++中如何运用虚方法修正派生类静态成员输出异常

问题背景 #

现有基类Pet、派生类Dog以及枚举PetType，代码定义如下：

enum class PetType {
    Cat,
    Dog,
    Q
};

class Pet {
protected:
    std::string name;
    size_t age;
    std::string breed;
    static PetType spice;

public:
    ...
    friend std::ostream& operator<< (std::ostream& out, const Pet& pet);
    friend std::ostream& operator<< (std::ostream& out, const PetType& pet);
};

class Dog : public Pet {
private:
    static PetType spice;
public:
    ...
};
PetType Dog::spice = PetType::Dog;
PetType Pet::spice = PetType::Q;

重载的operator<<实现如下：

std::ostream& operator<< (std::ostream& out, const Pet& pet) {
    out << "My name is " << pet.name << std::endl;
    out << "I am " << pet.spice << ", " << pet.breed << std::endl;
    out << "I am " << pet.age << " years old" << std::endl;
    return out;
}

当用vector存储不同Pet对象并遍历输出时，所有对象的PetType都显示为基类的Q，而非派生类的Dog。

问题原因 #

静态成员spice属于类本身，而非对象实例。编译阶段就会确定pet.spice访问的是基类Pet的静态成员，和对象的实际运行时类型无关，因此无法通过静态成员区分派生类类型。

解决方案：使用虚方法实现动态类型识别 #

步骤1：替换静态成员为虚函数 #

移除基类和派生类的静态spice成员，在基类中声明一个虚函数用于返回宠物类型，派生类重写该函数返回对应类型：

enum class PetType {
    Cat,
    Dog,
    Q
};

class Pet {
protected:
    std::string name;
    size_t age;
    std::string breed;

public:
    // 基类虚函数，返回默认类型Q
    virtual PetType getPetType() const {
        return PetType::Q;
    }
    // 补充构造函数初始化成员
    Pet(const std::string& n, size_t a, const std::string& b) 
        : name(n), age(a), breed(b) {}

    friend std::ostream& operator<< (std::ostream& out, const Pet& pet);
    friend std::ostream& operator<< (std::ostream& out, const PetType& pet);
};

class Dog : public Pet {
public:
    // 重写虚函数，返回Dog类型
    PetType getPetType() const override {
        return PetType::Dog;
    }
    // 派生类构造函数，调用基类构造
    Dog(const std::string& n, size_t a, const std::string& b) 
        : Pet(n, a, b) {}
};

步骤2：修改输出运算符实现 #

将原本访问静态成员的代码改为调用虚函数，利用C++的动态绑定特性，自动匹配对象实际类型的函数版本：

std::ostream& operator<< (std::ostream& out, const Pet& pet) {
    out << "My name is " << pet.name << std::endl;
    // 调用虚函数获取实际类型
    out << "I am " << pet.getPetType() << ", " << pet.breed << std::endl;
    out << "I am " << pet.age << " years old" << std::endl;
    return out;
}

// 补充PetType的输出重载实现（示例）
std::ostream& operator<< (std::ostream& out, const PetType& type) {
    switch(type) {
        case PetType::Cat: out << "a Cat"; break;
        case PetType::Dog: out << "a Dog"; break;
        case PetType::Q: out << "a Unknown Pet"; break;
        default: out << "Invalid Type";
    }
    return out;
}

步骤3：正确存储多态对象 #

注意：vector不能直接存储Pet对象（会触发对象切片，丢失派生类信息），需要存储基类指针或智能指针：

#include <vector>
#include <memory>

int main() {
    std::vector<std::unique_ptr<Pet>> pets;
    // 添加Dog对象
    pets.emplace_back(std::make_unique<Dog>("Buddy", 3, "Golden Retriever"));
    // 可添加其他派生类对象（如Cat）

    // 遍历输出
    for (const auto& pet : pets) {
        std::cout << *pet << std::endl;
    }
    return 0;
}

这样运行时，程序会根据对象的实际类型调用对应的getPetType函数，正确输出派生类的PetType。

内容的提问来源于stack exchange，提问作者игорь кочнов