如何在C++中检查向量对象类型并筛选特定子类实例展示

这个问题是C++多态场景下类型识别与特定类方法调用的典型需求，我来给你一步步拆解可行的解决方案：

核心思路是通过运行时类型识别（RTTI）或者自定义类型标识，区分Inpatient和Outpatient类型的对象，再安全转换类型并调用它们的专属方法。下面分两种常用方案详细说明：

方案一：使用dynamic_cast（推荐，依赖RTTI） #

dynamic_cast是C++标准中用于多态类型转换的工具，它能在运行时检查对象的实际类型：转换成功返回非空指针，失败则返回nullptr。

第一步：确保类层次支持多态 #

首先你的基类Patients必须包含至少一个虚函数（比如虚析构函数或者纯虚的toString），否则dynamic_cast无法工作：

#include <vector>
#include <iostream>
#include <string>
#include <memory> // 用于智能指针管理内存

// 基类：所有病人的父类
class Patients {
public:
    virtual ~Patients() = default; // 虚析构函数，确保派生类对象正确销毁
    virtual std::string toString() const = 0; // 纯虚方法，强制派生类实现
};

// 住院病人基类
class Inpatient : public Patients {
public:
    // Inpatient专属方法
    virtual std::string getInpatientInfo() const {
        return "住院病人：需每日查房，定期复查";
    }
};

// 门诊病人基类
class Outpatient : public Patients {
public:
    // Outpatient专属方法
    virtual std::string getOutpatientInfo() const {
        return "门诊病人：随诊观察，有不适及时复诊";
    }
};

// 具体派生类实现
class FemaleIn : public Inpatient {
public:
    std::string toString() const override {
        return "女性住院病人";
    }
};

class MaleIn : public Inpatient {
public:
    std::string toString() const override {
        return "男性住院病人";
    }
};

class FemaleOut : public Outpatient {
public:
    std::string toString() const override {
        return "女性门诊病人";
    }
};

class MaleOut : public Outpatient {
public:
    std::string toString() const override {
        return "男性门诊病人";
    }
};

第二步：实现Hospital类的display方法 #

注意存储病人时必须用指针/智能指针：如果直接存Patients对象会发生「对象切片」，丢失派生类的所有特性。这里推荐用std::unique_ptr自动管理内存，避免内存泄漏：

class Hospital {
private:
    std::vector<std::unique_ptr<Patients>> patients;
public:
    // 添加病人（转移智能指针所有权）
    void addPatient(std::unique_ptr<Patients> patient) {
        patients.push_back(std::move(patient));
    }

    // 展示所有住院病人
    void displayInpatients() const {
        std::cout << "=== 住院病人列表 ===" << std::endl;
        for (const auto& ptr : patients) {
            // 尝试转换为Inpatient类型
            if (Inpatient* inpatient = dynamic_cast<Inpatient*>(ptr.get())) {
                // 调用Inpatient的专属方法和toString
                std::cout << inpatient->toString() << " | " << inpatient->getInpatientInfo() << std::endl;
            }
        }
    }

    // 展示所有门诊病人
    void displayOutpatients() const {
        std::cout << "\n=== 门诊病人列表 ===" << std::endl;
        for (const auto& ptr : patients) {
            // 尝试转换为Outpatient类型
            if (Outpatient* outpatient = dynamic_cast<Outpatient*>(ptr.get())) {
                std::cout << outpatient->toString() << " | " << outpatient->getOutpatientInfo() << std::endl;
            }
        }
    }
};

测试代码 #

int main() {
    Hospital myHospital;

    // 添加各类病人
    myHospital.addPatient(std::make_unique<FemaleIn>());
    myHospital.addPatient(std::make_unique<MaleIn>());
    myHospital.addPatient(std::make_unique<FemaleOut>());
    myHospital.addPatient(std::make_unique<MaleOut>());

    // 展示结果
    myHospital.displayInpatients();
    myHospital.displayOutpatients();

    return 0;
}

输出结果：

=== 住院病人列表 ===
女性住院病人 | 住院病人：需每日查房，定期复查
男性住院病人 | 住院病人：需每日查房，定期复查

=== 门诊病人列表 ===
女性门诊病人 | 门诊病人：随诊观察，有不适及时复诊
男性门诊病人 | 门诊病人：随诊观察，有不适及时复诊

方案二：自定义类型标识（不依赖RTTI） #

如果你的项目关闭了RTTI（比如部分嵌入式环境），可以在基类中添加类型枚举，让派生类主动标识自己的类型：

修改Patients基类 #

class Patients {
public:
    // 定义病人类型枚举
    enum class PatientType { Inpatient, Outpatient };
    virtual ~Patients() = default;
    virtual std::string toString() const = 0;
    virtual PatientType getType() const = 0; // 返回当前对象的类型
};

// Inpatient类重写getType
class Inpatient : public Patients {
public:
    PatientType getType() const override {
        return PatientType::Inpatient;
    }
    // ... 其他方法不变
};

// Outpatient类重写getType
class Outpatient : public Patients {
public:
    PatientType getType() const override {
        return PatientType::Outpatient;
    }
    // ... 其他方法不变
};

修改Hospital的display方法 #

因为已经通过getType确认了类型，这里可以用static_cast（比dynamic_cast更高效）：

void displayInpatients() const {
    std::cout << "=== 住院病人列表 ===" << std::endl;
    for (const auto& ptr : patients) {
        if (ptr->getType() == Patients::PatientType::Inpatient) {
            Inpatient* inpatient = static_cast<Inpatient*>(ptr.get());
            std::cout << inpatient->toString() << " | " << inpatient->getInpatientInfo() << std::endl;
        }
    }
}

这种方法不需要RTTI，性能更好，但需要维护类型枚举，新增派生类时要记得更新相关逻辑。

• 绝对不要存储对象实例：如果vector里存的是Patients对象，会发生对象切片，派生类的所有额外信息都会被丢弃，无法进行类型识别。
• 优先用智能指针：std::unique_ptr或std::shared_ptr能自动管理内存，避免手动delete导致的泄漏。
• 虚函数是前提：不管用哪种方案，基类必须有虚函数才能实现多态，这是C++多态的基础。

内容的提问来源于stack exchange，提问作者성기덕