第十五章

基类成员函数 

        除了构造函数之外，任意非 static 成员函数都可以是虚函数。保留字只在类内部的成员函数声明中出现，不能用在类定义体外部出现的函数定义上。

15.2.2

        protected 还有另一重要性质： 派生类只能通过派生类对象访问其基类的 protected 成员，派生类对其基类类型对象的 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 类型的对象没有特殊访问访问权限。

15.2.3

        派生类中虚函数的声明（第 7.4 节）必须与基类中的定义方式完全匹配，但有一个例外：返回对基类型的引用（或指针）的虚函数。派生类中的虚函数可以返回基类函数所返回类型的派生类的引用（或指针）。

派生类的声明 

        如果需要声明（但并不实现）一个派生类，则声明包含类名但不包含派生列表。例如，下面的前向声明会导致编译时错误：

// error: a forward declaration must not include the derivation list
class Bulk_item : public Item_base;

15.2.5

        无论派生列表中是什么访问标号，所有继承 Base 的类对 Base 中的成员具有相同的访问。派生访问标号将控制派生类的用户对从 Base 继承而来的成员的访问 。

        size 在 Base 中为 public，但在 Derived 中为private。为了使 size 在 Derived 中成为 public， 可以在 Derived 的 public部分增加一个 using 声明。如下这样改变 Derived 的定义，可以使 size 成员能够被用户访问，并使 n 能够被从 Derived 派生的类访问：

class Base {
public:
std::size_t size() const { return n; }
protected:
std::size_t n;
};
class Derived : private Base {
public:
// maintain access levels for members related to the size of the
object
using Base::size;
protected:
using Base::n;
// ...
};

        class 保留字定义的派生默认具有 private 继承， 而用 struct 保留字定义的类默认具有 public 继承：

class Base { /* ... */ };
struct D1 : Base { /* ... */ }; // public inheritance by default
class D2 : Base { /* ... */ }; // private inheritance by default

12.2.6

         友元关系不能继承。基类的友元对派生类的成员没有特殊访问权限。如果基类被授予友元关系，则只有基类具有特殊访问权

限，该基类的派生类不能访问授予友元关系的类。

class Base {
friend class Frnd;
protected:
int i;
};
// Frnd has no access to members in D1
class D1 : public Base {
protected:
int j;
};
class Frnd {
public:
int mem(Base b) { return b.i; } // ok: Frnd is friend to Base
int mem(D1 d) { return d.i; } // error: friendship doesn't inherit
};
// D2 has no access to members in Base
class D2 : public Frnd {
public:
int mem(Base b) { return b.i; } // error: friendship doesn't inherit
};

        如果基类定义 static 成员（第 12.6 节），则整个继承层次中只有一个这样的成员。

15.3

        可以将派生类对象的引用转换为基类子对象的引用，对指针也类似。没有从基类引用（或基类指针）到派生类引用（或派生类指针）的（自动）转换。没有从派生类型对象到基类类型对象的直接转换，但是，一般可以使用派生类型对象对基类对象进行赋值或初始化。

引用转换不同于转换对象 

        将对象传给希望接受引用的函数时，引用直接绑定到该对象，虽然看起来在传递对象，实际上实参是该对象的引用，对象本身未被复制，并且，转换不会在任何方面改变派生类型对象，该对象仍是派生类型对象。将派生类对象传给希望接受基类类型对象（而不是引用），则该派生类对象的基类部分被复制到形参。

派生类到基类转换的可访问性 

        要确定到基类的转换是否可访问，可以考虑基类的 public成员是否访问（所谓可以访问是对于某一个作用域而言的，对于该作用域内public可以访问就存在转换），如果可以，转换是可访问的，否则，转换是不可访问的：无论是什么派生访问标号，派生类本身都可以访问基类的 public 成员，因此，派生类本身的成员和友元总是可以访问派生类到基类的转换。

15.3.2

        从基类到派生类的自动转换是不存在的。需要派生类对象时不能使用基类对象：

Bulk_item bulk;
Item_base *itemP = &bulk; // ok: dynamic type is Bulk_item
Bulk_item *bulkP = itemP; // error: can't convert base to derived

        编译器在编译时无法知道特定转换在运行时实际上是安全的。编译器确定转换是否合法，只看指针或引用的静态类型。

        一个类只能初始化自己的直接基类。

15.4.2

       如果派生类定义了自己的复制构造函数，该复制构造函数一般应显式使用基类复制构造函数初始化对象的基类部分：

class Base { /* ... */ };
class Derived: public Base {
public:
// Base::Base(const Base&) not invoked automatically
Derived(const Derived& d):
Base(d) /* other member initialization */ { /*... */ }
};

        如果省略基类初始化函数，如下代码：

// probably incorrect definition of the Derived copy constructor
Derived(const Derived& d) /* derived member initizations */
{/* ... */ }

        效果是运行 Base 的默认构造函数初始化对象的基类部分。假定 Derived成员的初始化从 d 复制对应成员，则新构造的对象将具有奇怪的配置：它的Base 部分将保存默认值，而它的 Derived 成员是另一对象的副本。

        析构函数的工作与复制构造函数和赋值操作符不同：派生类析构函数不负责撤销基类对象的成员。 对象的撤销顺序与构造顺序相反：首先运行派生析构函数，然后按继承层次依次向上调用各基类析构函数。

        基类析构函数是三法则（第 13.3 节）的一个重要例外。基类具有析构函数并不表示也需要赋值操作符或复制构造函数。

构造函数和赋值操作符不是虚函数 

        基类赋值操作符有一个形参是自身类类型的引用，如果该操作符为虚函数，则每个类都将得到一个虚函数成员，该成员定义了参数为一个基类对象的 operator=。 但是， 派生类中的赋值操作符有一个与类本身类型相同的形参， 该类型必须不同于继承层次中任意其他类的赋值操作符的形参类型。 

15.5.1 名字查找在编译时发生 

        对象、引用或指针的静态类型决定了对象能够完成的行为。静态类型仍然决定着可以使用什么成员。

Bulk_item bulk;
Bulk_item *bulkP = &bulk; // ok: static and dynamic types are the same
Item_base *itemP = &bulk; // ok: static and dynamic types differ
bulkP->discount_policy(); // ok: bulkP has type Bulk_item*
itemP->discount_policy(); // error: itemP has type Item_base*

15.8

Sales_item(const Item_base&);

         我们不知道给予构造函数的对象的实际类型。我们知道它是一个 Item_base 对象或者是一个 Item_base 派生类型的对象。句柄类经常需要在不知道对象的确切类型时分配书籍对象的新副本。 解决这个问题的通用方法是定义虚操作进行复制，我们称将

该操作命名为 clone。

class Item_base {
public:
virtual Item_base* clone() const
{ return new Item_base(*this); }
};
class Bulk_item : public Item_base {
public:
Bulk_item* clone() const
{ return new Bulk_item(*this); }
};

Sales_item::Sales_item(const Item_base &item):p(item.clone()), use(new std::size_t(1)) { }