继承

  • 继承是类中成员的复用。
  • 有元关系无奈被继承。

继承的定义和应用办法

  • 下列父类成员 pri 为private，所以子类无法访问。其余成员子类皆可拜访。
  • 下列子类以protected 形式继承父类，所以子类的对象对父类的拜访权限最高为protected。
  • 父类中成员函数 Print() 为public，然而子类继承形式为 protected，所以子类对象对 Print()的拜访权限为 protected，无法访问。
class Person    //父类{public:    void Print()    {        cout << "name：" << _name << endl;        cout << "age：" << _age << endl;    }protected:    string _name = "bjf";    int _age = 18;    private:    int pri = 5;};class Student :protected Person   //继承Person类，子类 public:    void test()    {        cout << _name << endl;        cout << _age << endl;        Print();    }private:    int code;};int main(){    Student xiaoming;    xiaoming.test();    return 0;}
  • 继承形式只决定子类的对象对父类成员的最高拜访权限（最低权限取决于成员自身的权限），不影响子类对父类的拜访权限。
  • 子类能够拜访父类的所有成员，除了公有成员（只是不能拜访公有成员，然而子类依然继承了的）
  • class默认的继承形式是private，struct默认继承形式是pubilc。

类对象间的赋值规定

  • 能够将子类对象赋值给父类对象。（父类对象不能赋值子类对象）
int main(){    Student bjf;    Person  man;    man = bjf;  //用子类对象赋值父类的对象，只将子类中继承的父类成员赋值过来，而子类本人的成员不论    Person* woman = &bjf;  //woman指针，只代表bjf中的父类成员。    return 0;}

继承中的作用域（对于暗藏）

  • 在继承的体系中，父类和子类有独立的作用域。
  • 如果父类和子类有同名成员，则须要表明该成员属于哪个类，否则会依据就近准则默认是子类的成员。（子类成员屏蔽了父类成员的间接拜访，这就是暗藏）
  • 留神：如果是同名成员函数，这个也是暗藏，须要指明属于哪个类（这个不是函数重载）
class Person{public:    int mun = 10;};class Student :public Person   //继承Person类 {public:    void test()    {        cout << mun << endl;  //输入为 5，就近准则        cout << Person::mun << endl;  //输入为 10        }    int mun = 5;};int main(){    Student xiaoming;    xiaoming.test();    return 0;}

父类成员变量的初始化

  • 子类对父类成员变量的初始化，必须调用父类的构造函数进行初始化。

  • 留神：

    • 子类对象初始化时，是先初始化父类成员，再初始化子类成员。
    • 在程序完结主动调用析构函数时，实践上是先调用子类的析构函数而后调用父类的析构函数（栈先进后出），然而编译器在这个前默认调用类一次父类的析构函数
    • 所以，理论的析构程序是 父类析构—子类析构—父类析构（父类析构被调用两次）

  • 留神：父类的析构函数和子类的析构函数，他们函数名不同，然而依然会触发暗藏

    • 因为在编译器中，任何类的析构函数都会被对立解决成 destructor()。
class Person{public:    Person(int b)        :_mun(b)    {}protected:    int _mun;};class Student :public Person   //继承Person类 （student是子类，Person是父类）{public:    Student(int a, int b)        :_mun(a)        , Person(b)  //调用父类的构造函数    {    }    void test()    {        cout << _mun << endl;  //输入为 7，就近准则        cout << Person::_mun << endl;  //输入为 8        }protected:    int _mun;};int main(){    Student xiaoming(7, 8);    xiaoming.test();    return 0;}

多继承

  • 多继承：一个子类有多个间接父类。

菱形继承

  • 菱形继承会呈现数据冗余问题，即man类中继承了两份 Person 的成员。
  • 并且会呈现二义性，即应用Person中成员时，无奈确认是应用的Student的还是Teacher的。

  • 虚继承能够很好的解决这个问题（virtual）

    • 在两头类的继承中加上virtual，子类在继承两头类时，只会继承一份Person类。

继承与组合

  • 继承：子类继承父类的成员，子类能够复用父类
  • 组合：子类中创立父类的对象，子类能够根据这个父类对象应用父类的私有成员
  • 倡议尽量应用组合。
class Person{}class Student{    Person man;   //建设父类的对象，依附这个对象应用父类成员。}