C++继承

继承引出

　　继承主要是为了减少代码的重复内容，解决代码复用问题。通过抽象出一个基类（父类），将重复代码写到基类中，在派生类（子类）中实现不同的方法。

　　语法： class 子类：继承方式 父类

class News{
public:
    void header(){
        cout << "头部" << endl;
    }

    void footer(){
        cout << "底部" << endl;
    }

    void mynew(){
        cout << "今日新闻" << endl;
    }
};

class Entertain{
public:
    void header(){
        cout << "头部" << endl;
    }

    void footer(){
        cout << "底部" << endl;
    }

    void mynEntertain(){
        cout << "娱乐" << endl;
    }
};

//其中两个类中的代码有重复
void test00(){
    News mynews;
    Entertain myEnters;
}

//使用继承
class BasePage{
public:
    void header(){
        cout << "头部" << endl;
    }

    void footer(){
        cout << "底部" << endl;
    }
};

class SonNew:public BasePage{
public:
    void mynew(){
        cout << "今日新闻" << endl;
    }
};

class  SonEntertain :public BasePage{
public:
    void mynEntertain(){
        cout << "娱乐" << endl;
    }
};

void test01(){
    SonNew mynews;
    SonEntertain myEnters;
}

继承方式

　　继承方式有公有继承，私有继承，保护继承。

　　（1）公有继承：保持父类中的访问属性；

　　（2）私有继承：将父类中的所有访问属性改为private；

　　（3）保护继承：除父类中的私有属性，其他改为保护属性。

继承中的对象模型

　　子类中会继承父类的私有成员，只是被编译器隐藏起来了，无法访问到，通过sizeof(子类class)可以检查出。

class Base{
public:
    int m_A;
    float m_B;

private:
    double m_C;
};

class Son:public Base{
public:
    int m_D;
};

void test01(){
    cout << sizeof(Son) << endl; //24，由于字节对齐 4*6
}

　　另外也可以通过开发人员命令提示工具进行查看类布局。

 cl /d1 reportSingleClassLayoutSon heap.cpp 

继承中的构造和析构

　　（1）子类创建对象时，先调用父类的构造函数，然后再调用自身的构造，析构顺序与构造顺序相反；

　　（2）子类会继承父类的成员属性和成员函数，但子类不会继承父类构造函数和析构函数；

　　注意：由于继承中父类和子类的构造、析构顺序原因，当父类中只提供了有参构造时（默认构造等函数会被隐藏），子类仅仅调用默认构造时，会因为子类创建对象时无法调用父类构造函数而报错，这里可以让子类利用初始化列表来显式调用父类有参构造函数来进行父类构造，然后进行子类构造。

class Base{
public:
    Base(){
        cout << "默认构造函数" << endl;
    }
    ~Base(){
        cout << "默认析构函数" << endl;
    }
};
class Son :public Base{
public:
    Son(){
        cout << "子类默认构造函数" << endl;
    }

    ~Son(){
        cout << "子类默认析构函数" << endl;
    }
};

class Base1{
public:
    Base1(int a){
        cout << "默认构造函数" << endl;
    }
    ~Base1(){
        cout << "默认析构函数" << endl;
    }
};

class Son1 :public Base1{
public:

    //会报错，Base1不存在默认构造函数
    //Son1(){
    //    cout << "子类默认构造函数" << endl;
    //}

    //初始化列表显式调用父类有参构造函数
    Son1(int a):Base1(a){
        cout << "子类默认构造函数" << endl;
    }

    ~Son1(){
        cout << "子类默认析构函数" << endl;
    }
};

void test01(){
    Son son;
}

继承中的同名处理

　　（1）父类和子类成员属性同名，用子类声明对象调用子类属性，若想调用父类成员，则加上父类的作用域；

　　（2）父类和子类成员函数同名，子类函数不会覆盖父类的成员，只是隐藏起来，用子类声明对象调用子类成员函数，若想调用父类函数（包括重载），则加上父类的作用域；

　　（3）若子类中没有与父类同名的成员函数，子类声明对象后，可以直接调用父类成员函数。

class Base{
public:

    void myfun(){
        cout << "父类成员函数" << endl;
    }
    void myfun(int a){
        cout << "父类成员函数" << endl;
    }
};

class Son :public Base{
public:

    void myfun(){
        cout << "子类成员函数" << endl;
    }
};


void test01(){
    Son son;
    son.myfun();
    son.Base::myfun();

    son.myfun(10); //报错
    son.Base::myfun(10); //必须加作用域
}

继承中静态成员处理

 　　同名成员和非静态成员基本一致，同样可以被子类继承，但静态成员可以通过类名直接访问，不需要创建对象。

多继承

　　多继承会产生二义性的问题。如果继承的多个父类中有同名的成员属性和成员函数，在子类调用时，需要指定作用域从而确定父类。

class Base{
public:

    void myfun(){
        cout << "父类成员函数" << endl;
    }
};

class Base1{
public:

    void myfun(){
        cout << "父类成员函数" << endl;
    }
};



class Son :public Base, private Base1{
public:

    void myfun1(){
        cout << "子类成员函数" << endl;
    }
};


void test01(){
    Son son;

    //son.myfun(); //指定不明确

    //son.Base1::myfun();//Base1为私有成员变量，无法访问
    son.Base::myfun();
}

菱形继承

 　　两个子类继承于同一个父类，同时又有另外一个类多继承于两个子类，这种继承称为菱形继承。比如羊和驼继承于动物类，同时羊驼继承于羊和驼。

　　菱形继承会产生两个问题：

　　（1）羊和驼都继承了动物类的数据和函数，因此羊驼调用数据和函数时，会出现二义性。虽然可以通过作用域确定父类，但我们想要一个数据；

　　（2）羊驼继承了两份动物类中的某些数据和函数，但只需要一份即可。

class Animal{
public:
    int m_Age;
};

class Sheep:public Animal{

};

class Camel :public Animal{

};


class Son :public Sheep, public Camel{

};


void test01(){

    //子类会继承父类的成员属性，但两者之间不会相互修改
    //比如修改sheep不会修改到animal的age属性
    Animal animal;
    animal.m_Age = 30;
    
    Sheep sheep;
    sheep.m_Age = 40;

    //Son为多继承，多继承会产生二义性
    //虽然可以通过作用域来确定父类，但我们想要的是一份数据
    Son son;
    son.Sheep::m_Age = 10;
    son.Camel::m_Age = 20;

    cout << animal.m_Age << endl;
    cout << son.Sheep::m_Age << endl;
    cout << son.Camel::m_Age << endl;
}

　　对上述代码通过工具查看Son类布局，如下所示：

　　布局显示Son继承Sheep父类，父类继承祖父类，祖父类中有成员属性m_Age；同样Son继承Camel父类，父类继承祖父类，祖父类中有成员属性m_Age，左侧的0和4表示类Son相对地址，即Son的起始地址和Sheep中的m_Age地址为0，加上偏移量4，指向了类内地址为4的Camle的m_Age，Son中包含了两个int类型，大小为8。

　　菱形继承问题解决：使用虚继承，这样操作的是共享的一份数据，在继承方式前加virtual，这样的话Son类可以直接访问m_Age，不用添加作用域。

class Animal{
public:
    int m_Age;
};

class Sheep:virtual public Animal{

};

class Camel :virtual public Animal{

};


class Son :public Sheep, public Camel{

};

void test01(){
    Son son;

    son.m_Age = 10;
}

 　　利用开发者工具对虚继承的代码查看Son类布局，如下所示：

　　布局显示Son继承Sheep父类，父类中有虚指针vbptr(virtual base pointer)，对象结构类似结构体，首元素是虚基类指针，其余为自身数据（不包括静态成员和成员函数）（具体详见C++多态之内存中对象的数据结构）；同样Son继承Camel父类，父类中有虚指针vbptr(virtual base pointer)，左侧的0、4、8同样表示类内相对地址，Son的起始地址和Sheep的虚指针地址为0，Camel的虚指针地址为4，Animal中的m_Age为8。

　　Sheep父类的虚指针指向下面Sheep的虚基类表vbtale@Sheep(virtual base table)，虚基类表是一个整型数组，数组第二个元素值为8，即Sheep的虚指针地址偏移8指向Animal的m_Age地址。Camel父类同理，因此，类中只有一个m_Age元素。

　　Son中包含了两个指针和一个int类型，所以大小为12。

虚继承工作原理

　　通过虚基类表的地址索引输出虚基类指针的偏移量及虚基类数据，对照上图虚基类指针和虚基类表，访问虚基类的偏移量：

　　(1) &son 表示对son取地址，也表示父类Sheep虚基类指针的地址，也表示Sheep虚基类表（整型数组）的地址

　　(2) (int*)&son 对地址进行强转，&son的类型为class son*,转为整型指针

　　(3) *(int*)&son 对地址解引用，返回整型数组的首地址，也是第一个元素的地址，为整型类型

　　(4) *(int*)&son + 1 为第二个元素的地址，偏移量为一个int类型

　　(5) (int*)*(int*)&son + 1对一个地址进行解引用，需要先将其转化为对应元素的指针类型，这里为整型指针类型

　　(6) 对上述地址进行解引用，访问偏移量

　　(7) (int*)&son + 1 访问tuo的偏移量时，需要先指向tuo的虚基类指针，因此需要加偏移量，这里的1表示偏移一个整型字节

　　补充(7),如果m_Age不是int类型，而是double类型，此时偏移量为一个double

class Animal{
public:
    int m_Age;
    //double m_Age;
};

class Sheep:virtual public Animal{

};

class Camel :virtual public Animal{

};


class Son :public Sheep, public Camel{

};

void test01(){
    Son son;
    int *a;
    son.m_Age = 10;
    
    //----------------------访问虚基类的偏移量----------------------
    //(1) &son 表示对son取地址，也表示父类Sheep虚基类指针的地址，也表示Sheep虚基类表（整型数组）的地址
    //(2) (int*)&son 对地址进行强转，&son的类型为class son*,转为整型指针
    //(3) *(int*)&son 对地址解引用，返回整型数组的首地址，也是第一个元素的地址，为整型类型
    //(4) *(int*)&son + 1 为第二个元素的地址，偏移量为一个int类型
    //(5) (int*)*(int*)&son + 1对一个地址进行解引用，需要先将其转化为对应元素的指针类型，这里为整型指针类型
    //(6) 对上述地址进行解引用，访问偏移量
    //(7) (int*)&son + 1 访问tuo的偏移量时，需要先指向tuo的虚基类指针，因此需要加偏移量，这里的1表示偏移一个整型字节
    //补充(7),如果m_Age不是int类型，而是double类型，此时偏移量为一个double，


    cout << typeid(son.m_Age).name() << endl;
    cout << typeid(&son).name() << endl;
    cout << typeid(*(int*)&son).name() << endl;
    cout << typeid((*(int*)&son) + 1).name() << endl;
    cout << typeid(*((int*)&son + 2)).name() << endl;
    cout << "--------------------" << endl;
    cout << *(int*)((int*)*(int*)&son + 1) << endl; //访问sheep的偏移量
    cout << *((int*)*(int*)&son + 1) << endl; //访问sheep的偏移量

    cout << *((int*)*((int*)&son + 2) + 1) << endl;//访问tuo的偏移量
    cout << *(int*)((int*)*((int*)&son + 2) + 1) << endl;//访问tuo的偏移量
    

    //----------------------访问m_Age----------------------
    //&son 表示对son取地址，将其转为char型，加8表示要偏移8个字节，若为int型，加8表示偏移32字节
    //取son的地址，加上偏移量，转到animal的m_Age地址处，需要强转为Animal *
    //取->进行间接访问
    cout << ((Animal*)((char*)&son + *(int*)((int*)*(int*)&son + 1)))->m_Age << endl;
}