C++中的public、private、protected成员继承问题

    我是C++菜鸟，刚学了一点C++。

先看例子1：

/* Item.h */

#include <iostream>

#include <string>

class
Item_base
{

public:

Item_base(const
std::string
&book
=
"",

double
sales_price
=
0.0)
:

isbn(book),
price(sales_price)
{}

std::string
book()
const
{return
isbn;}

bool
isPrecious(Item_base
&other);

 

virtual
double
net_price(std::size_t
n)
const

{
return
n*price;
}

virtual
~Item_base()
{}

 

private:

std::string
isbn;

double
price;

};

 

 

/* Item.cc */

#include "Item.h"

bool
Item_base::isPrecious(Item_base
&other)

{

if(price
>
other.price)

return
true;

return
false;

}

 

 

/* test.cc */

#include "Item.h"

using
std::cout;

using
std::endl;

int
main()

{

Item_base
base("TN-119",12.3);

cout
<<"isbn: "
<<base.book()
<<endl;

 

double
total_price
=
base.net_price(3);

cout
<<"total: "
<<total_price
<<endl;

 

Item_base
base1("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;

return
0;

}

 

    在没有继承的情况下，只要public、private就足够了，private成员不能被用户（test.cc）使用，用户只能通过类的public接口来使用它们，比如用base.book()来获得base.isbn。

    在类中，该类（不是该类的一个对象，而是该类的任何对象）的private成员都可以被访问，如bool Item_base::isPrecious(Item_base &other)函数中，就可以访问Item_base类的price成员，当然成员的访问要依赖于具体的对象，如这里的this、other。

 

 

：

/* Item.h */

#include <iostream>

#include <string>

class
Item_base
{

public:

Item_base(const
std::string
&book
=
"",

double
sales_price
=
0.0)
:

isbn(book),
price(sales_price)
{}

std::string
book()
const
{return
isbn;}

bool
isPrecious(Item_base
&other);

 

virtual
double
net_price(std::size_t
n)
const

{
return
n*price;
}

virtual
~Item_base()
{}

 

private:

std::string
isbn;

double
price;

};

 

class
Bulk_item
:
public
Item_base
{

public:

Bulk_item(std::size_t
min,
double
disc_rate)
:

min_qty(min),
discount(disc_rate)
{}

Bulk_item(const
std::string
&book,
double
sales_price,

std::size_t
min,
double
dis)
:

Item_base(book,sales_price),
min_qty(min),
discount(dis)
{}

 

private:

std::size_t
min_qty;

double
discount;

};

 

 

/* Item.cc */

#include "Item.h"

bool
Item_base::isPrecious(Item_base
&other)

{

if(price
>
other.price)

return
true;

return
false;

}

 

 

/* test.cc */

#include "Item.h"

using
std::cout;

using
std::endl;

int
main()

{

Item_base
base("TN-119",12.3);

Bulk_item
bulk("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;

 

return
0;

}

 

    Bulk_item类继承了Item_base类，并从哪里继承了bool
isPrecious(Item_base
&other)方法，但要注意该方法仍然是基类定义的，只是被子类继承过来用而已。再看test.cc中的base.isPrecious(bulk)调用，该实参被自动转化为Item_base类，isPrecious（）函数仍可以访问bulk从基类那继承来的private成员price。

 

 

    最后看一下例子3：

/* Item.h */

#include <iostream>

#include <string>

class
Item_base
{

public:

Item_base(const
std::string
&book
=
"",

double
sales_price
=
0.0)
:

isbn(book),
price(sales_price)
{}

std::string
book()
const
{return
isbn;}

bool
isPrecious(Item_base
&other);

 

virtual
double
net_price(std::size_t
n)
const

{
return
n*price;
}

virtual
~Item_base()
{}

 

private:

std::string
isbn;

protected:

double
price;

};

 

class
Bulk_item
:
public
Item_base
{

public:

Bulk_item(std::size_t
min,
double
disc_rate)
:

min_qty(min),
discount(disc_rate)
{}

Bulk_item(const
std::string
&book,
double
sales_price,

std::size_t
min,
double
dis)
:

Item_base(book,sales_price),
min_qty(min),
discount(dis)
{}

double
net_price(std::size_t
n)
const;

 

private:

std::size_t
min_qty;

double
discount;

};

 

 

/* Item.cc */

#include "Item.h"

bool
Item_base::isPrecious(Item_base
&other)

{

if(price
>
other.price)

return
true;

return
false;

}

 

double
Bulk_item::net_price(std::size_t
n)
const

{

if(n>=min_qty)

return
price*(1-discount)*n;

return
price*n;

}

 

 

/* test.cc */

#include "Item.h"

using
std::cout;

using
std::endl;

int
main()

{

Item_base
base("TN-119",12.3);

Bulk_item
bulk("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;

 

return
0;

}

 

    和前面最大的不同在于，子类要重写基类的某个方法，如这里的double
Bulk_item::net_price(std::size_t
n)
const。那么这个方法就完全是子类自己定义的，它将不能访问从基类那继承过来的private成员，除非在基类中把这些成员定义为protected。

    和例子1中讲的一样，在类中访问有权限访问的成员时，必须依赖于该类的一个对象，如这里的this（隐式的）；同样，若net_price(xx, Bulk_item bulk)还有一个bulk参数，那么它也可以访问bulk.price；但是，若net_price(xx, Item_base base)有一个base参数，那它不能访问base.price，因为一个类内不能访问其它类的非public成员。