C++实现动态绑定代码分享

C++实现动态绑定代码分享

#include 
#include
using namespace std;
class BookItem
{
private:
  string bookName;
  size_t cnt;
public:
  BookItem(const string&s,size_t c,double p):
    bookName(s),cnt(c),price(p)
    {}
  ~BookItem(){}
protected:
  double price;
public:
  double bookPrice()
  {
    return this->price;
  }
  string getBookName()
  {
    return this->bookName;
  }
  size_t getBookCount()
  {
    return this->cnt;
  }
  virtual double money()
  {
     return cnt*price;
  }
  virtual void costMoney()
  {
    cout<=10)
      return cnt*price*(1.0-discount);
    else
      return cnt*price;
  }
  void costMoney()
  {
    cout<costMoney();
  pb=&b2;
  pb->costMoney();
  return 0;
}

只有采用“指针->函数()”或“引用.函数()”的方式调用C++类中的虚函数才会执行动态绑定，非虚函数并不具备动态绑定的特征，不管采用任何方式调用都不行。

下面代码中，一个java或者C#的程序员容易犯的一个错误。

 class base
 {
 public:
   base() { p = new char ; }
   ~base() { delete p; }
 private:
   char * p ;
 };
 
 class Derived:public base
 {
 public:
   Derived() { d = new char[10] ; }
   ~Derived() { delete[] d; }
 private:
   char * d ;
 };
 
 int main()
 {
   base *pA = new Derived();
   delete pA ;
   
   Derived *pA = new Derived();
   delete pA ;
 }

代码中：
执行delete pA时，直接执行~base析构函数，不会执行~Derived析构函数的，原因在于析构函数不是虚函数。
执行delete pB时，先执行~Derived()然后再执行~base()。
相比之下，java和C#中，所有的函数调用都是动态绑定的。

关于C++的成员函数调用与绑定方式，可以通过下面的代码测试：

 class base
 {
 public:
   virtual void Func() { cout<<"base"<Func();   //动态绑定，Derived的func
   (*p1).Func();  //动态绑定，Derived的func
   p2.Func();   //动态绑定，Derived的func
   obj2.Func();  //静态绑定，base的func
 
   return 0 ;
 }

可以看出“对象名.函数()”属于静态绑定，当然，使用指针转换为对象的方式应该属于指针调用那一类了，至于“类名::函数()”毫无疑问属于静态绑定。