0828|C++day6 菱形继承+虚继承+多态+抽象类+模板

一、思维导图

二、今日知识回顾

1）多态

父类的指针或者引用，指向或初始化子类的对象，调用子类对父类重写的函数，进而展开子类的功能。

#include 
using namespace std;

class Zhou
{
private:
    string name;
    int age;
public:
    //无参构造函数
    Zhou() {}
    //有参构造函数
    Zhou(string n,int a):name(n),age(a)
    {}
    virtual void show()
    {
        cout << "Zhou" << endl;
    }
};

class Teacher:public Zhou
{
private:
    int id;
public:
    //无参构造函数
    Teacher() {}
    //有参构造函数
    Teacher(string n, int a, int id):Zhou(n,a),id(id)
    {}
    void show()
    {
        cout << "上课了" << endl;
    }
};

class Player:public Zhou
{
private:
    string game;
public:
    //无参构造函数
    Player() {}
    //有参构造函数
    Player(string n, int a, string game):Zhou(n,a),game(game)
    {}
    void show()
    {
        cout << "稳住 我们能赢" << endl;
    }

};
int main()
{
    Teacher r("zhangsan",34,1001);
    Zhou *p; //父类的指针
    p = &r;  //父类的指针，指向子类对象 相当于承担老师这个角色
    p->show(); //上课

    Player r1("lisi",23,"王者");
    p = &r1; //此时使游戏玩家这个角色
    p->show();

    return 0;
}

2）虚析构

#include 

using namespace std;
class Person
{
private:
    string name;
public:
    Person() {}
    Person(string n):name(n)
    {}

    virtual~Person()  //虚析构函数  满足继承
    {
        cout << "Person::析构函数" << endl;
    }
};

class Stu:public Person
{
private:
    int id;
public:
    Stu() {}
    Stu(string n, int a):Person(n),id(a)
    {}

    ~Stu()
    {
        cout << "Stu::析构函数" << endl;
    }
};
int main()
{
    Person *p = new Stu("zhangsan",1001);
    delete p;   //如果没有虚析构函数，进行释放p时，子类自己拓展的空间就没有释放--内存泄漏
    return 0;
}

3）抽象类

• 抽象类一般是用来被继承的，它不能实例化出具体的一个对象，抽象类中至少有一个纯虚函数。
• 如果子类没有对父类的纯虚函数重写，那么子类也是抽象类，不能实例化一个对象

#include 

using namespace std;

class A  //抽象类
{
    int a;
public:
    A() {}
    virtual void show() = 0; //纯虚函数
};
class B:public A
{
    int b;
public:
    B() {}
    void show() //如果子类没有对继承过来的纯虚函数进行重写，那么子类也是抽象类，不能实例化一个对象
    {
    }
};
int main()
{
    B b;
    return 0;
}

三、作业

1）动物园的讲解员和动物表演

以下是一个简单的比喻，将多态概念与生活中的实际情况相联系：

比喻：动物园的讲解员和动物表演

  想象一下你去了一家动物园，看到了许多不同种类的动物，如狮子、大象、猴子等。现在，动物园里有一位讲解员，他会为每种动物表演做简单的介绍。

  在这个场景中，我们可以将动物比作是不同的类，而每种动物表演则是类中的函数。而讲解员则是一个基类，他可以根据每种动物的特点和表演，进行相应的介绍。

具体过程如下：

• 定义一个基类 Animal，其中有一个虚函数 perform()，用于在子类中实现不同的表演行为。

#include 

using namespace std;

class Animal  //基类
{
    string name;
    int age;
public:
    //无参构造函数
    Animal() {}
    //有参构造函数
    Animal(string n,int a):name(n),age(a)
    {}
    virtual void perform() = 0;  //将perform设置为纯虚类
    virtual~Animal()
    {cout << "Animal::析构函数" << endl;}
};
class Lion:public Animal
{
    string per;
public:
    //无参构造函数
    Lion() {}
    //有参构造函数
    Lion(string n,int a,string p):Animal(n,a),per(p)
    {}
    void perform()
    {
        cout << per << endl;
    }
    ~Lion()
    {cout << "Lion::析构函数" << endl;}
};
int main()
{
    Animal *p = new Lion("狮子",4,"河东狮吼");
    p->perform();
    delete p;

    return 0;
}

 

2）用函数模板实现不同数据类型的交换功能

#include 

using namespace std;
template  
void fun(T &a,T &b)
{
    T temp;
    temp = a;
    a = b;
    b = temp;
}
int main()
{
    int a = 10;
    int b = 20;
    fun(a,b);
    cout << a << " " << b << endl;

    char c = 'a';
    char d = 'b';
    fun(c,d);
    cout << c << " " << d << endl;

    return 0;
}