用c++写一个封装继承多肽的例子
时间: 2023-09-09 07:05:17 浏览: 126
C++中的封装、继承、多态理解
### 回答1:
好的,我可以回答这个问题。以下是一个用 C 语言实现封装、继承和多态的例子:
```c
#include <stdio.h>
// 定义一个基类 Animal
typedef struct {
const char* name;
int age;
} Animal;
// 定义一个 Animal 的构造函数
void Animal_init(Animal* animal, const char* name, int age) {
animal->name = name;
animal->age = age;
}
// 定义一个 Animal 的方法
void Animal_sayHello(Animal* animal) {
printf("Hello, I'm %s, %d years old.\n", animal->name, animal->age);
}
// 定义一个派生类 Dog,继承自 Animal
typedef struct {
Animal base;
const char* breed;
} Dog;
// 定义一个 Dog 的构造函数
void Dog_init(Dog* dog, const char* name, int age, const char* breed) {
Animal_init(&dog->base, name, age);
dog->breed = breed;
}
// 重写 Animal 的方法
void Dog_sayHello(Animal* animal) {
Dog* dog = (Dog*)animal;
printf("Woof! I'm %s, a %d-year-old %s.\n", dog->base.name, dog->base.age, dog->breed);
}
int main() {
// 创建一个 Animal 对象
Animal animal;
Animal_init(&animal, "Tom", 3);
Animal_sayHello(&animal);
// 创建一个 Dog 对象
Dog dog;
Dog_init(&dog, "Max", 2, "Golden Retriever");
Animal_sayHello(&dog.base); // 调用基类方法
Dog_sayHello(&dog); // 调用派生类方法
return ;
}
```
这个例子中,我们定义了一个基类 Animal,它有一个构造函数 Animal_init 和一个方法 Animal_sayHello。然后我们定义了一个派生类 Dog,它继承自 Animal,并且有一个构造函数 Dog_init 和一个重写了 Animal_sayHello 的方法 Dog_sayHello。在 main 函数中,我们创建了一个 Animal 对象和一个 Dog 对象,并分别调用了它们的方法。
### 回答2:
封装、继承和多态是面向对象编程的三大特性之一,下面是一个用C语言编写的封装、继承和多态的例子:
```c
#include <stdio.h>
// Animal类(基类)
typedef struct {
void (*sound)(void); // 定义一个函数指针,用于发出声音
} Animal;
void Animal_sound(void) {
printf("Animal makes a sound.\n");
}
// Cat类(派生类)
typedef struct {
Animal base; // 派生类内嵌基类对象作为第一个成员
} Cat;
void Cat_sound(void) {
printf("Cat meows.\n");
}
// Dog类(派生类)
typedef struct {
Animal base; // 派生类内嵌基类对象作为第一个成员
} Dog;
void Dog_sound(void) {
printf("Dog barks.\n");
}
void makeSound(Animal* animal) {
animal->sound();
}
int main() {
Animal animal;
animal.sound = Animal_sound;
Cat cat;
cat.base.sound = Cat_sound;
Dog dog;
dog.base.sound = Dog_sound;
makeSound(&animal); // 输出:Animal makes a sound.
makeSound((Animal*)&cat); // 输出:Cat meows.
makeSound((Animal*)&dog); // 输出:Dog barks.
return 0;
}
```
在上面的例子中,我们定义了一个基类Animal,其中内嵌了一个函数指针sound,用于发出声音。接下来,我们定义了两个派生类Cat和Dog,它们分别继承自Animal,并分别重写了sound函数。makeSound函数接收一个Animal类型的指针,并调用sound函数。在main函数中,我们创建了一个Animal对象、一个Cat对象和一个Dog对象,并通过调用makeSound函数,分别执行了基类和派生类的声音输出。
这个例子展示了使用C语言实现封装、继承和多态的基本方式。
### 回答3:
多态是面向对象编程中的一个重要概念,它允许通过统一的接口调用不同实现的对象。下面是一个使用C语言实现封装、继承和多态的简单例子:
假设我们有一个基类Animal,它有一个公共的成员函数eat()。然后派生出两个子类Dog和Cat,它们分别重写了eat()函数,并添加了自己特有的成员函数bark()和meow()。
首先,我们需要创建一个结构体Animal,定义基类的成员函数。代码如下:
```c
typedef struct {
void (*eat)();
} Animal;
```
然后,我们创建Dog和Cat结构体分别继承Animal,并定义自己的成员函数。代码如下:
```c
typedef struct {
Animal base; // 继承基类
void (*bark)();
} Dog;
void dogEat() {
printf("Dog is eating.\n");
}
void dogBark() {
printf("Dog is barking.\n");
}
Dog createDog() {
Dog dog;
dog.base.eat = dogEat; // 继承基类的eat函数
dog.bark = dogBark;
return dog;
}
typedef struct {
Animal base; // 继承基类
void (*meow)();
} Cat;
void catEat() {
printf("Cat is eating.\n");
}
void catMeow() {
printf("Cat is meowing.\n");
}
Cat createCat() {
Cat cat;
cat.base.eat = catEat; // 继承基类的eat函数
cat.meow = catMeow;
return cat;
}
```
最后,我们可以创建Dog和Cat对象,并通过统一的接口调用它们的成员函数。代码如下:
```c
int main() {
Dog dog = createDog();
Cat cat = createCat();
Animal* animal1 = (Animal*)&dog;
Animal* animal2 = (Animal*)&cat;
animal1->eat();
dog.bark();
animal2->eat();
cat.meow();
return 0;
}
```
这样,无论是调用animal1还是animal2的eat()函数,都会根据实际类型调用正确的函数。这就是多态的实现。
阅读全文