面向对象编程

--转换与继承、复制控制与继承

I.转换与继承

引言：

由于每一个派生类对象都包括一个基类部分，因此能够像使用基类对象一样在派生类对象上执行操作。

对于指针/引用，能够将派生类对象的指针/引用转换为基类子对象的指针/引用。

基类类型对象既能够作为独立对象存在,也能够作为派生类对象的一部分而存在,因此,一个基类对象可能是也可能不是一个派生类对象的部分,因此,没有从基类引用(或基类指针)到派生类引用(或派生类指针)的(自己主动)转换。

关于对象类型，尽管一般能够使用派生类型的对象对基类类型的对象进行初始化或赋值,但,没有从派生类型对象到基类类型对象的直接转换。

一、派生类到基类的转换

假设有一个派生类型的对象,则能够使用它的地址对基类类型的指针进行赋值或初始化。相同,能够使用派生类型的引用或对象初始化基类类型的引用。可是，对象没有相似转换。编译器不会自己主动将派生类型对象转换为基类类型对象。

可是,一般能够使用派生类型对象对基类对象进行赋值或初始化。对对象进行初始化和/或赋值以及能够自己主动转换引用或指针。

1、引用转换不同于转换对象

关于引用转换：将对象传给希望接受引用的函数时,引用直接绑定到该对象,尽管看起来在传递对象,实际上实參是该对象的引用,对象本身未被复制,而且,转换不会在不论什么方面改变派生类型对象,该对象仍是派生类型对象。

关于对象转换：将派生类对象传给希望接受基类类型对象(而不是引用)的函数时,形參的类型是固定的——在编译时和执行时形參都是基类类型对象。假设用派生类型对象调用这种函数,则该派生类对象的基类部分被拷贝到形參。

小结：一个是派生类对象转换为基类类型引用,一个是用派生类对象对基类对象进行初始化或赋值。

2、用派生类对象对基类对象进行初始化或赋值

对基类对象进行初始化或赋值,实际上是在调用函数:初始化时调用构造函数,赋值时调用赋值操作符。

基类一般(显式或隐式地)定义自己的复制构造函数和赋值操作符,这些成员接受一个形參,该形參是基类类型的(const)引用。由于存在从派生类引用到基类引用的转换,这些复制控制成员可用于从派生类对象对基类对象进行初始化或赋值:

    Item_base item;
    Bulk_item bulk;

    Item_base item1(bulk);	//调用Item_base的复制构造函数
    item = bulk;				//调用Item_base的赋值操作符

用Bulk_item类型的对象调用Item_base类的复制构造函数或赋值操作符时,将发生下列步骤:

1)将Bulk_item对象转换为Item_base引用,这仅仅意味着将一个Item_base引用绑定到Bulk_item对象。

2)将该引用作为实參传给复制构造函数或赋值操作符。

3)那些操作符使用Bulk_item的 Item_base部分分别对调用构造函数或赋值的 Item_base对象的成员进行初始化或赋值。

4)一旦操作符执行完成,对象即为Item_base。它包括Bulk_item的 Item_base部分的副本,但实參的Bulk_item部分被忽略。

在这种情况下,bulk的Bulk_item部分在对item进行初始化或赋值时被“切掉”了。Item_base对象仅仅包括基类中定义的成员,不包括由随意派生类型定义的成员,Item_base对象中没有派生类成员的存储空间。

3、派生类到基类转换的可訪问性

像继承的成员函数一样，从派生类到基类的转换可能也可能不是可訪问的。转换能否够訪问取决于在派生类的派生列表中指定的訪问标号。

【提示：】要确定到基类的转换是否可訪问，能够考虑基类的public成员是否可訪问，假设能够，则转换是可訪问的，否则，转换是不可訪问的！

1)public继承:用户代码和后代类都能够使用派生类到基类的转换。

2)private或 protected继承:则用户代码不能将派生类型对象转换为基类对象。假设是 private继承,则从private继承类派生的类不能转换为基类。假设是protected继承,则兴许派生类的成员能够转换为基类类型。

不管是什么派生訪问标号,派生类本身都能够訪问基类的public[protected]成员,因此,派生类本身的成员和友元总是能够訪问派生类到基类的转换。

二、基类到派生类的转换

从基类到派生类的自己主动转换是不存在的：

    Item_base base;
    Bulk_item *bulkP = &base;	//Error
    Bulk_item &bulkRef = base;	//Error
    Bulk_item bulk = base;			//Error

没有从基类类型到派生类型的（自己主动）转换，原因在于基类对象仅仅能是基类对象，它不能包括派生类对象的成员。假设同意基类对象给派生类类型对象赋值，那么就能够试图使用派生类对象訪问不存在的成员！

更有甚者：当基类指针或引用实际绑定到派生类对象时,从基类到派生类的转换也存在限制:

    Bulk_item bulk;
    Item_base *itemP = &bulk;
    Bulk_item *bulkP = itemP;   //Error

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

在这些情况下,假设用户知道从基类到派生类的转换是安全的,就能够使用static_cast强制编译器进行转换。或者,能够用dynamic_cast申请在执行时进行检查。

    Bulk_item bulk;
    Item_base *itemP = &bulk;
    Bulk_item *bulkP = static_cast<Bulk_item*>(itemP);   //OK
    Bulk_item *bulkP = dynamic_cast<Bulk_item*>(itemP);   //OK

II.复制控制与继承

引言：

当构造、复制、赋值和撤销派生类对象时，也会构造、复制、赋值和撤销基类子对象！

构造函数和复制控制成员不能继承，每一个类定义自己的构造函数和复制控制成员。像不论什么类一样，假设类不定义自己的默认构造函数和复制控制成员，则编译器将使用合成版本号！

一、基类构造函数和复制控制

本身不是派生类的基类,其构造函数和复制控制基本上不受继承影响：

    Item_base(const std::string &book = "",
              double sales_price = 0.0):
        isbn(book),price(sales_price) {}

构造函数能够设置成为protected或private，某些类须要仅仅希望派生类使用的特殊构造函数，则将够函数设置成为protected。

二、派生类构造函数

每一个派生类构造函数出了初始化自己的数据成员，还要初始化基类！

1、合成的派生类默认构造函数

派生类的合成默认构造函数与非派生类的构造函数仅仅有一点不同：除了初始化派生类的数据成员之外，它还须要初始化派生类对象的基类部分[事实上是先初始化基类部分的，一定要掌握好初始化顺序]！

对于Bulk_item类，合成的默认构造函数执行顺序：

1)调用Item_base的默认构造函数；[基类]

2)用常规变量初始化规则初始化Bulk_item的成员，也就是说，qty和discount成员是未初始化的！[派生类]

2、定义默认构造函数

由于Bulk_item具有内置类型成员,所以应定义自己的默认构造函数:

class Bulk_item:public Item_base
{
public:
    Bulk_item():min_qty(0),discount(0) {}
    // AS Before...
};

该构造函数出了初始化qty和discount成员之外，还会隐式调用Item_base的默认构造函数初始化对象的基类部分[事实上是先执行基类的默认构造函数的！]。

执行这个构造函数的效果是,首先使用Item_base的默认构造函数初始化Item_base部分,Item_base的构造函数执行完成后,再初始化Bulk_item部分的成员并执行构造函数的函数体(函数体为空)。

3、向基类构造函数传递实參

派生类构造函数初始化列表仅仅能初始化派生类的成员，不能直接初始化继承成员。相反，派生类构造函数通过将基类构造函数包括在初始化列表中来间接初始化继承成员：

    Bulk_item(const std::string &book,double sales_price,
              std::size_t qty = 0,double disc_rate = 0):
        Item_base(book,sales_price),
        min_qty(qty),discount(disc_rate) {}

这个构造函数能够这样使用：

    Bulk_item bulk("0-201-82470-1",50,5,.19);

要建立bulk：

1）首先执行Item_base构造函数，该构造函数使用Bulk_item构造函数初始化列表来传递来的实參初始化isbn和price。

2）初始化Bulk_item的成员。

3）执行Bulk_item的构造函数（空）函数体。

【小结】

构造函数初始化列表为类的基类和成员提供初始值，它并不指定初始化的执行次序。首先初始化基类，然后依据声明次序初始化派生类的成员。

4、在派生类构造函数中使用默认实參

能够将这两个Bulk_item构造函数编写为一个接受默认实參的构造函数：

class Bulk_item:public Item_base
{
public:
    Bulk_item(const std::string &book = "",double sales_price = 0.0,
              std::size_t qty = 0,double disc_rate = 0):
        Item_base(book,sales_price),
        min_qty(qty),discount(disc_rate) {}
    //AS Before
};

5、仅仅能初始化直接基类

一个派生类类仅仅能初始化它自己的直接基类，直接基类就是在派生列表中指定的类。

能够设置一个折扣策略须要一个数量和一个折扣量,能够定义名为Disc_item的新类存储数量和折扣量,以支持这些依据购买量来打折的折扣策略。Disc_item类能够不定义net_price函数,但能够作为定义不同折扣策略的其它类(如Bulk_item类)的基类。

【关键概念：重构】

将Disc_item加到Item_base层次是重构的一个样例。重构包括又一次定义类层次，将操作和/或数据从一个类移到还有一个类。为了适应应用程序的须要而又一次设计类以便添加新的函数或处理其它改变时，最有可能须要进行重构。

重构在面向对象应用程序中很常见。值得注意的是：尽管改变了继承层次，使用Bulk_item或Item_base类的代码不须要改变。然而，对类进行重构，或以随意其它方式改变类，使用这些类的随意代码都必须又一次编译。

要实现这个设计：

1）首先须要定义Disc_item类：

class Disc_item : public Item_base
{
public:
    Disc_item(const std::string &book = "",
              double sales_price = 0.0,
              std::size_t qty = 0,
              double disc_rate = 0.0):
        Item_base(book,sales_price),quantity(qty),discount(disc_rate) {}

protected:
    std::size_t quantity;
    double discount;
};

2）其次，能够又一次实现Bulk_item以继承Disc_item，而不再是直接继承Item_base:

class Bulk_item : public Disc_item
{
public:
    Bulk_item(const std::string &book = "",
              double sales_price = 0.0,
              std::size_t qty = 0,
              double disc_rate = 0.0):
        Disc_item(book,sales_price,qty,disc_rate) {}

    //重定义根类的Item_base::net_price
    double net_price(std::size_t ) const;
};

如今，每一个Bulk_item对象有三个子对象：一个（空的）Bulk_item部分、一个Disc_item子对象，Disc_item子对象又有一个Item_base基类子对象。

由于派生类构造函数仅仅能初始化自己的直接基类，因此在Bulk_item类的构造函数初始化列表中指定Item_base是一个错误。

【关键概念：尊重基类接口】

构造函数仅仅能初始化其直接基类的原因是每一个类都定义了自己的接口。定义Disc_item时,通过定义它的构造函数指定了如何初始化Disc_item对象。一旦类定义了自己的接口,与该类对象的全部交互都应该通过该接口,即使对象是派生类对象的一部分也不例外。

相同,派生类构造函数不能初始化基类的成员且不应该对基类成员赋值。假设那些成员为 public或protected,派生构造函数能够在构造函数函数体中给基类成员赋值,可是,这样做会违反基类的接口。派生类应通过使用基类构造函数尊重基类的初始化意图,而不是在派生类构造函数函数体中对这些成员赋值。

//P493 习题15.14
class Item_base
{
public:
    Item_base(const std::string &book = "",
              double sales_price = 0.0):
        isbn(book),price(sales_price) {}

private:
    std::string isbn;
    double price;
};

class Bulk_item : public Item_base
{
public:
    Bulk_item(const std::string &book = "",
              double sales_price = 0.0,
              std::size_t qty = 0,
              double disc_rate = 0.0):
        Item_base(book,sales_price),
        min_qty(qty),discount(disc_rate) {}

private:
    std::size_t min_qty;
    double discount;
};

//习题15.16
//1)
struct C1 : public Base
{
    C1(int val):Base(val) {}
};

//2)
struct C2 : public C1
{
    C2(int val):C1(val) {}
};

//3)
struct C3 : public C1
{
    C3(int val):C1(val) {}
};

//4)
struct C4 : public Base
{
    C4(int val):Base(val) {};
};

//5)
struct C5 : public Base
{
    C5(int ival):Base(ival) {}
};