重学C++ (十一) OOP面向对象编程(2)

转换与继承

本节主要需要区分的是：

• 基类和派生类的转换；

• 引用（指针）的转换和对象的转换。

1.每个派生类对象包含一个基类部分，因此，可以像使用基类对象一样在派生类对象上执行操作。基于这一点，可以将派生类对象的引用（指针）转换为基类子对象的引用（指针），且存在自动转换。

反之，基类到派生类的自动转换是不存在的，因此基类不包含派生类型的成员。另外，将基类指针或引用绑定到派生类对象时也存在限制，因为编译器编译时无法知道该转换是安全的（编译器确定转换是否合法，只看指针或引用的静态类型）。如果我们确定基类到派生类的转换是安全的，可以使用static_cast强制编译器进行转换，也可以用dynamic_cast申请在运行时进行检查。

2.引用转换不同于对象转换。在引用转换中，对象本身未被复制，转换不会在任何方面改变派生类型对象。在对象转换中（不是引用或指针），形参类型是固定的，将派生类对象传给基类对象形参时，该派生类对象的基类部分被【复制】到形参，这里是对基类对象进行初始化或赋值：初始化时调用构造函数，赋值时调用赋值操作符。（事实上，一般基类的复制构造函数和赋值操作符的形参是基类类型的const引用，因为存在从派生类引用到基类引用的转换，故这两个成员函数可用于从派生类对象到基类对象进行初始化或赋值）。

构造函数和复制控制

构造函数

例子1：

class Bulk_item: public Item_base
{
public:
    Bulk_item():min_qty(0), discount(0.0) {}
};

该构造函数隐式调用基类的默认构造函数初始化对象的基类部分：首先使用Item_base的默认构造函数初始化Item_base部分，之后再初始化Bulk_item部分的成员，并执行构造函数的函数体。

例子2：

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

该构造函数使用有两个形参的Item_base构造函数初始化基类子对象。

*首先初始化基类，然后根据【声明次序】初始化派生类的成员。

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

复制控制和继承

*只包含类类型或内置类型数据成员，不含指针的类一般可以使用合成操作，复制、复制或撤销这样的成员不需要特殊控制。

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

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

Base(d)将派生类对象d转换为它的基类部分的引用，并调用基类复制构造函数。

*如果忽略Base(d)，则将运行Base的【默认】构造函数初始化对象的基类部分——并不符合我们【复制】的本意。

*对于复制操作符，必须防止自身赋值！

Derived &Derived::oprator=(const Derived &rhs)
{
    if (this != &rhs)
    {
        Base::operator=(rhs); //assign the base part
        //assign the derived part
    }
    return *this;
}

派生类析构函数不负责撤销基类对象的成员，【编译器】总是【显式】调用派生类对象基类部分的析构函数。每个析构函数只负责清楚自己的成员：

class Derived: public Base
{
public:
    //Base::～Base() invoked automatically
    ～Derived() {/* 清理派生类部分的成员 */}
};

*对象的撤销顺序与构造顺序相反：先运行派生类析构函数，然后按继承层次依次向上调用个基类析构函数。

虚析构函数

要保证运行适当的析构函数，基类中的析构函数必须为虚函数：

class Item_base
{
    virtual ~Item_base() {}
};

Item_base *itemP = new Item_base;
delete itemP; //调用Item_base的析构函数
itemP = new Bulk_item; //指针的静态类型和动态类型不同
delete itemP; //调用Bulk_item的析构函数

在上述情况中，如果我们不定义虚析构函数，则第二个delete调用的将是Item_base的析构函数，这对于派生类型是未定义的行为。

*构造函数不能定义为虚函数；赋值操作符设为虚函数则可能会令人混淆，而且不会有什么用处。

构造函数和析构函数中的虚函数

首先需要明确：

构造派生类对象时先运行基类构造函数，此时对象的派生类部分是未初始化的。

撤销派生类对象时先撤销派生类部分。

在这两种情况下，对象都是不完整的。因此，在基类构造函数或析构函数中，编译器将派生类对象【以基类类型对象对待】。

如果在构造函数或析构函数中调用虚函数，运行的是构造函数或析构函数自身类型定义的版本。

理由：

如果从基类构造函数中调用虚函数的派生类版本，则派生类版本可能会调用派生类成员，而此时对象的派生部分成员还未初始化！该访问将可能导致程序崩溃。

继承情况下的类作用域

在继承情况下，派生类的作用域嵌套在基类作用域中。如果不能在派生类作用域中确定名字，就在外围基类作用域中查找该名字的定义。

与基类成员同名的派生类成员将屏蔽对基类成员的直接访问（可通过作用域操作符访问被屏蔽的基类成员）。

注意，对于函数，即使函数原型不同，只要名字相同，基类成员就会被屏蔽。

局部作用域中声明的函数不会重载全局作用域中定义的函数，同样，派生类中定义的函数也不重载基类中定义的成员。

因此，如果基类有以下函数：

int memfcn();

而派生类有以下函数：

int memfcn(int);

则对派生类调用memfcn()将报错，因此不存在对基类函数的重载，基类中的memfcn()被屏蔽。

这也解释了虚函数为什么必须在基类和派生类中拥有同一原型。

看下面代码：

class Base
{
public:
    virtual int fcn();
};

class D1: public Base
{
public:
    int fcn(int); //屏蔽基类的fcn()
};

class D2: public D1
{
public:
    int fcn(int); //非虚函数，屏蔽D1的fcn(int)
    int fcn(); //虚函数，重写基类的fcn()
};

Base bobj;
D1 d1obj;
D2 d2obj;
Base *bp1 = &bobj, *bp2 = &d1obj, *bp3 = &d2obj;
bp1->fcn(); //call Base::fcn at run time
bp2->fcn(); //call Base::fcn at run time
bp3->fcn(); //call D2::fcn at run time

三个指针都是基类类型的指针，故通过在Base中查找fcn确定这三个调用。由于fcn是虚函数，所以编译器会生成代码，在运行时基于引用或指针所绑定的实际类型进行调用。

纯虚函数

在函数形参表后面写上=0指定纯虚函数：

double fcn(std::size_t) const = 0;

含有一个或多个纯虚函数的类是抽象基类，除了作为抽象基类的派生类的对象的组成部分，不能创建抽象类型的对象。

容器与继承

假设一个容器存放的是基类类型的对象，当插入一个派生类对象时，会将派生类对象的基类部分【复制】到基类对象并保存在容器中（因此派生类部分将被切掉，也就是说容器里的只能是基类对象，而不是派生类对象）。

一个解决方案是，使用容器保存对象的指针。