我是C++菜鸟，刚学了一点C++。
先看例子1：
/* Item.h */
#include <iostream>
#include <string>
classItem_base{
public:
Item_base(conststd::string&book="",
doublesales_price=0.0):
isbn(book),price(sales_price){}
std::stringbook()const{returnisbn;}
boolisPrecious(Item_base&other);
virtualdoublenet_price(std::size_tn)const
{returnn*price;}
virtual~Item_base(){}
private:
std::stringisbn;
doubleprice;
};
/* Item.cc */
#include "Item.h"
boolItem_base::isPrecious(Item_base&other)
{
if(price>other.price)
returntrue;
returnfalse;
}
/* test.cc */
#include "Item.h"
usingstd::cout;
usingstd::endl;
intmain()
{
Item_basebase("TN-119",12.3);
cout<<"isbn: "<<base.book()<<endl;
doubletotal_price=base.net_price(3);
cout<<"total: "<<total_price<<endl;
Item_basebase1("TN-120",15.4);
if(base.isPrecious(base1))
cout<<base.book()<<" is precious than "<<base1.book()<<endl;
else
cout<<base.book()<<" is cheaper than "<<base1.book()<<endl;
return0;
}
在没有继承的情况下，只要public、private就足够了，private成员不能被用户（test.cc）使用，用户只能通过类的public接口来使用它们，比如用base.book()来获得base.isbn。
在类中，该类（不是该类的一个对象，而是该类的任何对象）的private成员都可以被访问，如bool Item_base::isPrecious(Item_base &other)函数中，就可以访问Item_base类的price成员，当然成员的访问要依赖于具体的对象，如这里的this、other。
再看例子2：
/* Item.h */
#include <iostream>
#include <string>
classItem_base{
public:
Item_base(conststd::string&book="",
doublesales_price=0.0):
isbn(book),price(sales_price){}
std::stringbook()const{returnisbn;}
boolisPrecious(Item_base&other);
virtualdoublenet_price(std::size_tn)const
{returnn*price;}
virtual~Item_base(){}
private:
std::stringisbn;
doubleprice;
};
classBulk_item:publicItem_base{
public:
Bulk_item(std::size_tmin,doubledisc_rate):
min_qty(min),discount(disc_rate){}
Bulk_item(conststd::string&book,doublesales_price,
std::size_tmin,doubledis):
Item_base(book,sales_price),min_qty(min),discount(dis){}
private:
std::size_tmin_qty;
doublediscount;
};
/* Item.cc */
#include "Item.h"
boolItem_base::isPrecious(Item_base&other)
{
if(price>other.price)
returntrue;
returnfalse;
}
/* test.cc */
#include "Item.h"
usingstd::cout;
usingstd::endl;
intmain()
{
Item_basebase("TN-119",12.3);
Bulk_itembulk("TNP-132",13.3,3,0.2);
if(base.isPrecious(bulk))
cout<<base.book()<<" is more expensive than "<<bulk.book()<<endl;
if(bulk.isPrecious(base)) //ok! isPrecious is base's func, it can access base's data
cout<<base.book()<<" is cheaper than "<<bulk.book()<<endl;
return0;
}
Bulk_item类继承了Item_base类，并从哪里继承了boolisPrecious(Item_base&other)方法，但要注意该方法仍然是基类定义的，只是被子类继承过来用而已。再看test.cc中的base.isPrecious(bulk)调用，该实参被自动转化为Item_base类，isPrecious（）函数仍可以访问bulk从基类那继承来的private成员price。
最后看一下例子3：
/* Item.h */
#include <iostream>
#include <string>
classItem_base{
public:
Item_base(conststd::string&book="",
doublesales_price=0.0):
isbn(book),price(sales_price){}
std::stringbook()const{returnisbn;}
boolisPrecious(Item_base&other);
virtualdoublenet_price(std::size_tn)const
{returnn*price;}
virtual~Item_base(){}
private:
std::stringisbn;
protected:
doubleprice;
};
classBulk_item:publicItem_base{
public:
Bulk_item(std::size_tmin,doubledisc_rate):
min_qty(min),discount(disc_rate){}
Bulk_item(conststd::string&book,doublesales_price,
std::size_tmin,doubledis):
Item_base(book,sales_price),min_qty(min),discount(dis){}
doublenet_price(std::size_tn)const;
private:
std::size_tmin_qty;
doublediscount;
};
/* Item.cc */
#include "Item.h"
boolItem_base::isPrecious(Item_base&other)
{
if(price>other.price)
returntrue;
returnfalse;
}
doubleBulk_item::net_price(std::size_tn)const
{
if(n>=min_qty)
returnprice*(1-discount)*n;
returnprice*n;
}
/* test.cc */
#include "Item.h"
usingstd::cout;
usingstd::endl;
intmain()
{
Item_basebase("TN-119",12.3);
Bulk_itembulk("TNP-132",13.3,3,0.2);
cout<<base.book()<<" 3X total: "<<base.net_price(3)<<endl;
cout<<bulk.book()<<" 3X total: "<<bulk.net_price(3)<<endl;
return0;
}
和前面最大的不同在于，子类要重写基类的某个方法，如这里的doubleBulk_item::net_price(std::size_tn)const。那么这个方法就完全是子类自己定义的，它将不能访问从基类那继承过来的private成员，除非在基类中把这些成员定义为protected。
和例子1中讲的一样，在类中访问有权限访问的成员时，必须依赖于该类的一个对象，如这里的this（隐式的）；同样，若net_price(xx, Bulk_item bulk)还有一个bulk参数，那么它也可以访问bulk.price；但是，若net_price(xx, Item_base base)有一个base参数，那它不能访问base.price，因为一个类内不能访问其它类的非public成员。