关于c++:C继承

继承

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

继承的定义和应用办法

• 下列父类成员 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;   // 建设父类的对象，依附这个对象应用父类成员。}