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

时间:2022-06-01 18:47:38

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include <iostream>
#include<string>
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<<money()<<endl;
  }
};
class BookBatchItem:public BookItem
{
private:
  string bookName;
  size_t cnt;
public:
  BookBatchItem(const string&s,size_t c,double p,double discountRate):
    BookItem(s,c,p),cnt(c),discount(discountRate)
    {}
  ~BookBatchItem(){}
private:
  double discount;
public:
  double money()
  {
    if(cnt>=10)
      return cnt*price*(1.0-discount);
    else
      return cnt*price;
  }
  void costMoney()
  {
    cout<<money()<<endl;
//    cout<<cnt<<endl;
//    cout<<price<<endl;
//    cout<<discount<<endl;
//    cout<<"..."<<endl;
  }
};
int main()
{
  BookItem b1("Uncle Tom's house",11,12.5);
  b1.costMoney();
  BookBatchItem b2("Gone with wind",11,12.5,0.12);
  b2.costMoney();
  BookItem* pb=&b1;
  pb->costMoney();
  pb=&b2;
  pb->costMoney();
  return 0;
}

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

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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++的成员函数调用与绑定方式,可以通过下面的代码测试:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Base
{
public:
  virtual void Func() { cout<<"Base"<<endl; }
};
 
class Derived:public Base
{
public:
  virtual void Func() { cout<<"Derived"<<endl; }
};
 
int main()
{
  Derived obj;
  Base * p1 = &obj;
  Base & p2 = obj;
  Base obj2 ;
 
  obj.Func() ;  //静态绑定,Derived的func
  p1->Func();   //动态绑定,Derived的func
  (*p1).Func();  //动态绑定,Derived的func
  p2.Func();   //动态绑定,Derived的func
  obj2.Func();  //静态绑定,Base的func
 
  return 0 ;
}

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