这个在面试中被问到了。

如何编写自己的 dynamic_cast。我想，基于typeid的name函数。

现在如何实现自己的 typid？我对此一无所知。

最佳答案

你没有任何线索是有原因的，dynamic_cast和 static_cast不像const_cast或 reinterpret_cast ，它们实际上执行指针运算并且在某种程度上是类型安全的。

指针运算

为了说明这一点，请考虑以下设计:

struct Base1 { virtual ~Base1(); char a; };
struct Base2 { virtual ~Base2(); char b; };

struct Derived: Base1, Base2 {};

Derived 的实例应该看起来像这样(它基于 gcc，因为它实际上依赖于编译器...):

|      Cell 1       | Cell 2 |      Cell 3        | Cell 4 |
| vtable pointer    |    a   | vtable pointer     |    b   |
|         Base 1             |        Base 2               |
|                     Derived                              |

现在想想类型转换所需的工作:

• 类型转换自 Derived至 Base1不需要任何额外的工作，它们在同一个物理地址
• 类型转换自 Derived至 Base2需要将指针移动 2 个字节

因此，有必要了解对象的内存布局，以便能够在一个派生对象和它的基类之一之间进行转换。这只有编译器知道，无法通过任何 API 访问该信息，它不是标准化的或其他任何东西。

在代码中，这将翻译成:

Derived derived;
Base2* b2 = reinterpret_cast<Base2>(((char*)&derived) + 2);

当然，对于 static_cast .

现在，如果您能够使用 static_cast在执行dynamic_cast ，然后您可以利用编译器并让它为您处理指针算法……但您仍然没有脱离困境。

写 dynamic_cast 吗？

首先，我们需要澄清 dynamic_cast 的规范:

• dynamic_cast<Derived*>(&base);如果 base 则返回 null不是 Derived 的实例.
• dynamic_cast<Derived&>(base);抛出 std::bad_cast在这种情况下。
• dynamic_cast<void*>(base);返回最派生类的地址
• dynamic_cast遵守访问规范( public 、 protected 和 private 继承)

我不了解你，但我认为它会很丑陋。使用 typeid这里是不够的:

struct Base { virtual ~Base(); };
struct Intermediate: Base {};
struct Derived: Base {};

void func()
{
  Derived derived;
  Base& base = derived;
  Intermediate& inter = dynamic_cast<Intermediate&>(base); // arg
}

这里的问题是 typeid(base) == typeid(Derived) != typeid(Intermediate) ，因此您也不能依赖它。

另一个有趣的事情:

struct Base { virtual ~Base(); };
struct Derived: virtual Base {};

void func(Base& base)
{
  Derived& derived = static_cast<Derived&>(base); // Fails
}

static_cast当涉及虚拟继承时不起作用...因此我们遇到了指针算术计算的问题。

一个差不多的解决方案

class Object
{
public:
  Object(): mMostDerived(0) {}
  virtual ~Object() {}

  void* GetMostDerived() const { return mMostDerived; }

  template <class T>
  T* dynamiccast()
  {
    Object const& me = *this;
    return const_cast<T*>(me.dynamiccast());
  }

  template <class T>
  T const* dynamiccast() const
  {
    char const* name = typeid(T).name();
    derived_t::const_iterator it = mDeriveds.find(name);
    if (it == mDeriveds.end()) { return 0; }
    else { return reinterpret_cast<T const*>(it->second); }
  }

protected:
  template <class T>
  void add(T* t)
  {
    void* address = t;
    mDerived[typeid(t).name()] = address;
    if (mMostDerived == 0 || mMostDerived > address) { mMostDerived= address; }
  }

private:
  typedef std::map < char const*, void* > derived_t;
  void* mMostDerived;
  derived_t mDeriveds;
};

// Purposely no doing anything to help swapping...

template <class T>
T* dynamiccast(Object* o) { return o ? o->dynamiccast<T>() : 0; }

template <class T>
T const* dynamiccast(Object const* o) { return o ? o->dynamiccast<T>() : 0; }

template <class T>
T& dynamiccast(Object& o)
{
  if (T* t = o.dynamiccast<T>()) { return t; }
  else { throw std::bad_cast(); }
}

template <class T>
T const& dynamiccast(Object const& o)
{
  if (T const* t = o.dynamiccast<T>()) { return t; }
  else { throw std::bad_cast(); }
}

构造函数中需要一些小东西:

class Base: public Object
{
public:
  Base() { this->add(this); }
};

那么，让我们检查一下:

• 经典用法:好的
• virtual继承？它应该可以工作...但未经测试
• 尊重访问说明符... ARG :/

祝任何试图在编译器之外实现它的人好运，真的:x

关于c++ - 如何编写自己的 dynamic_cast，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3174104/