C++笔记：面向对象编程基础(二)

Code

Code1：派生类只能通过派生类对象访问其基类的protected成员

/*假定 Bulk_item 定义了一个成员函数，接受一个 Bulk_item 对象的 引用和一个 Item_base 对象的引用，该函数可以访问自己对象的 protected 成 员以及 Bulk_item 形参的 protected 成员，但是，它不能访问 Item_base 形 参的 protected 成员。*/
 void Bulk_item::memfcn(const Bulk_item &d， const Item_base &b)
 {
    // attempt to use protected member
    double ret = price; // ok: uses this->price
    ret = d.price; // ok: uses price from a Bulk_item object
    ret = b.price; // error: no access to price from an Item_base
}
/*d.price 的使用正确，因为是通过 Bulk_item 类型对象引用 price;b.price 的 使用非法，因为对 Base_item 类型的对象没有特殊访问访问权限。*/

Code2：声明(但并不实现)一个派生类

//error: a forward declaration must not include the derivation list class   Bulk_item : public Item_base;
 //正确的前向声明为:
 //forward declarations of both derived and nonderived class
 class Bulk_item;
 class Item_base;

Code3：覆盖虚函数机制

Item_base *baseP = &derived;
 //calls version from the base class regardless of the dynamic type of baseP
 double d = baseP->Item_base::net_price(42);

Code4：在派生类的成员函数内部访问基类的成员，访问级别取决于基类的类型

class Base {
public:
    void basemem();
protected:
    int i;
// ... 
};

struct Public_derived : public Base {
    int use_base() { return i; } // ok: derived classes can access i
    // ...
};
struct Private_derived : private Base {
    int use_base() { return i; } // ok: derived classes can access i
};

Code5：在派生类定义与实现的外部，即派生类的对象或者继承自派生类的类，派生类成员访问级别取决于派生类继承基类的访问标号

Base b;
Public_derived d1;
Private_derived d2;
b.basemem();   // ok: basemem is public
d1.basemem();  // ok: basemem is public in the derived class
d2.basemem();  // error: basemem is private in the derived class

//派生访问标号还控制来自非直接派生类的访问:
 struct Derived_from Private : public Private_derived {
     // error: Base::i is private in Private_derived
     int use_base() { return i; }
 };
 struct Derived_from_Public : public Public_derived {
     // ok: Base::i remains protected in Public_derived
     int use_base() { return i; }
 };

Code6：派生类可以恢复继承成员的访问级别

class Base {
 public:
     std::size_t size() const { return n; }
 protected:
     std::size_t n;
 };
 class Derived : private Base { . . . };

 /*在这一继承层次中，size 在 Base 中为 public，但在 Derived 中为 private。为了使 size 在 Derived 中成为 public，可以在 Derived 的 public 部分增加一个 using 声明。如下这样改变 Derived 的定义，可以使 size 成员 能够被用户访问，并使 n 能够被从 Derived 派生的类访问:*/
 class Derived : private Base {
 public:
 // maintain access levels for members related to the size of the object
    using Base::size;
 protected:
     using Base::n;
 // ... 
};