dynamic_cast的继承和使用

Question

假设我有如下 3 个类（因为这是一个示例，它将无法编译！）：

class Base
{
public:
   Base(){}
   virtual ~Base(){}
   virtual void DoSomething() = 0;
   virtual void DoSomethingElse() = 0;
};

class Derived1
{
public:
   Derived1(){}
   virtual ~Derived1(){}
   virtual void DoSomething(){ ... }
   virtual void DoSomethingElse(){ ... }
   virtual void SpecialD1DoSomething{ ... }
};

class Derived2
{
public:
   Derived2(){}
   virtual ~Derived2(){}
   virtual void DoSomething(){ ... }
   virtual void DoSomethingElse(){ ... }
   virtual void SpecialD2DoSomething{ ... }
};

我想根据某些直到运行时才可用的设置来创建 Derived1 或 Derived2 的实例。

由于我在运行时之前无法确定派生类型，那么您认为以下做法是不好的做法吗？...

class X
{
public:
   ....

   void GetConfigurationValue()
   {
      ....
      // Get configuration setting, I need a "Derived1"
      b = new Derived1();

      // Now I want to call the special DoSomething for Derived1
      (dynamic_cast<Derived1*>(b))->SpecialD1DoSomething();      
   }
private:
   Base* b;
};

我通常读到 Dynamic_cast 的使用不好，但正如我所说，我不知道 在运行时之前要创建哪种类型。请帮忙！

Answer 1

为什么不通过将派生指针分配给基指针来延迟“丢弃”一些类型信息的时刻：

void GetConfigurationValue()
{
  // ...
  // Get configuration setting, I need a "Derived1"
  Derived1* d1 = new Derived1();
  b = d1;

  // Now I want to call the special DoSomething for Derived1
  d1->SpecialD1DoSomething();
}

Answer 2

虚函数的要点在于，一旦拥有正确类型的对象，您就可以调用正确的函数，而无需知道该对象是哪个派生类——您只需调用虚函数，它就会执行以下操作：正确的事情。

当您有一个派生类定义了基类中不存在的不同内容时，您只需要一个dynamic_cast，并且您需要/想要考虑到额外的东西。

例如：

struct Base { 
    virtual void do_something() {}
};

struct Derived : Base { 
    virtual void do_something() {} // override dosomething
    virtual void do_something_else() {} // add a new function
};

现在，如果您只想调用do_something()，则完全不需要dynamic_cast。例如，您可以拥有一个 Base * 集合，只需对每个集合调用 do_something() 即可，而不用关心该对象是否真的是一个 基础或派生。

当/如果您有一个Base *，并且您想要调用do_something_else()，那么您可以使用dynamic_cast 来确定对象本身是否真的是一个 Derived 以便您可以调用它。

Answer 3

使用dynamic_cast本身并不是一个坏习惯。不恰当地使用它是不好的做法，即在并不真正需要的地方使用它。

以这种方式使用它也是一个不好的做法：

(dynamic_cast<Derived1*>(b))->SpecialD1DoSomething();  

原因：dynamic_cast(b) 可能返回 NULL。

使用dynamic_cast时，您必须格外小心，因为不能保证b实际上是Derived1类型而不是Derived2类型：

void GenericFunction(Base* p)
{
    (dynamic_cast<Derived1*>(b))->SpecialD1DoSomething();
}

void InitiallyImplementedFunction()
{
   Derived1 d1;
   GenericFunction(&d1); // OK... But not for long. 
   // Especially, if implementation of GenericFunction is in another library
   // with not source code available to even see its implementation 
   // -- just headers
}    

void SomeOtherFunctionProbablyInAnotherUnitOfCompilation()
{
   Derived2 d2;
   GenericFunction(&d2); // oops!
}

您必须检查dynamic_cast是否确实成功。有两种方法可以做到这一点：在演员之前和之后检查。在转换之前，您可以通过 RTTI 检查您尝试转换的指针是否实际上是您期望的指针：

if (typeid(b) == typeid(Derived1*))
{
   // in this case it's safe to call the function right 
   // away without additional checks
   dynamic_cast<Derived1*>(b)->SpecialD1DoSomething();
}
else
{
  // do something else, like try to cast to Derived2 and then call
  // Derived2::SpecialD2DoSomething() in a similar fashion
}

事后检查实际上更简单一些：

Derived1* d1 = dynamic_cast<Derived1*>(b);
if (d1 != NULL)
{
   d1->SpecialD1DoSomething();
}

我还想说，尝试在同时保存打字是一种不好的做法用 C++ 编程。 C++ 中的许多功能似乎完全可以用更短的类型来表示（即让您感觉“NULL 永远不会在这里发生”），但事后调试起来却很痛苦。 ;)

Answer 4

您可能需要考虑避免使用dynamic_cast的其他一些事情

来自Effective C++（第三版） - Item 35 虚拟函数的替代方案 -

1. 通过非虚拟接口（NVI）的“模板方法模式”。使用公共方法“包装器”将虚拟函数设为私有/受保护 - 允许您在虚拟方法之前和之后强制执行一些其他工作流程。
2. 通过函数指针的“策略模式”。传入额外的方法作为函数指针。
3. 通过 tr1::function 的“策略模式”。与 2. 类似，但您可以为整个班级提供各种选项
4. “策略模式”经典。将策略与主类分开 - 将虚拟函数推入另一个层次结构。

Answer 5

有一个名为 工厂模式 的模式适合这种情况。这允许您根据某些输入参数返回正确类的实例。

享受！

Answer 6

有什么问题：

Base * b;
if( some_condition ) {
   b = new Derived1;
}
else {
   b = new Derived2;
}

if ( Derived2 * d2 = dynamic_cast <Derived2 *>( b ) ) {
    d2->SpecialD2DoSomething();
}

或者我错过了什么？

我可以建议，当你发布这样的问题时，你（和其他人）将你的类命名为 A、B、C 等，并将你的函数命名为 f1()、f2() 等。这让回答你问题的人变得更容易。

Answer 7

避免dynamic_cast的一种方法是使用一个虚拟蹦床函数“SpecialDoSomething”，其派生多态实现调用该特定派生类的“SpecialDxDoSomething()”，该函数可以是您想要的任何非基类名称。它甚至可以调用多个函数。