重学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:
    virtualintfcn();
};

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

class D2: public D1
{
public:
    intfcn(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;
            

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

容器与继承

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

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