Question

我对C ++中的dynamic_cast关键字很困惑。

struct A {
    virtual void f() { }
};
struct B : public A { };
struct C { };

void f () {
    A a;
    B b;

    A* ap = &b;
    B* b1 = dynamic_cast<B*> (&a);  // NULL, because 'a' is not a 'B'
    B* b2 = dynamic_cast<B*> (ap);  // 'b'
    C* c = dynamic_cast<C*> (ap);   // NULL.

    A& ar = dynamic_cast<A&> (*ap); // Ok.
    B& br = dynamic_cast<B&> (*ap); // Ok.
    C& cr = dynamic_cast<C&> (*ap); // std::bad_cast
}

定义说：

dynamic_cast关键字从一个指针或引用转换基准键入另一个，执行运行时检查以确保强制转换

我们可以在C中编写等效的dynamic_cast C ++，以便更好地理解事物吗？

Answer 1

以下是static_cast<>和dynamic_cast<>的详细说明，因为它们与指针有关。这只是一个101级的破败，它没有涵盖所有错综复杂的内容。

的static_cast＆LT;输入*＆gt;（ptr）

这会将指针放在ptr中，并尝试将其安全地转换为Type*类型的指针。这个演员表是在编译时完成的。如果类型类型相关，它将仅执行强制转换。如果类型不相关，则会出现编译器错误。例如：

class B {};
class D : public B {};
class X {};

int main()
{
  D* d = new D;
  B* b = static_cast<B*>(d); // this works
  X* x = static_cast<X*>(d); // ERROR - Won't compile
  return 0;
}

的dynamic_cast＆LT;输入*＆gt;（ptr）

这再次尝试将指针放在ptr中，并将其安全地转换为Type*类型的指针。但是这个演员表是在运行时执行的，而不是编译时。因为这是一个运行时转换，所以特别是在与多态类组合时非常有用。实际上，在certian情况下，类必须是多态的，以使演员表合法。

强制转换可以进入以下两个方向之一：从基础到派生（B2D）或从派生到基础（D2B）。这很简单，可以看到D2B强制转换如何在运行时运行。 ptr来自Type，或者不是ptr。在D2B dynamic_cast＆lt;＆gt;的情况下，规则很简单。您可以尝试将任何内容转换为其他内容，如果Type实际上是从Type*派生的，那么您将从dynamic_cast返回#include <iostream> using namespace std; class Base { public: virtual void DoIt() = 0; // pure virtual virtual ~Base() {}; }; class Foo : public Base { public: virtual void DoIt() { cout << "Foo"; }; void FooIt() { cout << "Fooing It..."; } }; class Bar : public Base { public : virtual void DoIt() { cout << "Bar"; } void BarIt() { cout << "baring It..."; } }; Base* CreateRandom() { if( (rand()%2) == 0 ) return new Foo; else return new Bar; } int main() { for( int n = 0; n < 10; ++n ) { Base* base = CreateRandom(); base->DoIt(); Bar* bar = (Bar*)base; bar->BarIt(); } return 0; }指针。否则，您将获得一个NULL指针。

但是B2D演员阵容有点复杂。请考虑以下代码：

main()

CreateRandom()无法判断将返回哪种对象Bar* bar = (Bar*)base;，因此C风格的转换AreYouABar() const = 0;显然不是类型安全的。你怎么能解决这个问题？一种方法是将类似bool true的函数添加到基类，并从Bar返回false，从Foo返回dynamic_cast<>。但还有另一种方法：使用int main() { for( int n = 0; n < 10; ++n ) { Base* base = CreateRandom(); base->DoIt(); Bar* bar = dynamic_cast<Bar*>(base); Foo* foo = dynamic_cast<Foo*>(base); if( bar ) bar->BarIt(); if( foo ) foo->FooIt(); } return 0; }：

dynamic_cast<Type*>

强制转换在运行时执行，并通过查询对象来工作（无需担心现在如何），询问它是否是我们正在寻找的类型。如果是，dynamic_cast<>返回一个指针;否则返回NULL。

为了使这个基于派生的转换使用virtual工作，Base，Foo和Bar必须是标准所谓的多态类型。要成为多态类型，您的类必须至少具有一个dynamic_cast函数。如果您的类不是多态类型，则class Base {}; class Der : public Base {}; int main() { Base* base = new Der; Der* der = dynamic_cast<Der*>(base); // ERROR - Won't compile return 0; }的基于派生的使用将无法编译。例如：

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


int main()
{
    Base* base = new Der;
    Der* der = dynamic_cast<Der*>(base); // OK

    return 0;
}

向基础添加虚拟功能（例如虚拟dtor）将同时生成Base和Der多态类型：

{{1}}

Answer 2

除非您实现自己的手动RTTI（并绕过系统），否则无法直接在C ++用户级代码中实现dynamic_cast。 dynamic_cast与C ++实现的RTTI系统密切相关。

但是，为了帮助您更多地了解RTTI（以及dynamic_cast），您应该阅读<typeinfo>标头和typeid运算符。这将返回与您手头的对象相对应的类型信息，您可以从这些类型的信息对象中查询各种（有限的）事物。

Answer 3

不仅仅是C中的代码，我认为英语定义就足够了：

给定一个类Base，派生类Derived，dynamic_cast将Base指针转换为Derived指针，当且仅当指向的实际对象实际上是Derived对象时。

class Base { virtual ~Base() {} };
class Derived : public Base {};
class Derived2 : public Base {};
class ReDerived : public Derived {};

void test( Base & base )
{
   dynamic_cast<Derived&>(base);
}

int main() {
   Base b;
   Derived d;
   Derived2 d2;
   ReDerived rd;

   test( b );   // throw: b is not a Derived object
   test( d );   // ok
   test( d2 );  // throw: d2 is not a Derived object
   test( rd );  // ok: rd is a ReDerived, and thus a derived object
}

在示例中，对test的调用将不同的对象绑定到对Base的引用。在内部，引用是下载以类型安全的方式引用Derived：向下转换仅对引用对象确实是Derived的实例的情况成功。< / p>

Answer 4

以下与C ++的dynamic_cast在类型检查方面的结果并不相近，但它可能会帮助您更好地理解其目的：

struct Animal // Would be a base class in C++
{
    enum Type { Dog, Cat };
    Type type;
};

Animal * make_dog()
{
   Animal * dog = new Animal;
   dog->type = Animal::Dog;
   return dog;
}
Animal * make_cat()
{
   Animal * cat = new Animal;
   cat->type = Animal::Cat;
   return cat;
}

Animal * dyn_cast(AnimalType type, Animal * animal)
{
    if(animal->type == type)
        return animal;
    return 0;
}

void bark(Animal * dog)
{
    assert(dog->type == Animal::Dog);

    // make "dog" bark
}

int main()
{
    Animal * animal;
    if(rand() % 2)
        animal = make_dog();
    else
        animal = make_cat();

    // At this point we have no idea what kind of animal we have
    // so we use dyn_cast to see if it's a dog

    if(dyn_cast(Animal::Dog, animal))
    {
        bark(animal); // we are sure the call is safe
    }

    delete animal;
}

Answer 5

dynamic_cast使用RTTI执行类型检查。如果它失败了它会抛出异常（如果你给它一个引用）或者如果给它一个指针则为NULL。

Answer 6

不，不容易。编译器为每个类分配一个唯一的标识，该信息由每个对象实例引用，这是在运行时检查以确定动态转换是否合法的内容。您可以使用此信息和运算符创建标准基类以对该基类执行运行时检查，然后任何派生类都将通知基类在类层次结构中的位置，并且这些类的任何实例都可以通过运行时转换为你的运作。

修改

这是一个演示一种技术的实现。我没有声称编译器使用这样的东西，但我认为它演示了概念：

class SafeCastableBase { public: typedef long TypeID; static TypeID s_nextTypeID; static TypeID GetNextTypeID() { return s_nextTypeID++; } static TypeID GetTypeID() { return 0; } virtual bool CanCastTo(TypeID id) { if (GetTypeID() != id) { return false; } return true; } template <class Target> static Target *SafeCast(SafeCastableBase *pSource) { if (pSource->CanCastTo(Target::GetTypeID())) { return (Target*)pSource; } return NULL; } }; SafeCastableBase::TypeID SafeCastableBase::s_nextTypeID = 1; class TypeIDInitializer { public: TypeIDInitializer(SafeCastableBase::TypeID *pTypeID) { *pTypeID = SafeCastableBase::GetNextTypeID(); } }; class ChildCastable : public SafeCastableBase { public: static TypeID s_typeID; static TypeID GetTypeID() { return s_typeID; } virtual bool CanCastTo(TypeID id) { if (GetTypeID() != id) { return SafeCastableBase::CanCastTo(id); } return true; } }; SafeCastableBase::TypeID ChildCastable::s_typeID; TypeIDInitializer ChildCastableInitializer(&ChildCastable::s_typeID); class PeerChildCastable : public SafeCastableBase { public: static TypeID s_typeID; static TypeID GetTypeID() { return s_typeID; } virtual bool CanCastTo(TypeID id) { if (GetTypeID() != id) { return SafeCastableBase::CanCastTo(id); } return true; } }; SafeCastableBase::TypeID PeerChildCastable::s_typeID; TypeIDInitializer PeerChildCastableInitializer(&PeerChildCastable::s_typeID); int _tmain(int argc, _TCHAR* argv[]) { ChildCastable *pChild = new ChildCastable(); SafeCastableBase *pBase = new SafeCastableBase(); PeerChildCastable *pPeerChild = new PeerChildCastable(); ChildCastable *pSameChild = SafeCastableBase::SafeCast<ChildCastable>(pChild); SafeCastableBase *pBaseToChild = SafeCastableBase::SafeCast<SafeCastableBase>(pChild); ChildCastable *pNullDownCast = SafeCastableBase::SafeCast<ChildCastable>(pBase); SafeCastableBase *pBaseToPeerChild = SafeCastableBase::SafeCast<SafeCastableBase>(pPeerChild); ChildCastable *pNullCrossCast = SafeCastableBase::SafeCast<ChildCastable>(pPeerChild); return 0; }

Answer 7

C中没有类，因此用该语言编写dynamic_cast是不可能的。 C结构没有方法（因此，它们没有虚方法），因此没有任何“动态”。

Answer 8

dynamic_cast使用RTTI。它可以减慢您的应用程序，您可以使用访客设计模式的修改来实现向下转换而无需RTTI http://arturx64.github.io/programming-world/2016/02/06/lazy-visitor.html

Answer 9

首先，要描述用C术语进行的动态转换，我们必须用C表示类。具有虚拟功能的类使用指向虚拟功能的指针的“ VTABLE”。注释是C ++。随时重新格式化并修复编译错误...

// class A { public: int data; virtual int GetData(){return data;} };
typedef struct A { void**vtable; int data;} A;
int AGetData(A*this){ return this->data; }
void * Avtable[] = { (void*)AGetData };
A * newA() { A*res = malloc(sizeof(A)); res->vtable = Avtable; return res; }

// class B : public class A { public: int moredata; virtual int GetData(){return data+1;} }
typedef struct B { void**vtable; int data; int moredata; } B;
int BGetData(B*this){ return this->data + 1; }
void * Bvtable[] = { (void*)BGetData };
B * newB() { B*res = malloc(sizeof(B)); res->vtable = Bvtable; return res; }

// int temp = ptr->GetData();
int temp = ((int(*)())ptr->vtable[0])();

然后，动态投稿就像：

// A * ptr = new B();
A * ptr = (A*) newB();
// B * aB = dynamic_cast<B>(ptr);
B * aB = ( ptr->vtable == Bvtable ? (B*) aB : (B*) 0 );

Answer 10

static_cast< Type* >(ptr)

C ++中的static_cast可用于可在编译时验证所有类型转换的场景。

dynamic_cast< Type* >(ptr)

C ++中的dynamic_cast可用于执行类型安全向下转换。 dynamic_cast是运行时多态。 dynamic_cast运算符，它可以安全地从指针（或引用）转换为基类型到指向（或引用）到派生类型。

例如1：

#include <iostream>
using namespace std;

class A
{
public:
    virtual void f(){cout << "A::f()" << endl;}
};

class B : public A
{
public:
    void f(){cout << "B::f()" << endl;}
};

int main()
{
    A a;
    B b;
    a.f();        // A::f()
    b.f();        // B::f()

    A *pA = &a;   
    B *pB = &b;   
    pA->f();      // A::f()
    pB->f();      // B::f()

    pA = &b;
    // pB = &a;      // not allowed
    pB = dynamic_cast<B*>(&a); // allowed but it returns NULL

    return 0;
}

有关详细信息，请click

例如2：

#include <iostream>

using namespace std;

class A {
public:
    virtual void print()const {cout << " A\n";}
};

class B {
public:
    virtual void print()const {cout << " B\n";}
};

class C: public A, public B {
public:
    void print()const {cout << " C\n";}
};


int main()
{

    A* a = new A;
    B* b = new B;
    C* c = new C;

    a -> print(); b -> print(); c -> print();
    b = dynamic_cast< B*>(a);  //fails
    if (b)  
       b -> print();  
    else 
       cout << "no B\n";
    a = c;
    a -> print(); //C prints
    b = dynamic_cast< B*>(a);  //succeeds
    if (b)
       b -> print();  
    else 
       cout << "no B\n";
}

C ++中的dynamic_cast和static_cast

10 个答案:

的static_cast＆LT;输入*＆gt;（ptr）

的dynamic_cast＆LT;输入*＆gt;（ptr）