派生类写不同动物的叫声

好的，我可以帮你写出派生类，以描述不同动物的叫声。以下是一个例子：

// 基类 Animal
class Animal {
public:
    virtual void makeSound() {
        std::cout << "动物发出了一些声音" << std::endl;
    }
};

// 派生类 Dog
class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "汪汪汪！" << std::endl;
    }
};

// 派生类 Cat
class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "喵~~喵~~" << std::endl;
    }
};

// 派生类 Bird
class Bird : public Animal {
public:
    void makeSound() override {
        std::cout << "叽叽喳喳！" << std::endl;
    }
};

在上面的例子中，基类 Animal 定义了一个虚函数 makeSound，表示动物发出声音。派生类 Dog、Cat 和 Bird 分别重写了这个函数，分别表示狗汪汪叫、猫喵喵叫和鸟叽叽喳喳叫。可以根据需要添加更多派生类来描述更多动物的叫声。

相关问题

定义猫科动物animal，由其派生出猫类cat和豹类leopard，二者都包含虚函数sound，要求根据派生类对象的不同调用各自重载后的成员函数

好的，让我来回答你的问题。

首先，我们可以定义一个基类 `Animal`，包含虚函数 `sound`：

class Animal {
public:
    virtual void sound() = 0;
};

然后，我们可以从 `Animal` 派生出 `Cat` 和 `Leopard`：

class Cat : public Animal {
public:
    void sound() override {
        std::cout << "Meow!" << std::endl;
    }
};

class Leopard : public Animal {
public:
    void sound() override {
        std::cout << "Roar!" << std::endl;
    }
};

在这里，我们重载了 `Animal` 的 `sound` 函数，使得 `Cat` 和 `Leopard` 的叫声不同。

最后，我们可以创建 `Cat` 和 `Leopard` 的对象，并根据对象的类型来调用相应的成员函数：

int main() {
    Animal* animal1 = new Cat();
    Animal* animal2 = new Leopard();

    animal1->sound(); // 输出 "Meow!"
    animal2->sound(); // 输出 "Roar!"

    delete animal1;
    delete animal2;

    return 0;
}

在这里，我们使用了多态性，通过基类指针指向派生类对象，并调用虚函数 `sound`，来实现了动态绑定，根据对象的类型来调用相应的成员函数。

c++编写程序，定义动物Animal类，由其派生出猫类（Cat）和狮子类（Lion），二者都包含虚函数sound（），要求根据派生类对象的不同调用各自的成员函数sound（）

好的，以下是示例代码：

#include <iostream>
using namespace std;

class Animal {  //定义动物类
public:
    virtual void sound() {  //虚函数
        cout << "动物发出声音" << endl;
    }
};

class Cat : public Animal {  //猫类，继承自动物类
public:
    void sound() {  //重写动物类的虚函数
        cout << "喵喵喵" << endl;
    }
};

class Lion : public Animal {  //狮子类，继承自动物类
public:
    void sound() {  //重写动物类的虚函数
        cout << "吼吼吼" << endl;
    }
};

int main() {
    Animal* animal1 = new Cat();  //创建一个猫对象
    Animal* animal2 = new Lion();  //创建一个狮子对象

    animal1->sound();  //调用猫对象的成员函数sound()
    animal2->sound();  //调用狮子对象的成员函数sound()

    delete animal1;  //释放动态分配的内存
    delete animal2;

    return 0;
}

输出结果为：

喵喵喵
吼吼吼

可以看到，根据不同的派生类对象，调用了不同的成员函数sound()。