如何简洁判断Base类实例是否为Derived1至Derived5中的某类实例？

你想要的那种直接把类型放进集合循环判断的写法在C里没法直接实现——因为C是静态类型语言，类型信息在编译期就确定了，不能像普通值一样存储在容器中，运行时也没法动态用变量类型去做dynamic_cast。不过有几种简洁的替代方案可以达到同样的效果：

方案一：可变参数模板函数（无需修改原有类） #

利用C++17的折叠表达式，可以快速实现一个通用的判断函数，一次性传入所有要检查的派生类类型：

#include <type_traits>

// 通用判断函数：检查Base指针是否能转换为任意传入的派生类类型
template<typename... DerivedTypes>
bool is_one_of(Base* b) {
    // 折叠表达式：逐个尝试dynamic_cast，只要有一个成功就返回true
    return (dynamic_cast<DerivedTypes*>(b) != nullptr || ...);
}

// 使用示例
if (is_one_of<Derived1, Derived2, Derived3, Derived4, Derived5>(b)) {
    // b属于目标派生类之一
    return true;
}
return false;

如果是C++17之前的版本，可以用递归模板实现同样的逻辑：

template<typename Derived>
bool is_one_of(Base* b) {
    return dynamic_cast<Derived*>(b) != nullptr;
}

template<typename Derived, typename... Rest>
bool is_one_of(Base* b) {
    return dynamic_cast<Derived*>(b) != nullptr || is_one_of<Rest...>(b);
}

这种方案的优点是不需要修改原有类的结构，直接复用现有类型即可，代码简洁易读。

方案二：添加类型标识虚函数（效率更高，适合可修改类的场景） #

如果允许修改Base类和派生类，可以添加一个返回类型标识的虚函数，用枚举值区分不同设备类型，这种方法比dynamic_cast效率更高（虚函数调用开销远小于dynamic_cast）：

// 定义设备类型枚举
enum class DeviceType {
    Base,
    Derived1, Derived2, Derived3, Derived4, Derived5,
    Derived6, Derived7, Derived8, Derived9
};

class Base {
public:
    virtual ~Base() = default;
    // 虚函数：返回当前对象的类型标识
    virtual DeviceType get_device_type() const {
        return DeviceType::Base;
    }
};

// 每个派生类重写该函数，返回对应的类型枚举
class Derived1 : public Base {
public:
    DeviceType get_device_type() const override {
        return DeviceType::Derived1;
    }
};

// Derived2~Derived9同理，各自返回对应的DeviceType值

// 判断逻辑：检查类型是否在目标集合中
#include <array>
#include <algorithm>

bool is_exception_device(Base* b) {
    if (!b) return false;
    // 定义例外设备类型集合
    constexpr std::array<DeviceType, 5> exception_types = {
        DeviceType::Derived1, DeviceType::Derived2, DeviceType::Derived3,
        DeviceType::Derived4, DeviceType::Derived5
    };
    auto type = b->get_device_type();
    return std::find(exception_types.begin(), exception_types.end(), type) != exception_types.end();
}

// 使用示例
if (is_exception_device(b)) {
    // 属于例外设备类型，不执行应急传感器逻辑
}

这种方案的优势是效率更高，而且后续新增设备类型时，只需要添加枚举值并重写get_device_type函数，判断逻辑无需修改，扩展性更好。

方案三：利用type_info和集合（不推荐，效率低） #

可以通过typeid获取对象的类型信息，将目标类型的type_info存入集合，然后对比：

#include <typeinfo>
#include <unordered_set>

// 初始化目标类型集合（注意：type_info的地址在同一程序中是唯一的）
const std::unordered_set<const std::type_info*> target_types = {
    &typeid(Derived1), &typeid(Derived2), &typeid(Derived3),
    &typeid(Derived4), &typeid(Derived5)
};

bool is_target_type(Base* b) {
    if (!b) return false;
    return target_types.count(&typeid(*b)) > 0;
}

不过这种方法有个明显的问题：typeid只能识别对象的实际类型，无法处理派生类到基类的转换（比如如果Derived1还有子类，typeid会返回子类的类型，而不会匹配Derived1），所以只适合精确匹配类型的场景，不如前两种方案灵活。

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