C++继承简单介绍

继承概念

继承是C++具有代表性的一个特性，是面向对象设计是代码可以复用的重要手段，并且允许在保持原有类特性的基础上扩展，增加功能，这种类一般叫做子类或派生类。继承是类设计层次的复用。

在生活中会有很多相似性，比如在学校中，老师和学生，用类在描述这两个身份时，首先这个两个类如果各自描述各自的，那么就会显得代码冗余，比如，我们可以将名字、性别、年龄等一些必备信息再用一个类封装，让老师和同学这两个身份复用同一个类。这样大大的减少了代码量。如下：

//父类或基类
class Person
{
public:
    void Print()
    {
        cout << "name: " << _name << endl;
        cout << "age: " << _age << endl;
    }
protected:
    string _name = "Perter";
    int _age = 18;
};

//子类或派生类
class Student : public Person  //学生
{
protected:
    int _sid;
};
class Teacher : public Person  //老师
{
protected:
    int _tid;
};
void Test()
{
    Student s; //创建一个学生对象
    Teacher t; //创建一个老师对象
}

继承定义

下图我们看到的Person是父类/基类，Student 是子类/派生类，public是继承方式，我们知道访问限定符有三种，分别是public、protected、private，那么对于父类有三种，子类有三种，那么就会有9种成员访问方式

继承基类成员访问方式的变化

类成员/继承方式	public继承	protected继承	private继承
父类的public成员	子类public	子类protected	子类private
父类的protected成员	子类protected	子类protected	子类private
父类的private成员	子类不可见	子类不可见	子类不可见

总结以上：

1. 对于父类是private成员无论是什么继承方式在子类对象中存在，但不可访问(类外类内均不可访问)

2. 对于protected和public成员，会根据继承方式选择子类成员限制，如基类中是public继承方式是public那么子类就是public，如果是protected那么就是protected，根据访问权限的大小来决定。其中public > protected > private

3. 继承方式也可不写，对于class默认私有继承，而struck默认公有继承

补充：protected和private的区别

在假设public继承时，基类的protected成员在子类中是可以访问的，而private成员不可访问

class Person
{
protected:
    string _name = "Perter";
private:
    int _age = 18;
};
class Student : public Person
{
public:
    void Print()
    {
        cout << "name: " << _name << endl;
        //下面的访问是错误的
        cout << "age: " << _age << endl; 
    }
protected:
    int _sid;
};

父类和子类对象赋值转换

子类对象可以直接赋值给父类的对象/父类的指针/父类的引用。这种方式有个形象的说法是切片或切割，寓意将子类中父类的那部分切来赋值过去。

注意：

父类对象不能赋值给子类对象

class Person
{
protected:
    string _name;
    string _sex;
    int _age;
};

class Student : public Person
{
public:
    int _id;
};

void Test()
{
    Student s;
    //以下需要注意的点是，这个中间过程不产生临时变量
    //这里是直接将父类那部分切割过去
    Person p = s;
    Person* ptr = &s;
    Person& rp = s;

    int i = 2;
    double d = 2.0;
    //此时产生临时变量，临时变量具有常属性
    double& rb = i;//错误
    const double& rb = i;//正确

}

继承中的作用域

父类子类存在相同名称的成员变量

class Person
{
public:
    void Print()
    {
        cout << "Student: " << _num << endl;
    }
protected:
    int _num = 0;
};

class Student : public Person
{
protected:
    int _num = 1;
};

void Test()
{
    Student s;
    s.Print(); // 0

    Person p;
    p.Print(); //0
}
//若Print函数存在子类中，则父类不能调用Print函数
//子类输出结果为1

父类子类存在相同名称的成员函数

若存在相同名称的成员函数，那么这两个函数就构成隐藏关系，若要访问父类同名的函数必须指定作用域。否则默认访问子类同名函数

重定义(隐藏)：子类和父类函数名字相同就构成隐藏

class A
{
public:
    void fun()
    {
        cout << "A::func()" << endl;
    }
};
class B : public A
{
public:
    void fun()
    {
        cout << "B::func()->" << endl;
    }
};

void Test()
{
    B b;
    b.A::fun();//若不加访问限定符的话，此时默认访问子类的fun函数
    //此时父类的fun函数被隐藏
}

子类的默认成员函数

我们知道C++中的六个默认成员函数，其中四个最为重要分别是构造函数、析构函数、拷贝构造和赋值，它们分别针对内置类型和自定义类型有着不同的要求。

在继承的子类中，也有它的规则

构造函数：子类中属于父类的那部分必须调用父类的构造函数，如果父类没有默认构造函数，则必须在子类构造函数的初始化列表阶段显示调用。

class A
{
public:
    A()
        :_num(0)
    {
        cout << "A()" << endl;
    }
protected:
    int _num;
};
class B : public A
{
public:
    B(int cnt = 0)
        :_cnt(cnt)
        ,A()//这个地方也可不写，因为父类有默认构造
    {}
protected:
    int _cnt;
};

void Test()
{
    B b;
}

拷贝构造：子类的拷贝构造会调用父类的拷贝构造来完成父类的拷贝构造

class A
{
public:
    A(const A& a)
    {
        _num = a._num;
    }
protected:
    int _num;
};
class B : public A
{
public:
    B(const B& b)
        :A(b) //用b去作为传参会发生切片
    {
        _cnt = b._cnt;
    }
protected:
    int _cnt;
};

void Test()
{
    B b1;
    B b2 = b1;
}

赋值：子类属于父类那部分依然调用父类的operator=来完成，但是这里会有一个问题，就是父类和子类的operator=两个函数名相同，因此构成隐藏关系，必须指定作用域赋值

class A
{
public:
    A& operator= (const A& a)
    {
        if (this != &a)
        {
            _num = a._num;
        }
        return *this;
    }
protected:
    int _num;
};
class B : public A
{
public:
    B& operator= (const B& b)
    {
        if (this != &b)
        {
            A::operator=(b);//这个地方必须指定域
            _cnt = b._cnt;
        }
        return *this;
    }
protected:
    int _cnt;
};

void Test()
{
    B b1(1);
    B b2(2);
    b1 = b2;
}

析构函数：析构函数是特殊的一个

首先析构函数不能显示的去调用，因为子类的析构函数和父类的析构函数会构成隐藏关系（原因：由于多态关系的需求，所有析构函数都会特殊处理成destructor函数名）

其次子类析构函数会自动调用父类析构函数

class A
{
public:
    ~A()
    {
        cout << "~A()" << endl;
    }
protected:
    int _num;
};
class B : public A
{
public:
    ~B()
    {
        cout << "~B()" << endl;
    }
protected:
    int _cnt;
};
void Test()
{
    B b; //输出结果： A() B() ~B() ~A()
}

补充：

子类对象初始化先调用父类构造再调用子类构造

子类对象析构清理先调用子类析构再调用父类析构

友元、静态成员与继承

结论一：友元关系不不能被继承，也就是说父类的友元不能访问子类私有和保护成员

结论二：父类若定义了静态成员，则整个继承体系中只有一个这样的成员，无论派生出多少个子类，都是只有一个static成员实例

多继承与菱形继承及菱形虚拟继承

单继承：一个子类只有一个直接父类时成这个继承关系为单继承

多继承：一个子类有两个或以上直接父类时成这个继承关系为多继承

菱形继承：菱形继承是多继承的一种特殊情况

class A
{
public:
    int _a;
};

class B : public A
{
public:
    int _b;
};

class C : public A
{
public:
    int _c;
};

class D : public B, public C
{
public:
    int _d;
};

菱形继承存在的问题：菱形继承存在数据冗余和二义性的问题。

数据冗余：下图继承中C中已经存在A类，且B中也存在A类，它两同时给D那么D类中就有两份A

二义性：在D中去调用A时，不知是B的A还是C的A

void Test()
{
    D d;
    d._a = 1; //这里就会造成二义性
}

解决办法：采用虚拟继承可以解决菱形继承数据冗余和二义性的问题，只需在B,C继承时加上virtual关键字。

class A
{
public:
    int _a;
};
class B : virtual public A
{
public:
    int _b;
};

class C : virtual public A
{
public:
    int _c;
};

class D : public B, public C
{
public:
    int _d;
};

我们调查内存串口先观察不用虚继承的时候，如下图

再观察用虚继承，如下图

我们发现B中不但有4还包括了一个地址C中也是一样，我们再调用两个窗口查看这两个地址存放的是什么

我们可以计算出刚好B的地址加上20就是A的地址，而C的地址加上12就是A的地址，说明在B中保存了A的偏移量，C中也保存了A的偏移量

原因：

此时B、C、D的A是属于同一个，因为A的地址不知道，如果要去分别通过B、C去找A，通过各自的地址加上存储的偏移量能够更加准确的找到找到虚基类A。

void Test()
{
    B b;
    B* pb = &b;
    pb->_a = 10;

    D d;
    D* pd = &d;
    pd->_a = 20;
}

如上代码，有b对象和指针pb刚开始pb指向的a去更改，在用一个d对象切片赋值给pb去更改a，这两个代码都去更改了a，分别通过各自去计算A的地址