C++中的虚函数：深入探究多态性

news2024/9/9 5:50:47

编辑

引言

虚函数基础

纯虚函数与抽象类

虚函数与多态

虚析构函数

结论

引言

在C++中，虚函数是实现多态性的关键机制，它允许我们编写更为灵活和可扩展的代码。通过虚函数，派生类可以提供不同的实现，而基类指针或引用可以调用这些派生类的实现，这就是所谓的运行时多态。本文将详细介绍虚函数的使用、意义以及一些高级主题，如纯虚函数和抽象类，同时辅以丰富的代码示例和注释。

虚函数基础

虚函数的基本概念是，一个类中的成员函数可以被其派生类重写。要声明一个虚函数，只需在函数声明前加上virtual关键字。这里是一个简单的示例：

#include <iostream>

// 声明基类 Shape
class Shape {
public:
    // 声明虚函数 draw()
    virtual void draw() {
        std::cout << "Drawing a generic shape." << std::endl;
    }
};

// 声明派生类 Circle
class Circle : public Shape {
public:
    // 重写虚函数 draw()
    void draw() override {
        std::cout << "Drawing a circle." << std::endl;
    }
};

int main() {
    Shape* shapePtr = new Circle(); // Shape指针指向Circle对象
    shapePtr->draw();               // 调用Circle::draw()

    delete shapePtr;                // 释放内存
    return 0;
}

纯虚函数与抽象类

纯虚函数是一个没有实现的虚函数，它在基类中声明，但在基类中不提供实现。这样的函数以= 0结尾，使得任何包含纯虚函数的类都变成了抽象类，抽象类不能被实例化。

class AbstractShape {
public:
    // 声明纯虚函数 draw()
    virtual void draw() = 0;
};

// 这是一个错误，因为AbstractShape是抽象类，不能实例化
// AbstractShape as;

// 正确的使用方式：定义一个派生类并实现纯虚函数
class ConcreteShape : public AbstractShape {
public:
    void draw() override {
        std::cout << "Drawing a concrete shape." << std::endl;
    }
};

虚函数与多态

虚函数的真正威力在于多态性，即一个接口可以有多种实现。以下代码展示了如何通过基类指针调用派生类的不同实现：

class Animal {
public:
    virtual void makeSound() {
        std::cout << "The animal makes a sound." << std::endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Woof woof!" << std::endl;
    }
};

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

void makeAllAnimalsSound(Animal* animal) {
    animal->makeSound();
}

int main() {
    Animal* dog = new Dog();
    Animal* cat = new Cat();

    makeAllAnimalsSound(dog); // 输出: Woof woof!
    makeAllAnimalsSound(cat); // 输出: Meow meow!

    delete dog;
    delete cat;

    return 0;
}

虚析构函数

在使用虚函数时，通常会将基类的析构函数声明为虚函数。这可以确保当通过基类指针删除派生类对象时，正确的析构函数会被调用。

class Base {
public:
    virtual ~Base() {} // 虚析构函数
};

class Derived : public Base {
public:
    ~Derived() {
        std::cout << "Derived destructor called." << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();
    delete basePtr; // 调用Derived的析构函数

    return 0;
}