C++虚指针实现及效率

C++虚指针实现及效率

转载自： http://blog.chinaunix.net/space.php?uid=22257012&do=blog&id=2655107

1. 单继承虚函数例子

   class  Point  {
   public:
   virtual ~Point();
   
   virtual Point& mult( float ) = 0;
   //  other operations 
   
   float x() const { return _x; }
   virtual float y() const { return 0; }
   virtual float z() const { return 0; }
   // 
   
   protected:
   Point( float x = 0.0 );
   float _x;
   } ;
   class  Point2d :  public  Point  {
   public:
   Point2d( float x = 0.0, float y = 0.0 )
   : Point( x ), _y( y ) {}
   ~Point2d();
   
   // overridden base class virtual functions
   Point2d& mult( float );
   float y() const { return _y; }
   
   //  other operations 
   
   protected:
   float _y;
   } ;
   class  Point3d:  public  Point2d  {
   public:
   Point3d( float x = 0.0,
   float y = 0.0, float z = 0.0 )
   : Point2d( x, y ), _z( z ) {}
   ~Point3d();
   
   // overridden base class virtual functions
   Point3d& mult( float );
   float z() const { return _z; }
   
   //  other operations 
   protected:
   float _z;
   } ;

   2. Vtable和VPTR结构

   虚函数的实现是通过VTable和vptr。每一个带有虚函数的类都有一个VTable，在编译器生成，每一个带有虚函数的类实例都有一个vptr，该类实例vptr指向该类的VTable，在运行期生成。

   
   

   如图左部的类实例内存结构，编译器为之生成__vptr__Point的指针，指向该类的VTable。

   

   VTable的结构是一个函数指针数组，数组的每个元素是一个函数指针，指向该类虚函数的地址。因为基类Point的Point::mult()为纯虚函数，因此Point对应的mult函数指针指向一个pure_virtual_called()，抛出调用纯虚函数错误。

   
   

   如图VTable所示，Point类和其子类的析构函数均在VTable[1]，mult在VTable[2]，y在VTable[3]，z在VTable[4]。如果Point2d增加Point2d自己的虚函数，同时Point3d继承Point2d的虚函数，他们相同的虚函数接口同样对应于相同的VTable数组下标，如VTable[5]，此由编译器保证，因而编译器对于虚函数接口能将其转换为函数指针数组的下标。

   
   

   故，当调用

   ptr->z();

   编译器实际调用的是：

   ( *ptr->vptr[ 4 ] )( ptr );

   从而可以找到ptr实际指向的VTable中的虚函数调用地址。

   
   

   3. 虚函数系统开销

   为了实现虚函数，编译器产生的操作包括：

   1. 编译期，为每一个类增加一个VTable函数指针数组，并使其指向正确的虚函数实现。

   2. 运行期，在类的构造函数中，为每一个类实例增加一个vptr，指向该类的VTable。

   3. 编译器，将虚函数调用编译为函数指针的调用。

   4. 运行期，在虚函数调用时，通过指向VTable和调用函数的index，查找函数指针(查找效率为数组随机访问，常数时间)，调用虚函数。

   
   

   由分析得，虚函数开销主要在编译期的VTable函数指针数组的构造，而运行期的函数指针查找不是性能瓶颈。同时，一个带虚函数的基类无论有多少个孩子类，并不会降低虚函数性能，而如果类的继承层次太深，底层类实例的构造函数则需要为类继承层次的每一层父类初始化vptr，效率降低。

   
   

   4. 虚函数系统性能测试

      void
      cross_product(  const  pt3d  & pA,  const  pt3d  & pB )
      {
      pt3d pC;
      
      pC.x = pA.y * pB.z - pA.z * pB.y;
      pC.y = pA.z * pB.x - pA.x * pB.z;
      pC.z = pA.x * pB.y - pA.y * pB.x;
      }
      main()  {
      pt3d pA( 1.725, 0.875, 0.478 );
      pt3d pB( 0.315, 0.317, 0.838 );
      
      for ( int iters = 0; iters < 10000000; iters++ )
      cross_product( pA, pB );
      
      return 0;
      }
      
      

   Optimized Non-optimized

   Inline Member 0.08 4.70

   Nonstatic Member 4.43 6.13

   Virtual Member

   CC 4.76 6.90

   NCC 4.63 7.72

   CC和NCC是比较的两个编译器版本，对于上述计算函数的测试，虚函数的调用开销主要是3.4虚表查询，虚函数调用损失了4% 到11%的运行时间。相对于IO操作，可以忽略。

   
    

   5. 参考文献

   Inside the C++ Object Model, By Stanley B. Lippman