mooc程序设计与算法（三）第五周 继承和派生

继承和派生

概念：定义一个新的类B时，如果该类与某个已有的类A相似（指的是B拥有A的全部特点），那么，就可以把A作为一个基类，把B作为基类的一个派生类（也称子类）。

派生类是通过对基类进行修改和扩充得到的。在派生类中，可以扩充新的成员变量和成员函数。派生类拥有基类全部成员函数和成员变量。

在派生了的各个成员函数中，不能访问基类中的private成员

派生类对象的内存空间

派生类对象的体积，等于基类对象的体积，再加上派生类对象自己的成员变量的体积，在派生类对象中，包含着基类对象，而且基类对象的存储位置位于派生类对象新增的成员变量之前

继承关系和复合关系

继承：“是”的关系：基类A,B是基类A的派生类，逻辑上要求：B也是A

符合：“有”的关系：类C中有成员变量k,k是类D的对象，则C和D是复合关系，逻辑上要求：D对象是C对象的固有属性或组成部分。

派生类覆盖基类成员

派生类可以定义一个和基类成员同名的成员，这叫覆盖。在派生类中访问这类成员时，缺省的情况是访问派生类中定义的成员。要在派生类中访问由基类定义的同名成员时，要使用作用域符号：：。

一般来说，基类和派生类不定义同名成员变量

类的保护成员：protected，可以访问它的有：基类的成员函数，基类的友元函数，派生类的成员函数可以访问当前对象的基类的保护成员。

派生类中初始化基类，可以用初始化列表解决

#include <iostream>
using namespace std;
class Bug{
private:
    int nLegs;
    int nColor;
public:
    int nType;
    Bug(int legs, int color);
    void PrintBug(){cout<<"in Bug "<<nLegs<<" "<<nColor<<endl;}
};
Bug::Bug(int legs, int color) {
    nLegs = legs;
    nColor = color;
}
class FlyBug:public Bug{
private:
    int nWings;
public:
    FlyBug(int legs, int color, int wings);
};
FlyBug::FlyBug(int legs, int color, int wings) :Bug(legs, color){
    nWings = wings;
}
int main(){
    FlyBug f(4, 5, 8);
    f.PrintBug();
}

在创建派生类对象时，需要调用基类的构造函数：初始化派生类对象中从基类继承的成员。在执行一个派生类的构造函数之前，总数先执行基类的构造函数。

在派生类析够的时候， 需要先执行派生类的析够函数，然后自动调用基类的析够函数。实例如下：

#include <iostream>
using namespace std;
class Base{
public:
    int n;
    Base(int i):n(i){
        cout<<"base "<<n<<" constructed"<<endl;
    }
    ~Base(){
        cout<<"base "<<n<<" destructed"<<endl;
    }
};
class Dervied:public Base{
public:
    Dervied(int i):Base(i){
        cout<<"deriver constructed"<<endl;
    }
    ~Dervied(){
        cout<<"derived destructed"<<endl;
    }
};
int main()
{
    Dervied d(10);
    return 0;
}

base 10 constructed
deriver constructed
derived destructed
base 10 destructed

封闭派生类对象的构造函数执行顺序：

1、先执行基类的构造函数，用已初始化派生类对象中从基类继承的成员

2、再执行成员对象类的构造函数，用以初始化派生类对象中成员对象

3、最后执行派生类自己的构造函数

派生类消亡时:

1、先执行派生类自己的析够函数

2、再依次执行各成员对象类的析够函数

3、最后执行基类的析够函数

析够函数调用顺序与构造函数的调用顺序相反

public继承的赋值兼容规则

派生类的对象可以赋值给基类对象

派生类对象可以初始化基类引用

派生类对象的地址可以赋值给基类指针

#include <iostream>
using namespace std;
class Base{
public:
    int n;
    Base(int i):n(i){
        cout<<"Base "<<n<<" constructed"<<endl;
    }
    ~Base(){
        cout<<"Base "<<n<<" destructed"<<endl;
    }
};
class Derived:public Base{
public:
    Derived(int i):Base(i){
        cout<<"Derived constructed"<<endl;
    }
    ~Derived(){
        cout<<"Derived destructed"<<endl;
    }
};
class MoreDerived:public Derived{
public:
    MoreDerived():Derived(4){
        cout<<"More Derived constructed"<<endl;
    }
    ~MoreDerived(){
        cout<<"More Derived destructed"<<endl;
    }
};
int main()
{
    MoreDerived Obj;
    return 0;
}

Base 4 constructed
Derived constructed
More Derived constructed
More Derived destructed
Derived destructed
Base 4 destructed