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<
}
};
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<
// cout<
// cout<
// cout<
// cout<
}
};
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#的程序员容易犯的一个错误。
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<
};
class Derived:public Base
{
public:
virtual void Func() { cout<
};
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 ;
}
可以看出“对象名.函数()”属于静态绑定,当然,使用指针转换为对象的方式应该属于指针调用那一类了,至于“类名::函数()”毫无疑问属于静态绑定。