手把手教你学C++（二十四）--C++多态

#include <iostream>
using namespace std;

// 基类
class Animal {
public:
    virtual void speak() const = 0; // 纯虚函数
    virtual ~Animal() {} // 虚析构函数
};

// 派生类
class Dog : public Animal {
public:
    void speak() const override { cout << "Woof!" << endl; }
};

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

void makeSound(const Animal& animal) {
    animal.speak(); // 多态调用
}

int main() {
    Dog dog;
    Cat cat;

    makeSound(dog); // 输出 Woof!
    makeSound(cat); // 输出 Meow!

    return 0;
}

虚析构函数（Virtual Destructor）

当基类指针指向派生类对象时，如果没有虚析构函数，析构函数将只调用基类的析构函数，这会导致派生类的资源没有被正确释放。因此，在基类中声明虚析构函数是很重要的。

示例：虚析构函数的重要性

cpp

深色版本

#include <iostream>
using namespace std;

class Base {
public:
    virtual void speak() const { cout << "Base speaking" << endl; }
    virtual ~Base() { cout << "Base destructor called" << endl; }
};

class Derived : public Base {
public:
    void speak() const override { cout << "Derived speaking" << endl; }
    ~Derived() { cout << "Derived destructor called" << endl; }
};

int main() {
    Base* basePtr = new Derived();
    basePtr->speak(); // 多态调用，输出 Derived speaking

    delete basePtr; // 调用析构函数
    // 输出：
    // Derived destructor called
    // Base destructor called

    return 0;
}

多态的实现原理

多态的实现依赖于虚函数表（vtable）机制。每个包含虚函数的类都会有一个虚函数表，虚函数表中存放了虚函数的地址。当通过基类指针调用虚函数时，编译器会查找虚函数表，并根据虚函数表中的地址调用相应的函数。

示例：虚函数表的工作原理

cpp

深色版本

#include <iostream>
using namespace std;

class Base {
public:
    virtual void speak() const { cout << "Base speaking" << endl; }
    virtual ~Base() {}
};

class Derived : public Base {
public:
    void speak() const override { cout << "Derived speaking" << endl; }
    ~Derived() {}
};

int main() {
    Base* basePtr = new Derived();
    basePtr->speak(); // 多态调用，输出 Derived speaking

    delete basePtr; // 调用析构函数

    return 0;
}

虚函数的重写（Override）

在派生类中，可以使用 override 关键字来明确标识某个虚函数是重写了基类中的虚函数。这有助于编译器进行检查，确保重写的函数确实是一个虚函数，并且签名相同。

示例：使用 override 关键字

cpp

深色版本

#include <iostream>
using namespace std;

class Base {
public:
    virtual void speak() const { cout << "Base speaking" << endl; }
    virtual ~Base() {}
};

class Derived : public Base {
public:
    void speak() const override { cout << "Derived speaking" << endl; }
    ~Derived() {}
};

int main() {
    Base* basePtr = new Derived();
    basePtr->speak(); // 多态调用，输出 Derived speaking

    delete basePtr; // 调用析构函数

    return 0;
}

多态的使用场景

多态通常用于需要在运行时根据对象的具体类型来调用相应方法的场景。例如，在设计图形系统时，可以定义一个基类 Shape，并在派生类中实现具体的形状类型（如 Circle、Square 等）。

示例：图形系统的多态实现

cpp

深色版本

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() const = 0; // 纯虚函数
    virtual ~Shape() {}
};

class Circle : public Shape {
public:
    void draw() const override { cout << "Drawing a circle" << endl; }
};

class Square : public Shape {
public:
    void draw() const override { cout << "Drawing a square" << endl; }
};

void renderShape(const Shape& shape) {
    shape.draw(); // 多态调用
}

int main() {
    Circle circle;
    Square square;

    renderShape(circle); // 输出 Drawing a circle
    renderShape(square); // 输出 Drawing a square

    return 0;
}

多态与抽象类

抽象类是指包含纯虚函数的类，这样的类不能直接实例化。抽象类主要用于定义接口，它的派生类必须实现这些纯虚函数。

示例：抽象类的多态实现

cpp

深色版本

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void speak() const = 0; // 纯虚函数
    virtual ~Animal() {}
};

class Dog : public Animal {
public:
    void speak() const override { cout << "Woof!" << endl; }
};

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

void makeSound(const Animal& animal) {
    animal.speak(); // 多态调用
}

int main() {
    Dog dog;
    Cat cat;

    makeSound(dog); // 输出 Woof!
    makeSound(cat); // 输出 Meow!

    return 0;
}