(转载)Comparing C++ and C (Inheritance and Virtual Functions)

Virtual Functions and Inheritance

This section presents the C++ code for a typical virtual function invocation scenario. This is then compared to the equivalent C code.

// A typical example of inheritance and virtual function use.

// We would be mapping this code to equivalent C.

// Prototype graphics library function to draw a circle
#include <iostream>
#include <ctime>
void glib_draw_circle (int x, int y, int radius);

// Shape base class declaration

class Shape

{

protected:

  int m_x;    // X coordinate

  int m_y;  // Y coordinate

 

public:

  // Pure virtual function for drawing

  virtual void Draw() = 0;  

 

  // A regular virtual function

  virtual void MoveTo(int newX, int newY);

 

  // Regular method, not overridable.

  void Erase();

 

  // Constructor for Shape

  Shape(int x, int y);

 

  // Virtual destructor for Shape

  virtual ~Shape();

};

 

// Circle class declaration

class Circle : public Shape

{

private:

   int m_radius;    // Radius of the circle 

 

public:

   // Override to draw a circle

   virtual void Draw();    

 

   // Constructor for Circle

   Circle(int x, int y, int radius);

 

   // Destructor for Circle

   virtual ~Circle();

};

 

// Shape constructor implementation

Shape::Shape(int x, int y)

{

   m_x = x;

   m_y = y;

}

 

// Shape destructor implementation

Shape::~Shape()

{

//...

}

void Shape::MoveTo(int newX, int newY)
{
    m_x=newX;
    m_y=newY;
    std::cout<<"MoveTo X:"<<m_x<<" Y:"<<m_y<<std::endl;
}

void Shape::Erase()
{
    m_x=0;
    m_y=0;
    std::cout<<"Erase"<<std::endl;
}
// Circle constructor implementation

Circle::Circle(int x, int y, int radius) : Shape (x, y)

{

   m_radius = radius;

}



// Circle destructor implementation

Circle::~Circle()

{

//...

}

 

// Circle override of the pure virtual Draw method.

void Circle::Draw()

{

   glib_draw_circle(m_x, m_y, m_radius);

}

 

void glib_draw_circle (int x, int y, int radius)
{
    std::cout <<"draw circle"<<" x:"<<x<<" y:"<<y<<" radius:"<<radius<<std::endl;
}
int main()

{
    clock_t start,finish;
    
    start = clock();

  // Define a circle with a center at (50,100) and a radius of 25

  Shape *pShape = new Circle(50, 100, 25);

 

  // Define a circle with a center at (5,5) and a radius of 2

  Circle aCircle(5,5, 2);

 

  // Various operations on a Circle via a Shape pointer

  pShape->Draw();

  pShape->MoveTo(100, 100);

  pShape->Erase();

  delete pShape;

 

  // Invoking the Draw method directly

  aCircle.Draw();
  finish = clock();
  
  std::cout <<"execute time:" <<( (double)(finish - start)*1000000/CLOCKS_PER_SEC )<<"us"<<std::endl;
  return 0;

}      

C code implementing the above C++ functionality is shown below. The code also includes compiler generated constructs like vtables. Virtual function access using vtables is also covered. (The presentation here has been simplified here to aid understanding).

/*

The following code maps the C++ code for the Shape and Circle classes

to C code.

*/
#include <stdio.h>

#include <stdlib.h>
#include <time.h>
#define TRUE 1

#define FALSE 0

typedef int BOOLEAN;

/*

Error handler used to stuff dummy VTable

entries. This is covered later.

*/

void pure_virtual_called_error_handler();
/* Prototype graphics library function to draw a circle */
void glib_draw_circle (int x, int y, int radius);
typedef void (*VirtualFunctionPointer)();
/*

VTable structure used by the compiler to keep

track of the virtual functions associated with a class.

There is one instance of a VTable for every class

containing virtual functions. All instances of

a given class point to the same VTable.

*/

typedef struct VTable
{  /*
   d and i fields are used when multiple inheritance and virtual
   base classes are involved. We will be ignoring them for this
   discussion.

*/

   int d;
  int i;
   /*

   A function pointer to the virtual function to be called is stored here.

*/
   VirtualFunctionPointer pFunc;
}VTable;



/*

The Shape class maps into the Shape structure in C. All

the member variables present in the class are included

as structure elements. Since Shape contains a virtual

function, a pointer to the VTable has also been added.

*/

typedef struct Shape
{

  int m_x;
  int m_y;
  /*

  The C++ compiler inserts an extra pointer to a vtable which

  will keep a function pointer to the virtual function that

  should be called.

*/
  VTable *pVTable;
}Shape;



/*

Function prototypes that correspond to the C++ methods

for the Shape class,

*/

Shape *Shape_Constructor(Shape *this_ptr, int x, int y);

void Shape_Destructor(Shape *this_ptr, BOOLEAN dynamic);

void Shape_MoveTo(Shape *this_ptr, int newX, int newY);

void Shape_Erase(Shape *this_ptr);



/*

The Shape vtable array contains entries for Draw and MoveTo

virtual functions. Notice that there is no entry for Erase,

as it is not virtual. Also, the first two fields for every

vtable entry are zero, these fields might have non zero

values with multiple inheritance, virtual base classes

A third entry has also been defined for the virtual destructor

*/
VTable VTableArrayForShape[] =
{   /*

    Vtable entry virtual function Draw.

    Since Draw is pure virtual, this entry

    should never be invoked, so call error handler

*/

    { 0, 0, (VirtualFunctionPointer) pure_virtual_called_error_handler},
    /*

    This vtable entry invokes the base class's
    MoveTo method.
*/
    { 0, 0, (VirtualFunctionPointer)Shape_MoveTo },
   /* Entry for the virtual destructor */
    { 0, 0, (VirtualFunctionPointer)Shape_Destructor }

};

/*

The struct Circle maps to the Circle class in the C++ code.

The layout of the structure is:

- Member variables inherited from the the base class Shape.

- Vtable pointer for the class.

- Member variables added by the inheriting class Circle.

*/

typedef struct Circle
{
   /* Fields inherited from Shape */
   int m_x;
   int m_y;
   VTable *pVTable;
   /* Fields added by Circle */
   int m_radius;
}Circle;

/*
Function prototypes for methods in the Circle class.
*/
Circle *Circle_Constructor(Circle *this_ptr, int x, int y, int radius);
void Circle_Draw(Circle *this_ptr);
void Circle_Destructor(Circle *this_ptr, BOOLEAN dynamic);
/* Vtable array for Circle */
VTable VTableArrayForCircle[] =
{   /*
   Vtable entry virtual function Draw.
    Circle_Draw method will be invoked when Shape's
    Draw method is invoked
*/
    { 0, 0, (VirtualFunctionPointer) Circle_Draw },
    /*

    This vtable entry invokes the base class's

    MoveTo method.

*/
    { 0, 0, (VirtualFunctionPointer) Shape_MoveTo },

    /* Entry for the virtual destructor */

    { 0, 0, (VirtualFunctionPointer) Circle_Destructor }
};

Shape *Shape_Constructor(Shape *this_ptr, int x, int y)
{
  /* Check if memory has been allocated for struct Shape. */
  if (this_ptr == NULL)
  {
    /* Allocate memory of size Shape. */
    this_ptr = (Shape *) malloc(sizeof(Shape));
  }

  /*
  Once the memory has been allocated for Shape,
  initialise members of Shape.
*/
  if (this_ptr)
  {    /* Initialize the VTable pointer to point to shape */
    this_ptr->pVTable = VTableArrayForShape;
    this_ptr->m_x = x;
    this_ptr->m_y = y;
  }
  return this_ptr;
}



void Shape_Destructor(Shape *this_ptr, BOOLEAN dynamic)
{  /*

  Restore the VTable to that for Shape. This is

  required so that the destructor does not invoke

  a virtual function defined by a inheriting class.

  (The base class destructor is invoked after inheriting

  class actions have been completed. Thus it is not

  safe to invoke the ineriting class methods from the

  base class destructor)

*/
  this_ptr->pVTable = VTableArrayForShape;
  
  /*

  If the memory was dynamically allocated

  for Shape, explicitly free it.

*/
  if (dynamic)
  {
    free(this_ptr);
  }
}

void Shape_MoveTo(Shape *this_ptr, int newX, int newY)
{
    this_ptr->m_x = newX;
    this_ptr->m_y = newY;
    printf("MoveTo X:%d Y:%d \n",newX,newY);
}

void Shape_Erase(Shape *this_ptr)
{
    this_ptr->m_x = 0;
    this_ptr->m_y = 0;
    printf("Erase\n");
}
    
Circle *Circle_Constructor(Circle *this_ptr, int x, int y, int radius)

{

  /* Check if memory has been allocated for struct Circle. */

  if (this_ptr == NULL)

  {
    /* Allocate memory of size Circle. */
    this_ptr = (Circle *) malloc(sizeof(Circle));
  }



  /*

  Once the memory has been allocated for Circle,

  initialise members of Circle.

*/

  if (this_ptr)
  {      /* Invoking the base class constructor */
      Shape_Constructor((Shape *)this_ptr, x, y);
      this_ptr->pVTable = VTableArrayForCircle;
      this_ptr->m_radius = radius;
  }
  return this_ptr;
}



void Circle_Destructor(Circle *this_ptr, BOOLEAN dynamic)
{
  /* Restore the VTable to that for Circle */
  this_ptr->pVTable = VTableArrayForCircle;
  /*

  Invoke the base class destructor after ineriting class

  destructor actions have been completed. Also note that

  that the dynamic flag is set to false so that the shape

  destructor does not free any memory.

*/

  Shape_Destructor((Shape *) this_ptr, FALSE);
  /*
  If the memory was dynamically allocated
  for Circle, explicitly free it.

*/
  if (dynamic)
  {
    free(this_ptr);
  }
}



void Circle_Draw(Circle *this_ptr)
{
   glib_draw_circle(this_ptr->m_x, this_ptr->m_y, this_ptr->m_radius);
}

void pure_virtual_called_error_handler()
{
}
void glib_draw_circle (int x, int y, int radius)
{
    printf("draw circle x:%d y:%d radius:%d \n",x,y,radius);
}

void main()
{
    clock_t start,finish;
  /*

  Dynamically allocate memory by passing NULL in this arguement.

  Also initialse members of struct pointed to by pShape.

*/

  Shape *pShape = NULL;

  /* Define a local variable aCircle of type struct Circle. */

  Circle aCircle;

  start=clock();
 
  pShape = (Shape *) Circle_Constructor(NULL, 50, 100, 25);
  /* Initialise members of struct variable aCircle. */

  Circle_Constructor(&aCircle, 5, 5, 2);
  /*

  Virtual function Draw is called for the shape pointer. The compiler

  has allocated 0 offset array entry to the Draw virtual function.

  This code corresponds to "pShape->Draw();"

*/
  (pShape->pVTable[0].pFunc)(pShape);

  /*

  Virtual function MoveTo is called for the shape pointer. The compiler

  has allocared 1 offset array entry to the MoveTo virtual function.

  This code corresponds to "pShape->MoveTo(100, 100);"

*/

  (pShape->pVTable[1].pFunc)(pShape, 100, 100);

  /*

  The following code represents the Erase method. This method is

  not virtual and it is only defined in the base class. Thus

  the Shape_Erase C function is called.

*/

  Shape_Erase(pShape);

  /* Delete memory pointed to by pShape (explicit delete in original code).

  Since the destructor is declared virtual, the compiler has allocated

  2 offset entry to the virtual destructor

  This code corresponds to "delete pShape;".

*/

  (pShape->pVTable[2].pFunc)(pShape, TRUE);

  /*

  The following code corresponds to aCircle.Draw().

  Here the compiler can invoke the method directly instead of

  going through the vtable, since the type of aCircle is fully

  known. (This is very much compiler dependent. Dumb compilers will

  still invoke the method through the vtable).

*/

  Circle_Draw(&aCircle);


  /*

  Since memory was allocated from the stack for local struct

  variable aCircle, it will be deallocated when aCircle goes out of scope.

  The destructor will also be invoked. Notice that dynamic flag is set to

  false so that the destructor does not try to free memory. Again, the

  compiler does not need to go through the vtable to invoke the destructor.

*/

  Circle_Destructor(&aCircle, FALSE);
  
  finish=clock();
  printf("execute time:%f us\n",(double)(finish - start)*1000000/CLOCKS_PER_SEC);
}

1 执行结果：

C++代码

draw circle x:50 y:100 radius:25
MoveTo X:100 Y:100
Erase
draw circle x:5 y:5 radius:2
execute time:22000us

C代码

draw circle x:50 y:100 radius:25
MoveTo X:100 Y:100
Erase
draw circle x:5 y:5 radius:2
execute time:7000.000000 us

每次的执行时间会有差异，多次执行的结果C的时间是C++的1/3 ~1/2，因为具体的函数实现中很简单，主要是C++的构造、析构函数的时间比较多(?下面2的结果)。

2 不执行具体的函数，只构造和销毁变量

void call2() //不执行函数，只构造和销毁变量
{
  Shape *pShape = new Circle(50, 100, 25);
  Circle aCircle(5,5, 2);
  delete pShape;
}

int main()
{
    clock_t start,finish;
    int i=100000;
    start = clock();
    while(i--)
    {
  call2();
  }
  finish = clock();
  
  std::cout <<"execute time:" <<( (double)(finish - start)*1000000/CLOCKS_PER_SEC )<<"us"<<std::endl;
  return 0;

}  

void call2() //不执行函数，只构造和销毁变量
{
    Shape *pShape = (Shape *) Circle_Constructor(NULL, 50, 100, 25);
    Circle aCircle;
    Circle_Constructor(&aCircle, 5, 5, 2);
    (pShape->pVTable[2].pFunc)(pShape, TRUE);
    Circle_Destructor(&aCircle, FALSE);
}
void main()
{
    int i=100000;
    clock_t start,finish;
  start=clock();
  while(i--)
  {
    call2();
  }
  finish=clock();
  printf("execute time:%f us\n",(double)(finish - start)*1000000/CLOCKS_PER_SEC);
}

结果：

D:\workspace\HEVC\C++vsC>Circle_C.exe
execute time:38000.000000 us

D:\workspace\HEVC\C++vsC>"Circle_C++.exe"
execute time:39000us

时间基本差不多

3 函数执行为主体

void call3() //函数执行为主体
{
  Shape *pShape = new Circle(50, 100, 25);
  Circle aCircle(5,5, 2);
  int i=1000000;
  while(i--);
  {
      pShape->Erase();
  }
  delete pShape;
}

void call3() //函数执行为主体
{
    int i=1000000;
    Shape *pShape = (Shape *) Circle_Constructor(NULL, 50, 100, 25);
    Circle aCircle;
    Circle_Constructor(&aCircle, 5, 5, 2);
    while(i--)
    {
   Shape_Erase(pShape);
  }    
    (pShape->pVTable[2].pFunc)(pShape, TRUE);
    Circle_Destructor(&aCircle, FALSE);
}

结果：

D:\workspace\HEVC\C++vsC>"Circle_C++.exe"
execute time:3000us

D:\workspace\HEVC\C++vsC>Circle_C.exe
execute time:10000.000000 us

C++比C快，C的时间是C++的3倍。

4 开始的代码C比C++快的原因

C code
void main()
{
    clock_t start,finish;
  start=clock();
  printf("输出比较\n");    
  finish=clock();
  printf("execute time:%f us\n",(double)(finish - start)*1000000/CLOCKS_PER_SEC);
}

C++ code
int main()
{
    clock_t start,finish;
    start = clock();
  std::cout<<"输出比较"<<std::endl;
  finish = clock();
  
  std::cout <<"execute time:" <<( (double)(finish - start)*1000000/CLOCKS_PER_SEC )<<"us"<<std::endl;
  return 0;

} 

D:\workspace\HEVC\C++vsC>"Circle_C++.exe"
输出比较
execute time:3000us

D:\workspace\HEVC\C++vsC>Circle_C.exe
输出比较
execute time:1000.000000 us

看来是C的输出函数比C++的效率要高。

5 将1中main中的代码放在call函数中，去掉输出打印函数

C++ code 
int main()
{
    clock_t start,finish;
    int i=10000;
    start = clock();
    while(i--)
    {
  call();
  }
  finish = clock();
  
  std::cout <<"execute time:" <<( (double)(finish - start)*1000000/CLOCKS_PER_SEC )<<"us"<<std::endl;
  return 0;

}  
C code
void main()
{
    clock_t start,finish;
    int i=10000;
    start = clock();
    while(i--)
    {
  call();
  }  
  finish=clock();
  printf("execute time:%f us\n",(double)(finish - start)*1000000/CLOCKS_PER_SEC);
}

D:\workspace\HEVC\C++vsC>"Circle_C++.exe"
execute time:4000us

D:\workspace\HEVC\C++vsC>Circle_C.exe
execute time:4000.000000 us

时间一样。

总结：C++转成C代码后，在类的构造、销毁与C的结构体的构造销毁上，效率没什么区别；而在具体函数的实现上，按照文章的转换方法，C的效率却只有C++的1/3，可以说类的成员函数调用方式比转换成C的直接调用函数的方式效率要高。

但是C的输出函数printf比C++的cout效率要高，时间是C++的1 /3。

 

原文地址 http://www.eventhelix.com/realtimemantra/basics/ComparingCPPAndCPerformance2.htm 

源码下载地址 http://download.csdn.net/detail/mlj318/3748113