C++之继承

继承

1. 继承和派生
2. 继承方式
3. 多继承
4. 菱形继承

继承和派生

继承的概念

继承是一种创建新类的方式，新建的类可以继承一个或多个类。可以理解为现实生活中继承，儿子继承了父亲的资产。
所以，继承描述的是类与类之间的关系。
新建的类称为派生(子)类，之前存在的类称为基(父)类

继承和派生

继承与派生是同一过程从不同的角度来看。
一个新类从已有类那里获得其已有特性，为继承。
从已有类产生一个新的子类，为派生。

继承的分类

新建类继承一个类时称为单继承。
新建类继承多个类时称为多继承。

继承时派生类的定义

class 派生类名 : 继承方式1 基类名1, 继承方式2 基类名2,…
{
类成员声明;
};

派生类的构成

1. 吸收基类成员
   派生类拥有基类的除构造和析构函数之外的所有成员变量和成员函数。
2. 改造基类成员
   派生类声明一个和基类成员同名的新成员，派生的新成员就隐藏了外层同名成
   员。
3. 添加新的成员
   派生类增加新成员使派生类在功能上有所发展。

派生类和基类的关系

派生类是基类对象，但基类对象不是派生类对象。
派生类 派生对象名；
基类 基类对象名；
基类对象名 = 派生对象名；//允许
派生对象名 = 基类对象名；//错误

派生类的构造顺序

派生类对象在实例化的时候是会调用基类的构造函数的，先构造父基类，然后构造派生类，析构是先释放派生类，然后释放基类。
析构顺序和构造顺序完全相反，是因为栈结构的关系。

派生类在构造基类时，会调用基类的构造函数，如果基类的构造函数需要参数，需要在派生类的构造函数后面加上初始化列表来实现基类的带参构造。

继承方式

派生类继承基类的方式和类中的访问属性一样有三种。
1. public 共有
2. proteted 保护
3. private 私有
不同的继承方式表示派生类吸收完基类成员之后，通过派生类对象去访问时，这些成员的访问方式。

派生类继承基类的方式导致成员的访问权限

1. 基类的私有成员，不管用什么方式继承，都不能被访问。
2. 其他成员的访问属性和继承方式两者看谁更严格就按严格的属性来控制。
   

多继承

一个派生类有多个基类，叫多继承。

多继承中派生类的构造

与单继承中构造顺序一致，区别在于，在构造基类时有多个基类，那么会按照基类的声明顺序来依次调用基类的构造函数。

继承中同名的处理

子类.父类::成员；

1. 在父类和子类有同名的成员时，如果直接调用，调用的是子类自己的成员，要想访问父类的成员就要用上面的方式，同名的情况下，子类不能直接访问父类的成员。
2. 有多个父类都有和子类有同名的成员，如果出现了这种情况，我们也是需要在调用的时候明确说明调用的是哪个成员。

菱形继承

继承结构如上图，类B继承类A，类C继承类A，类D继承类B，类C。这样继承就会导致类D对象中会有2个类A对象，想要访问类A的成员，会导致基类类A不明确。
在A类中如果有一个成员A,那么在B和C也同样会继承过来，D会直接继承B，C中的成员，也就间接继承了A中成员，导致出现两个类A，就会产生类似同名的问题，在D对象中如果调用A中成员，那么调用就会不明确不知道调用哪个A中的成员。

解决方法

1. 通过类名：：成员名来控制调用哪个成员。
2. 通过虚继承，在继承的前面加上关键字virtual 。这样B和C就是通过一个指针去访问A的成员，D只会继承一份A，就不会有这个访问问题了。

练习代码

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
protected:
    int a;
private:
    int b;
public:
    int c;
    Father(int a)
    {
        this->a = a;
        b = 20;
        c = 30;
        cout << "Father的带参构造" << endl;
    }
    ~Father()
    {
        cout << "Father的析构" << endl;
    }
};

class Son:public Father
{
private:

public:
    void fun()
    {
        cout << a << endl;
    }
    int d;
    Son(int d):Father(10)
    {
        this->d = d;
        cout << "Son的带参构造" << endl;
    }
    ~Son()
    {
        cout << "Son的析构" << endl;
    }
};

class A {


//子类(public继承),子类中父类的private内不可以访问,类外也不可访问
//子类(protected继承),子类中父类的private内不可以访问,类外也不可访问
//子类(private继承),子类中父类的private内不可以访问,类外也不可访问
private:
    int a;

 //子类(public继承),子类中父类的子类中protected的内可以访问,类外不可访问
//子类(protected继承),子类中父类的子类中protected的内可以访问,类外不可访问
//子类(private继承),子类中父类的protected内可以访问,类外也不可访问
protected:
    int b;

//子类(public继承),子类中父类的子类中public内的可以访问,类外可访问
//子类(protected继承),子类中父类的子类中public内的可以访问,类外可访问
//子类(private继承),子类中父类的子类中public内的可以访问,类外可访问
public:
    int c;
    A(int a, int b, int c)
    {
        this->a = a;
        this->b = b;
        this->c = c;
    }
    void setb(int b)
    {
        this->b = b;
    }
    void seta(int a)
    {
        this->a = a;
    }
};
class B:private A
{
protected:
    int d;
private:
    int e;
public:
    B(int d, int e) :A(1, 2, 3) //父类构造函数可在子类构造函数进行初始化列表初始化
    {
        this->d = d;
        this->e = e;
    }
    void fun()
    {
        cout << b << endl;
    }
};

//多继承
class C :public A, public B
{
public:
    C() :A(1, 2, 3), B(4, 5)
    {
        cout << A::b << endl;
        cout << A::c << endl;
        cout << B::d << endl;
    }
};
int main()
{
    //Son s(1);
    //cout << s.c<< endl;
    B b(1,2);
    b.fun();

    C c;
    system("pause");
    return 0;
}