C++ vtable

在 C++ 的OO模型中，很重要的一个特性是运行时多态。运行时多态是通过类的虚方法实现的。看下面这个例子：

struct IObject {
  virtual void MethodA() = 0;  
  virtual int  MethodB(char *) = 0;
};

class A : public IObject {
public:
  virtual void MethodA() {
    std::cout << "method A" << std::endl;
  };

  virtual int MethodB(char *p) {
    std::cout << "method B " << p << std::endl;
    return 0;
  };

public:
  int MethodC(int c) {
    std::cout << "method C non-virtual" << std::endl;
    return ++c;
  }
private:
  int mem_;
};

int main(int argc, cahr *argv[]) 
{
  IObject *pObj = new A;

  pObj->MethodA();
  pObj->MethodB(NULL);

  // FIXME: This is a compile error!
  pObj->MethodC(1); // error

  delete A;

  return 0;
};

C++ 运行时多态， 在执行代码中，主要通过 vtable 实现。让我们用C来重新描述上面的例子。

// VTABLE of class IObject
struct I_IObject {
  void *pMethodA(void);
  int  *pMethodB(char *);
};

// Instance variant type of IObject
struct IObject {
  struct I_IObject *vtable_this;
};

// VTABLE of class A
struct A;
struct I_A {
  void *pDtor(A*) 
};

// Instance object variant type of class A
struct A {
  struct I_IObject *vtable_IObject;
  struct I_A *vtable_this;

  int *pMethodC(int);
  int mem_;
};

void A_MethodA (void) {
  printf("method A\n"); 
}

int  A_MethodB (char *p) {
  printf("method B %s\n", p);
}

int  A_MethodC (int c) {
  printf("method C non-virtual\n");
  return ++c;
}

void A_dtor(struct A *_this) {
  free(_this);
}

struct A *A_ctor() {
  struct A *p = malloc(sizeof(struct A));

  // Non-virtual function will be assign the value directly.
  p.pMethodC = &A_MethodC;

  /////////////////////////////////////////////////
  // vtable initialization code
#ifdef A_MethodA
  p.vtable_IObject->pMethodA = &A_MethodA;
#else
  p.vtable_IObject->pMethodA = &IObject_MethodA; // Warning!
#endif

#ifdef A_MethodB
  p.vtable_IObject->pMethodB = &A_MethodB;
#else
  p.vtable_IObject->pMethodB = &IObject_MethodB; // Warning!
#endif

  // vtable of A itself
  p.vtable_self->pDtor = &A_dtor;

  return p;
}

int main(int argc, char *argv[]) 
{
  IObject *pObj = (IObject*) A_ctor();

  pObj->vtable_self->pMethodA();
  pObj->vtable_self->pMethodB(NULL);

  A_dtor(pObj);

  return 0;
}

C的定价物确实有些繁琐，不过基本的结构就是这样了。具体说来是这样：
1，如果一个类 virtual function, 这些 virtual funciton 就会被统一在一个 vtable 中；
2，包含 virtual function 的class 都会有一个指向 vtable structure的指针，如果当前类重写了 virtual function, 在对象初始化的时候相应的虚函数指针就会被替换；
3，虚函数的调用一律通过vtable定位，因为存在vtable这一层中继，就可以保证在运行态可以通过父类的指针执行指向子类对象的方法，因为类对象初始化的时候正确的重写了vtable的内容。
4，一个对象多一个包含virtual function的基类，就会在类变量的结构中多引入一个指向父类vtable structure的指针。在类对象初始化的时候，就需要更多的 vtable 初始化代码。:D

多重继承会导致 vtable 膨胀， Microsoft ATL 引入了一个 ATL_NO_VTABLE __declspec(novtable) C++ 扩展。关于这个，下回再说~~~

其实这个例子里面还有一个小问题, 不知道大家能不能看出来啊!