class学习（七）菱形继承，多态

1.菱形继承

        一个父亲，两个儿子，一个孙子又去继承这两个儿子

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
class Animal
{
public:
    int m_Age;
};
class Sheep:public Animal{};
class Tuo :public Animal{};
class SheepTuo:public Sheep,public Tuo{};
void test01()
{
    SheepTuo st;
    st.Sheep::m_Age=18;
    st.Tuo::m_Age=28;
    cout<<st.Sheep::m_Age<<endl;
    cout<<st.Tuo::m_Age<<endl;
}
int main()
{
    test01();
	return 0;
}

年龄这个数据其实有一个就够了

2.解决菱形继承中数据重复继承问题  虚继承：加virtual即可，

       

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
class Animal
{
public:
    int m_Age;
};
class Sheep: virtual public Animal{};
class Tuo :virtual public Animal{};
class SheepTuo:public Sheep,public Tuo{};
void test01()
{
    SheepTuo st;
    st.Sheep::m_Age=18;
    st.Tuo::m_Age=28;
    cout<<st.Sheep::m_Age<<endl;
    cout<<st.Tuo::m_Age<<endl;
    cout<<st.m_Age<<endl;
}
int main()
{
    test01();
	return 0;
}

使用开发人员命令提示工具发现SheepTuo中继承的m_age只有一份，

即从Sheep和Tuo继承下来的是vbptr virtual base pointer 虚基类指针会指向vbtable虚基类表,

而vbtable中记录的是偏移量，而Sheep和Tuo继承下来的是vbptr加上各自的偏移量均指向那同一个m_age

3.多态 分为两类：

        静态多态：函数重载 和 运算符重载 属于静态多态，复用函数名

        动态多态：派生类和虚函数实现运行时多态

        动态多态满足条件：

        1、有继承关系

        2、子类重写父类虚函数

        动态多态使用：

        父类的指针或者引用执行子类对象

        Animal *a=new Cat;

  二者区别：

        静态多态的函数地址早绑定：编译阶段确定函数地址，即不论你传进来的是猫还是狗，都会走猫动物的speak函数。

        动态多态的函数地址晚绑定：运行阶段确定函数地址

原来：

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
class Animal
{
public:
    void speak()
    {
        cout<<"动物在说话"<<endl;
    }
};
class Cat:public Animal
{
public:
    void speak()
    {
        cout<<"小猫在说话"<<endl;
    }
};
void dospeak(Animal &animal)
{
    animal.speak();
}
void test01()
{
    Cat cat;
    dospeak(cat);
}
int main()
{
    test01();
	return 0;
}

 改后：

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
class Animal
{
public:
    virtual void speak()  //父类必须加virtual关键字    本质是此时Animal结构改变，sizeof(Animal)不再为1，而是4。即里面是一个vfptrx虚函数(表)指针，指向vftable虚函数表，表内部记录虚函数地址：&Animal::speak
    {
        cout<<"动物在说话"<<endl;
    }
};
class Cat:public Animal
{
public:
    void speak()  重写：函数返回值类型、函数名、参数列表 完全相同，前面加不加virtual均可
    {
        cout<<"小猫在说话"<<endl;
    }
    //如果不重写，则子类中vftable为&Animal::speak，重写则覆盖为&Cat::speak
};
void dospeak(Animal &animal)  //Animal &animal=cat
{
    animal.speak();
}
void test01()
{
    Cat cat;
    dospeak(cat);
}
int main()
{
    test01();
	return 0;
}

 每个类都有自己的虚函数表，里面存它的虚函数地址，当子类继承时会把父类的虚函数表一模一样的复制下来做自己的虚函数表但你重写子类的虚函数后，你相当于不要从父类中继承下来的那个虚函数表里，会新写一份覆盖它

4.纯虚函数  通常父类中虚函数无意义，所以写成纯虚函数

当类中有了纯虚函数，这个类也称为抽象类

抽象类特点：

• 无法实例化对象
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
class Animal
{
public:
    virtual void speak()=0;
};
class Cat:public Animal
{
public:
    void speak()
    {
        cout<<"!!!"<<endl;
    }
};
void dospeak(Animal &animal)  //Animal &animal=cat
{
    animal.speak();
}
void test01()
{
    Cat cat;
    dospeak(cat);
}
int main()
{
    test01();
	return 0;
}

 5.虚析构与纯虚析构

使用原因：

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
class Animal
{
public:
    virtual void speak()=0;
    Animal()
    {
        cout<<"Animal的构造函数调用"<<endl;
    }
    ~Animal()
    {
        cout<<"Animal的析构函数调用"<<endl;
    }
};
class Cat:public Animal
{
public:
    void speak()
    {
        cout<<*m_Name<<"小猫在说话"<<endl;
    }
    Cat(string name)
    {
        cout<<"Cat的构造函数调用"<<endl;
        m_Name=new string(name);
    }
    ~Cat()
    {
        if(m_Name!=NULL)
        {
            cout<<"Cat的析构函数调用"<<endl;
            delete m_Name;
            m_Name=NULL;
        }
    }
    string *m_Name;
};
void test01()
{
    Animal *animal=new Cat("Tom");
    animal->speak();
    //父类指针在析构时不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄漏
    delete(animal);
}
int main()
{
    test01();
	return 0;
}

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
class Animal
{
public:
    virtual void speak()=0;
    Animal()
    {
        cout<<"Animal的构造函数调用"<<endl;
    }
    /*
    //利用虚析构或纯虚析构可以解决父类指针释放子类对象不干净的问题，但前者必须有内容
    virtual ~Animal()
    {
        cout<<"Animal的析构函数调用"<<endl;
    }
    */
    virtual ~Animal()=0;
};
Animal::~Animal()
{
    cout<<"Animal的纯虚析构函数调用"<<endl;
}
class Cat:public Animal
{
public:
    void speak()
    {
        cout<<*m_Name<<"小猫在说话"<<endl;
    }
    Cat(string name)
    {
        cout<<"Cat的构造函数调用"<<endl;
        m_Name=new string(name);
    }
    ~Cat()
    {
        if(m_Name!=NULL)
        {
            cout<<"Cat的析构函数调用"<<endl;
            delete m_Name;
            m_Name=NULL;
        }
    }
    string *m_Name;
};
void test01()
{
    Animal *animal=new Cat("Tom");
    animal->speak();
    //父类指针在析构时不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄漏
    delete(animal);
}
int main()
{
    test01();
	return 0;
}