多个派生类的dynamic_cast

我有一个基类和n派生类。我想实例化一个派生类并将其发送到一个接收基类作为参数的函数。在函数内部，我通过使用dynamic_cast找到了它是哪种类型的派生类，但我不想使用几个if-else语句。相反，我想知道是否有一种方法可以找出它是哪个派生类，以便对其进行强制转换。 这里我留下我的代码作为示例。

class animal{
   public: 
          virtual ~animal() {}
          int eyes;

  };

class dog: public animal{
   public:
         int legs;
         int tail;
  };

class fish: public animal{
   public:
         int mostage;
  };

void functionTest(animal* a){
  if(dynamic_cast<fish*>(a) != NULL){
                             do_something();
                             }
  else if(dynamic_cast<dog*>(a) != NULL){
                              do_something();
                              }
 };

我想对此有一个更通用的方法。类似于dynamic_cast(a)。谢谢你！

如果您需要在几分钟内演示某些内容，那么对于快速草稿来说这样做是很棒的，但通常您会尝试避免以这种方式使用dynamic_cast - 如果在错误的地方使用它可能会导致极高的维护成本。有多种模式可用，例如简单的方法重载、Visitor http://en.wikipedia.org/wiki/Visitor_pattern模式，或虚拟的“GetType”函数（可以使用奇怪的重复模板模式 http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern，如果您喜欢图案）。

我将列出所有 3 种方法。第一个是迄今为止最简单、最容易使用的。另外两个的优点是它们都将做什么的决定转移到代码的不同部分，这可能是一个巨大的好处（或缺点）。

让我们假设这就是您想要做的：

void functionTest(animal* a)
{
    if(dynamic_cast<fish*>(a) != NULL)
        blub();
    else if(dynamic_cast<dog*>(a) != NULL)
        bark();
};

简单的虚函数方法：

class animal {
public: 
    virtual ~animal() {}
    virtual void do_something() = 0;
    int eyes;    
};

class dog : public animal {
public: 
    virtual void do_something() { bark(); } // use override in C++11
    int legs;
    int tail;
};

class fish: public animal {
public: 
    virtual void do_something() { blub(); } // use override in C++11
    int mostage;
};

void functionTest(animal* a)
{
   if (a) a->do_something();
};

访客方式：

class IVisitor {
public:
   ~IVisitor(){}
   virtual void visit(const fish&){}
   virtual void visit(const dog&){}
   virtual void visit(const animal&){}
};

class animal {
public: 
    virtual ~animal() {}
    virtual void accept(IVisitor& visitor) = 0; 
    int eyes;
};

class dog : public animal {
public: 
    virtual void accept(IVisitor& visitor) { visitor.visit(*this); }  // use override in C++11
    int legs;
    int tail;
};

class fish : public animal {
public: 
    virtual void accept(IVisitor& visitor) { visitor.visit(*this); }  // use override in C++11
    int mostage;
};

class MyVisitor : public IVisitor {
public:
   virtual void visit(const fish&) { blub(); } // use override in C++11
   virtual void visit(const dog&) { bark(); }  // use override in C++11   
};

void functionTest(animal* a)
{
    if (a)
    {
        MyVisitor v;
        a->accept(v);
    }
};

GetType 方法，具有CRTP http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern spice:

class animal {
public: 
    virtual ~animal() {}
    virtual const type_info& getType() const = 0; // careful. typeinfo is tricky of shared libs or dlls are involved
    int eyes;    
};

template <class T>
class BaseAnimal : public animal {
    // these are C++11 features. Alternatives exist to ensure T derives from BaseAnimal.
    static_assert(std::is_base_of<BaseAnimal,T>(,"Class not deriving from BaseAnimal");// C++11

    virtual const type_info& getType() const { return typeid(T); }    
};

class dog : public BaseAnimal<dog> {
public:
    int legs;
    int tail;
};

class fish : public BaseAnimal<fish> {
public:
    int mostage;
};

void functionTest(animal* a)
{
   if (!a)
      return;
   if (a->getType() == typeid(fish))
        blub(); 
   else if (a->getType() == typeid(dog))
        bark();
};

请注意，您应该将上述示例视为伪代码。为了获得最佳实践，您需要查找模式。此外，奇怪的重复模板模式也可以在第二种方法中使用，或者可以轻松地从第三种方法中删除它。这只是为了在这些情况下方便。