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。

 

 

    再看例子2：

/* 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成員。