1>思维导图

2>试编程

要求:

封装一个动物的基类，类中有私有成员：姓名，颜色，指针成员年纪

再封装一个狗这样类，共有继承于动物类，自己拓展的私有成员有：指针成员：腿的个数（整型 int count），共有成员函数：会叫：void speak()

要求：分别完成基类和派生类中的：构造函数、析构函数、拷贝构造函数、拷贝赋值函数

eg : Dog d1;

Dog d2(.....);

Dog d3(d2);

d1 = d3;

源代码:

#include <iostream>

using namespace std;
//封装一个动物的基类
class Animal
{
//类中有私有成员：姓名，颜色，指针成员年纪
private:
    string name;
    string color;
    double *age;

public:
    //Animal无参拷贝
    Animal(){}
    //Animal有参拷贝
    Animal(string n,string c,double a):name(n), color(c),\
        age(new double(a))
    {}
    //Animal析构函数
    ~Animal()
    {
        delete age;
    }
    //Animal拷贝构造
    Animal (const Animal &other):name(other.name),\
        color(other.color), age(new double(*other.age))
    {}
     //Animal拷贝赋值
    Animal &operator=(const Animal &other)
    {
        if(this != &other)
        {
             name = other.name;
             color = other.color;
             age = new double(*other.age);
        }
        return *this;
    }
};
//封装一个狗这样类，公有继承于动物类
class Dog:public Animal
{
//自己拓展的私有成员有：指针成员：腿的个数（整型 int legNum)
private:
    int *legNum;

public:
    //Dog无参拷贝
    Dog(){}
    //Dog有参拷贝
    Dog(int ln,string n,string c,double a):Animal(n,c,a),\
        legNum(new int(ln))
    {}
    //Dog析构函数
    ~Dog()
    {
        delete legNum;
    }
    //Dog拷贝构造
    Dog (const Dog &other):Animal(other),\
        legNum(new int(*other.legNum))
    {}
    //Dog拷贝赋值
    Dog &operator=(const Dog &other)
    {
        if(this != &other)
        {
            legNum = new int(*other.legNum);
            Animal::operator=(other);
        }
        return *this;
    }
    //公有成员函数：会叫：void speak()
    void speak()
    {
        cout << this << ": 汪汪汪……" << endl;
    }
};

int main()
{
    Dog d1;
    Dog d2(4,"小汪","blue",2.5);
    Dog d3(d2);
    d1 = d3;
//    d1.speak();
//    d2.speak();
//    d3.speak();

    return 0;
}

3>试编程

要求:

以下是一个简单的比喻，将多态概念与生活中的实际情况相联系：
比喻：动物园的讲解员和动物表演想象一下你去了一家动物园，看到了许多不同种类的动物，如狮子、大象、猴子等。现在，动物园里有一位讲解员，他会为每种动物表演做简单的介绍。
在这个场景中，我们可以将动物比作是不同的类，而每种动物表演则是类中的函数。
而讲解员则是一个基类，他可以根据每种动物的特点和表演，进行相应的介绍。
具体过程如下：
定义一个基类 Animal，其中有一个虛函数perform（)，用于在子类中实现不同的表演行为。

源代码:

#include <iostream>

using namespace std;

//定义一个基类Animal
class Animal
{
public:
    virtual void perform() = 0;
};

//定义一个Animal的子类Lion派生类
class Lion:virtual public Animal
{
private:
    string introduction;

public:
    Lion(string introduction=""):introduction(introduction){}
    //重写 perform()虚函数
    void perform() override
    {
        cout << "  介绍：芝士狮子" << introduction <<endl;
        cout << "  表演：狮子拜天！" << endl;
    }

};
//定义一个Animal的子类SnowLeopard派生类
class SnowLeopard:virtual public Animal
{
private:
    string introduction;
public:
    SnowLeopard(string introduction=""):introduction(introduction){}
    //重写 perform()虚函数
    void perform() override
    {
        cout << "  介绍：芝士雪豹" << introduction <<endl;
        cout << "  表演：与丁真珍珠去粘合国演讲。" << endl;
    }
};
//定义一个Animal的子类Elephant派生类
class Elephant:virtual public Animal
{
private:
    string introduction;

public:
    Elephant(string introduction=""):introduction(introduction){}
    //重写 perform()虚函数
    void perform() override
    {
        cout << "  介绍：芝士大象" << introduction <<endl;
        cout << "  表演：大象踢腿！" << endl;
    }
};


int main()
{
    // 实例化不同的动物类
    Lion lion;
    Elephant elephant;
    SnowLeopard SnowLeopard;

    // 使用基类指针指向不同的动物对象，实现多态
    Animal* animal1 = &lion;
    Animal* animal2 = &elephant;
    Animal* animal3 = &SnowLeopard;

    // 讲解员为每种动物表演做介绍
    cout << "动物园讲解员开始介绍：" << endl;
    cout << "------------------------" << endl;
    cout << "狮子表演：" << endl;
    animal1->perform();
    cout << "------------------------" << endl;
    cout << "雪豹表演：" << endl;
    animal3->perform();
    cout << "------------------------" << endl;
    cout << "大象表演：" << endl;
    animal2->perform();
    cout << "------------------------" << endl;

    return 0;
}

效果图: