c++多态学习例子
时间: 2023-11-03 18:51:41 浏览: 102
当然!多态是面向对象编程中的重要概念,它允许不同类型的对象以统一的方式进行处理。下面是一个简单的多态学习例子:
```python
class Animal:
def sound(self):
pass
class Dog(Animal):
def sound(self):
print("汪汪汪!")
class Cat(Animal):
def sound(self):
print("喵喵喵!")
def make_sound(animal):
animal.sound()
dog = Dog()
cat = Cat()
make_sound(dog) # 输出:汪汪汪!
make_sound(cat) # 输出:喵喵喵!
```
在上面的例子中,`Animal` 类是一个基类,它定义了一个 `sound()` 方法。`Dog` 和 `Cat` 类分别继承了 `Animal` 类,并重写了 `sound()` 方法。
`make_sound()` 函数接受一个 `Animal` 类型的参数,并调用它的 `sound()` 方法。当我们传入 `Dog` 或 `Cat` 对象时,由于多态的特性,它们的 `sound()` 方法会被正确地调用。
这个例子展示了多态的使用,通过将不同的对象传递给相同的函数,我们可以以统一的方式处理它们,并根据对象的实际类型调用正确的方法。
相关问题
c++多态代码实现
C++中多态的实现方式主要有以下几种:
1. 虚函数(Virtual Functions):通过在基类中声明虚函数,并在派生类中进行重写,实现多态性。当通过基类指针或引用调用虚函数时,会根据实际对象的类型来确定调用哪个函数。
示例代码如下:
```cpp
class Animal {
public:
virtual void sound() {
cout << "Animal makes a sound." << endl;
}
};
class Dog : public Animal {
public:
void sound() {
cout << "Dog barks." << endl;
}
};
class Cat : public Animal {
public:
void sound() {
cout << "Cat meows." << endl;
}
};
int main() {
Animal* animal1 = new Dog();
Animal* animal2 = new Cat();
animal1->sound(); // 输出:Dog barks.
animal2->sound(); // 输出:Cat meows.
delete animal1;
delete animal2;
return 0;
}
```
2. 纯虚函数(Pure Virtual Functions):在基类中声明纯虚函数,派生类必须实现该函数。纯虚函数使得基类成为抽象类,无法实例化,只能作为接口使用。
示例代码如下:
```cpp
class Shape {
public:
virtual void draw() = 0; // 纯虚函数
};
class Circle : public Shape {
public:
void draw() {
cout << "Drawing a circle." << endl;
}
};
class Rectangle : public Shape {
public:
void draw() {
cout << "Drawing a rectangle." << endl;
}
};
int main() {
Shape* shape1 = new Circle();
Shape* shape2 = new Rectangle();
shape1->draw(); // 输出:Drawing a circle.
shape2->draw(); // 输出:Drawing a rectangle.
delete shape1;
delete shape2;
return 0;
}
```
3. 虚析构函数(Virtual Destructors):当基类指针指向派生类对象时,如果基类的析构函数不是虚函数,那么只会调用基类的析构函数,而不会调用派生类的析构函数。为了正确释放派生类对象的资源,需要将基类的析构函数声明为虚函数。
示例代码如下:
```cpp
class Base {
public:
virtual ~Base() {
cout << "Base destructor." << endl;
}
};
class Derived : public Base {
public:
~Derived() {
cout << "Derived destructor." << endl;
}
};
int main() {
Base* base = new Derived();
delete base; // 输出:Derived destructor. Base destructor.
return 0;
}
```
c++多态继承封装
引用中提到,C++提供了类(封装、继承、多态)的功能。在C++中,封装是指将数据和操作封装在一个类中,通过访问控制符来限制对数据的访问。继承是指一个类可以继承另一个类的属性和方法,并且可以添加新的属性和方法。多态是指同一个函数可以根据参数的不同表现出不同的行为。
举个例子,假设有一个C++的类:
```cpp
class Shape {
public:
virtual void draw() {
// 绘制图形的代码
}
};
class Circle : public Shape {
public:
void draw() override {
// 绘制圆形的代码
}
};
class Rectangle : public Shape {
public:
void draw() override {
// 绘制矩形的代码
}
};
```
在这个例子中,Shape是一个基类,Circle和Rectangle是继承自Shape的派生类。它们都有一个draw()方法,但是每个类的draw()方法实现是不同的。当我们调用draw()方法时,会根据对象的实际类型来决定具体执行哪个类的draw()方法。