如何检查对象的类型是否是 C 中的特定子类？

Question

我正在考虑使用 typeid() 但我不知道如何询问该类型是否是另一个类的子类（顺便说一句，它是抽象的）

Answer 1

 

class Base
{
  public: virtual ~Base() {}
};

class D1: public Base {};

class D2: public Base {};

int main(int argc,char* argv[]);
{
  D1   d1;
  D2   d2;

  Base*  x = (argc > 2)?&d1:&d2;

  if (dynamic_cast<D2*>(x) == nullptr)
  {
    std::cout << "NOT A D2" << std::endl;
  }
  if (dynamic_cast<D1*>(x) == nullptr)
  {
    std::cout << "NOT A D1" << std::endl;
  }
}

Answer 2

你真的不应该。 如果您的程序需要知道对象是什么类，这通常表明存在设计缺陷。 看看是否可以使用虚函数获得您想要的行为。 此外，有关您正在尝试做什么的更多信息也会有所帮助。

我假设你遇到这样的情况：

class Base;
class A : public Base {...};
class B : public Base {...};

void foo(Base *p)
{
  if(/* p is A */) /* do X */
  else /* do Y */
}

如果这就是你所遇到的情况，那么尝试做这样的事情：

class Base
{
  virtual void bar() = 0;
};

class A : public Base
{
  void bar() {/* do X */}
};

class B : public Base
{
  void bar() {/* do Y */}
};

void foo(Base *p)
{
  p->bar();
}

编辑：由于关于这个答案的争论在这么多年后仍然在继续，我想我应该添加一些参考资料。 如果您有一个指向基类的指针或引用，并且您的代码需要知道该对象的派生类，那么它违反了 里氏替换原则。 鲍勃叔叔 将此称为“面向对象设计的诅咒"。

Answer 3

您可以使用dynamic_cast（至少对于多态类型）来做到这一点。

实际上，再想一想，您无法通过 dynamic_cast 判断它是否是特定类型 - 但您可以判断它是否是该类型或其任何子类。

template <class DstType, class SrcType>
bool IsType(const SrcType* src)
{
  return dynamic_cast<const DstType*>(src) != nullptr;
}

Answer 4

下面的代码演示了 3 种不同的实现方法：

• virtual function
• typeiddynamic_cast
• 上面

#include <iostream>
#include <typeinfo>
#include <typeindex>

enum class Type {Base, A, B};

class Base {
public:
    virtual ~Base() = default;
    virtual Type type() const {
        return Type::Base;
    }
};

class A : public Base {
    Type type() const override {
        return Type::A;
    }
};

class B : public Base {
    Type type() const override {
        return Type::B;
    }
};

int main()
{
    const char *typemsg;
    A a;
    B b;
    Base *base = &a;             // = &b;    !!!!!!!!!!!!!!!!!
    Base &bbb = *base;

    // below you can replace    base    with  &bbb    and get the same results

    // USING virtual function
    // ======================
    // classes need to be in your control
    switch(base->type()) {
    case Type::A:
        typemsg = "type A";
        break;
    case Type::B:
        typemsg = "type B";
        break;
    default:
        typemsg = "unknown";
    }
    std::cout << typemsg << std::endl;

    // USING typeid
    // ======================
    // needs RTTI. under gcc, avoid -fno-rtti
    std::type_index ti(typeid(*base));
    if (ti == std::type_index(typeid(A))) {
        typemsg = "type A";
    } else if (ti == std::type_index(typeid(B))) {
        typemsg = "type B";
    } else {
        typemsg = "unknown";
    }
    std::cout << typemsg << std::endl;

    // USING dynamic_cast
    // ======================
    // needs RTTI. under gcc, avoid -fno-rtti
    if (dynamic_cast</*const*/ A*>(base)) {
        typemsg = "type A";
    } else if (dynamic_cast</*const*/ B*>(base)) {
        typemsg = "type B";
    } else {
        typemsg = "unknown";
    }
    std::cout << typemsg << std::endl;
}

的程序打印出以下内容：

type A
type A
type A

Answer 5

dynamic_cast 可以确定类型是否在继承层次结构中的任何位置包含目标类型（是的，这是一个鲜为人知的功能，如果 B 继承自 A 和C，它可以将A*直接变成C*）。 typeid()可以确定对象的确切类型。 然而，这些都应该非常谨慎地使用。 正如已经提到的，您应该始终避免动态类型识别，因为它表明了设计缺陷。 （此外，如果您确定该对象是目标类型，则可以使用 static_cast 进行向下转型。Boost 提供了 polymorphic_downcast ，它将使用 < code>dynamic_cast 和 assert 在调试模式下，在发布模式下它只会使用 static_cast）。

Answer 6

我不知道我是否正确理解你的问题，所以让我用自己的话重述一下......

问题：给定类 B 和 D，确定是否 D 是 B 的子类（反之亦然？）

解决方案：使用一些模板魔法！ 好吧，说实话，您需要看看 LOKI，这是一个由著名的 C++ 作者 Andrei Alexandrescu 制作的出色的模板元编程库。

更具体地说，下载 LOKI 并包含标头 TypeManip .h ，然后在源代码中使用 SuperSubclass 类模板，如下所示：

if(SuperSubClass<B,D>::value)
{
...
}

根据文档，SuperSubClass::value 将是如果 B 是 D 的公共基类，或者如果 B 和 D 是同一类型的别名，则为 true。

即D 是B 的子类，或者D 与B 相同。

我希望这有帮助。

编辑：

请注意，与某些使用dynamic_cast的方法不同，SuperSubClass::value 的评估发生在编译时，因此有在运行时使用该系统不会受到任何惩罚。

Answer 7

我不同意你永远不应该在 C++ 中检查对象的类型。 如果你能避免它，我同意你应该这样做。 不过，说在任何情况下都不应该这样做就太过分了。 您可以使用多种语言来完成此操作，这可以让您的生活变得更加轻松。 例如，Howard Pinsley 在他关于 C# 的文章中向我们展示了如何操作。

我使用 Qt 框架做了很多工作。 一般来说，我会模仿他们做事的方式（至少在他们的框架中工作时）。 QObject 类是所有 Qt 对象的基类。 该类具有 isWidgetType() 和 isWindowType() 函数作为快速子类检查。 那么为什么不能检查您自己的派生类，它在本质上是可比较的呢？ 这是从其他一些帖子中衍生出来的 QObject：

class MyQObject : public QObject
{
public:
    MyQObject( QObject *parent = 0 ) : QObject( parent ){}
    ~MyQObject(){}

    static bool isThisType( const QObject *qObj )
    { return ( dynamic_cast<const MyQObject*>(qObj) != NULL ); }
};

然后，当您传递指向 QObject 的指针时，您可以通过调用静态成员函数来检查它是否指向您的派生类：

if( MyQObject::isThisType( qObjPtr ) ) qDebug() << "This is a MyQObject!";

Answer 8

#include <stdio.h>
#include <iostream.h>

class Base
{
  public: virtual ~Base() {}

  template<typename T>
  bool isA() {
    return (dynamic_cast<T*>(this) != NULL);
  }
};

class D1: public Base {};
class D2: public Base {};
class D22: public D2 {};

int main(int argc,char* argv[]);
{
  D1*   d1  = new D1();
  D2*   d2  = new D2();
  D22*  d22 = new D22();

  Base*  x = d22;

  if( x->isA<D22>() )
  {
    std::cout << "IS A D22" << std::endl;
  }
  if( x->isA<D2>() )
  {
    std::cout << "IS A D2" << std::endl;
  }
  if( x->isA<D1>() )
  {
    std::cout << "IS A D1" << std::endl;
  }
  if(x->isA<Base>() )
  {
    std::cout << "IS A Base" << std::endl;
  }
}

结果：

IS A D22
IS A D2
IS A Base

Answer 9

我正在考虑使用typeid()...

嗯，是的，可以通过比较来完成：typeid().name()。 如果我们采用已经描述的情况，其中：

class Base;
class A : public Base {...};
class B : public Base {...};

void foo(Base *p)
{
  if(/* p is A */) /* do X */
  else /* do Y */
}

foo(Base *p) 的可能实现将是：

#include <typeinfo>

void foo(Base *p)
{
    if(typeid(*p) == typeid(A))
    {
        // the pointer is pointing to the derived class A
    }  
    else if (typeid(*p).name() == typeid(B).name()) 
    {
        // the pointer is pointing to the derived class B
    }
}

Answer 10

我在这里看到了一些好的答案，也看到了一些愚蠢的答案。

“尝试查询对象的类型是一个设计缺陷”。 这意味着 Java instanceof 和 C# is 关键字是设计缺陷。 这些是不评价多态性的人的反应。 如果您有一个接口，则该接口是由另一个实现更多功能的接口派生的。 如果您需要这些额外的功能，您必须首先检查您是否有这样的接口。 甚至微软的 COM API 也使用了这种设计。

那么就如何推断一个对象是否是类的实例而言，已经给出了许多好的答案

• typeid
• 具有虚拟类型函数
• 动态强制转换

is_base_of 与多态性无关。

让每个虚函数定义自己的类型方法是不必要的，因为它是多余的。 每个虚拟类已经有一个指向其虚拟表的指针。

class Base
{
 void *p_virtual_table = BASE_VIRTUAL_TABLE;
}

class Derived : Base
{
 void *p_virtual_table = DERIVED_VIRTUAL_TABLE;
}

void *BASE_VIRTUAL_TABLE[n];
void *DERIVED_VIRTUAL_TABLE[n];

这里的要点是，虚拟表的地址是固定的，简单的比较将决定虚拟对象是否是虚拟类的实例。

由于 cpp 没有为我们提供访问虚拟表的标准方法，因此很难手动进行这些比较。 但是 cpp 抽象机在推导虚拟对象的确切实例时绝对没有问题。

Answer 11

除非使用 RTTI，否则只能在编译时使用模板执行此操作。

它允许您使用 typeid 函数，该函数将生成一个指向 type_info 结构的指针，该结构包含有关类型的信息。

阅读维基百科

Answer 12

您可以使用模板（或SFINAE（替换失败不是错误））来完成此操作。 示例：

#include <iostream>

class base
{
public:
    virtual ~base() = default;
};

template <
    class type,
    class = decltype(
        static_cast<base*>(static_cast<type*>(0))
    )
>
bool check(type)
{
    return true;
}

bool check(...)
{
    return false;
}

class child : public base
{
public:
    virtual ~child() = default;
};

class grandchild : public child {};

int main()
{
    std::cout << std::boolalpha;

    std::cout << "base:       " << check(base())       << '\n';
    std::cout << "child:      " << check(child())      << '\n';
    std::cout << "grandchild: " << check(grandchild()) << '\n';
    std::cout << "int:        " << check(int())        << '\n';

    std::cout << std::flush;
}

输出：

base:       true
child:      true
grandchild: true
int:        false

Answer 13

作为多个其他答案（包括我之前自己发布的答案！）的衍生，这里有一个可以提供帮助的宏：

#define isInstance( ptr, clazz ) (dynamic_cast<const clazz*>(ptr) != NULL)

Answer 14

我为指针和引用参数定义了 2 个宏。 如果您与一个版本一致，则可以注释掉另一个版本并将其重命名为INSTANCEOF。

#include <iostream>


#define INSTANCEOF_REF(derivedType, baseREF) (dynamic_cast<derivedType*>(&baseREF) != nullptr)
#define INSTANCEOF_PTR(derivedType, basePTR) (dynamic_cast<derivedType*>(basePTR) != nullptr)

class Base {
public:
    virtual ~Base() {}
};

class Derived : public Base {
};

int main() {
    Derived derivedObj; 
    Base* baseptr = &derivedObj;

    if (INSTANCEOF_REF(Derived, derivedObj)) {
        std::cout << "derivedObj is an instance of Derived." << std::endl;
    } else {
        std::cout << "derivedObj is NOT an instance of Derived." << std::endl;
    }  
    if (INSTANCEOF_REF(Base, derivedObj)) {
        std::cout << "derivedObj is an instance of Base." << std::endl;
    } else {
        std::cout << "derivedObj is NOT an instance of Base." << std::endl;
    }  

    if (INSTANCEOF_PTR(Derived, baseptr)) {
        std::cout << "baseptr is an instance of Derived." << std::endl;
    } else {
        std::cout << "baseptr is NOT an instance of Derived." << std::endl;
    } 
    
    if (INSTANCEOF_PTR(Base, baseptr)) {
        std::cout << "baseptr is an instance of Base." << std::endl;
    } else {
        std::cout << "baseptr is NOT an instance of Base." << std::endl;
    }

    return 0;
}

======

derivedObj is an instance of Derived.
derivedObj is an instance of Base.
baseptr is an instance of Derived.
baseptr is an instance of Base.

Answer 15

在 C# 中你可以简单地说：

if (myObj is Car) {

}