【问题标题】:Is there a faster way to detect object type at runtime than using dynamic_cast?有没有比使用 dynamic_cast 在运行时检测对象类型更快的方法?
【发布时间】:2009-06-16 08:57:22
【问题描述】:

我有一个类型层次结构 - GenericClass 和许多派生类,包括 InterestingDerivedClass,GenericClass 是多态的。有一个界面

interface ICallback {
    virtual void DoStuff( GenericClass* ) = 0;
};

我需要实现。然后我想检测传递给 ICallback::DoStuff() 的 GenericClass* 指针实际上是一个指向 InterestingDerivedClass 的指针的情况:

class CallbackImpl : public ICallback {
    void DoStuff( GenericClass* param ) {
        if( dynamic_cast<InterestingDerivedClass*>( param ) != 0 ) {
            return; //nothing to do here
        }
        //do generic stuff
    }
}

GenericClass 和派生类不在我的控制范围内,我只控制 CallbackImpl。

我对 dynamic_cast 语句进行了计时——它需要大约 1400 个周期,目前可以接受,但看起来不是很快。我试图在调试器中阅读 dynamic_cast 期间执行的反汇编,发现它需要很多指令。

由于我真的不需要指向派生类的指针,是否有一种仅使用 RTTI 在运行时检测对象类型的更快方法?也许一些特定于实现的方法只检查“是”关系但不检索指针?

【问题讨论】:

标签: c++ visual-c++ dynamic polymorphism


【解决方案1】:

我总是将dynamic_cast 的使用视为代码异味。您可以在所有情况下用多态行为替换它并提高代码质量。在你的例子中,我会做这样的事情:

class GenericClass
{
  virtual void DoStuff()
  {
    // do interesting stuff here
  }
};

class InterestingDerivedClass : public GenericClass
{
  void DoStuff()
  {
    // do nothing
  }
};

class CallbackImpl : public ICallback {
    void DoStuff( GenericClass* param ) {
        param->DoStuff();
    }
}

在您的情况下,您无法修改目标类,您正在按照 GenericClass 类型的声明所暗示的合同进行编程。因此,您可以做的任何事情都不会比dynamic_cast 更快,因为其他任何事情都需要修改客户端代码。

【讨论】:

    【解决方案2】:

    正如其他人所说,使用虚函数是一种很好的做法。使用它还有另一个原因,不适用于您的情况,因为您无法添加 VF,但我认为仍然值得一提 - 它可能比使用动态投射要快得多。在我使用 g++ 完成的一些(不是非常严格的)测试中,虚函数的性能比 dynamic_cast 高 4 倍。

    因为存在这样的差异,可能值得创建自己的继承层次结构来包装您无法控制的代码。您将使用 dynamic_cast(一次)创建包装器的实例来决定要创建什么派生类型,然后从那里使用虚函数。

    【讨论】:

      【解决方案3】:

      对我来说,这看起来像是一个非常骇人听闻的设计。 (正如其他人所提到的,必须使用dynamic_cast 通常表明您有设计问题。)。但如果大部分代码都超出了你的控制范围,我想你也无能为力了。

      但不,我知道的唯一通用解决方案是dynamic_Cast。 typeid 只匹配最衍生的类型,可能适用于您的情况。

      另一方面,dynamic_cast 如此昂贵的原因可能是它必须遍历整个类层次结构。如果你有一个很深的层次结构,那会变得很昂贵(换句话说,一般来说,没有很深的层次结构,但在 C++ 中尤其是)。

      (当然,在您第一次执行强制转换时,大多数类描述符查找可能会出现缓存未命中,这可能会扭曲您的基准测试并使其看起来比实际更昂贵)

      【讨论】:

        【解决方案4】:

        比较type_infos 会更快吗? (在参数param上调用typeid)

        【讨论】:

        • 是的,它更快,但它不测试继承,只测试完全匹配。
        • 可能会更快。但这不是一个好主意(如上面的原始代码)。
        • 我认为他在其他答案中已经被充分讲授了。他要求一种更快的方式来做他正在做的事情。 (公平的一点是,比较 type_infos 只会准确地捕获 InterestingDerivedClass,而不是从它派生的任何东西)。
        • 比较 type_info 需要 600 到 1200 个周期,这在形式上更快,但并不令人印象深刻。除此之外,我必须进行全面调查,以找出编译器希望比较成功的类型,并且它只适用于完全匹配。同时dynamic_cast“开箱即用”并准确检查“is a”关系。
        【解决方案5】:

        首先,不要过早优化。其次,如果您确实查询一个对象以获取其内部的具体实现,那么您的设计很可能有问题(想想双重分派)。

        至于最初的问题,将 GetRuntimeType() 函数引入 ICallback 会做得很好:请参阅 MFC 了解如何做到这一点。

        【讨论】:

          【解决方案6】:

          在您的具体用例中,答案是使用虚函数。

          但是,在某些情况下,您需要动态向下转换。有一些技术可以使此操作更快(或更快,具体取决于您的编译器实现dynamic_cast 的智能程度),特别是如果您将自己限制为单继承。主要思想是,如果你知道确切的类型,static_cast 会更快:

          f(A* pA)
          {
            if (isInstanceOfB(pA))
            {
              B* pB = static_cast<B*>(pA);
              // do B stuff...
            }
          }
          

          当然,问题在于如何快速实现 isInstanceOfB()。

          例如,参见boost::type_traits。

          【讨论】:

            【解决方案7】:

            标准 dynamic_cast 非常灵活,但通常很慢,因为它可以处理许多您可能不感兴趣的角落情况。如果你使用单继承,你可以用一个基于虚函数的简单实现来代替它。

            示例实现:

            // fast dynamic cast
            //! Fast dynamic cast declaration
            /*!
            Place USE_CASTING to class that should be recnognized by dynamic casting.
            Do not forget do use DEFINE_CASTING near class definition.
            *\note Function dyn_cast is fast and robust when used correctly.
            Each class that should be used as target for dyn_cast
            must use USE_CASTING and DEFINE_CASTING macros.\n
            Forgetting to do so may lead to incorrect program execution,
            because class may be sharing _classId with its parent and IsClassId
            will return true for both parent and derived class, making impossible'
            to distinguish between them.
            */
            #define USE_CASTING(baseType) \
              public: \
              static int _classId; \
              virtual size_t dyn_sizeof() const {return sizeof(*this);} \
              bool IsClassId( const int *t ) const \
              { \
                if( &_classId==t ) return true; \
                return baseType::IsClassId(t); \
              }
            
            //! Fast dynamic cast root declaration
            /*!
            Place USE_CASTING_ROOT to class that should act as
            root of dynamic casting hierarchy
            */
            
            #define USE_CASTING_ROOT \
              public: \
              static int _classId; \
              virtual size_t dyn_sizeof() const {return sizeof(*this);} \
              virtual bool IsClassId( const int *t ) const { return ( &_classId==t ); }
            
            //! Fast dynamic cast definition
            #define DEFINE_CASTING(Type) \
              int Type::_classId;
            
            template <class To,class From>
            To *dyn_cast( From *from )
            {
              if( !from ) return NULL;
              if( from->IsClassId(&To::_classId) )
              {
                assert(dynamic_cast<To *>(from));
                return static_cast<To *>(from);
              }
              return NULL;
            }
            

            也就是说,我完全同意其他人的观点,dynamic_cast 是可疑的,您通常能够以更简洁的方式实现相同的目标。也就是说,类似于 goto,在某些情况下它可能非常有用且更具可读性。

            另一个注意事项:如果您说有问题的类不在您的控制范围内,此解决方案对您没有帮助,因为它需要您修改类(不多,只需添加几行,但您需要修改他们)。如果真的是这样,你需要使用该语言提供的东西,即 dynamic_cast 和 typeinfo。

            【讨论】:

              【解决方案8】:
              猜你喜欢
              • 1970-01-01
              • 1970-01-01
              • 1970-01-01
              • 2016-06-09
              • 1970-01-01
              • 2013-12-23
              • 2014-05-02
              • 1970-01-01
              • 1970-01-01
              相关资源
              最近更新 更多