如何在C++中实现一个虚函数_C++虚函数与动态绑定

virtual

virtual

virtual

#include <iostream>
#include <string>

// 基类
class Animal {
public:
    // 声明一个虚函数
    virtual void speak() const {
        std::cout << "Animal makes a sound." << std::endl;
    }

    // 虚析构函数，非常重要！
    virtual ~Animal() {
        std::cout << "Animal destructor called." << std::endl;
    }
};

// 派生类 Dog
class Dog : public Animal {
public:
    // 重写基类的虚函数
    void speak() const override { // 使用 override 关键字是个好习惯，编译器会检查是否真的重写了虚函数
        std::cout << "Dog barks: Woof! Woof!" << std::endl;
    }

    ~Dog() override {
        std::cout << "Dog destructor called." << std::endl;
    }
};

// 派生类 Cat
class Cat : public Animal {
public:
    void speak() const override {
        std::cout << "Cat meows: Meow!" << std::endl;
    }

    ~Cat() override {
        std::cout << "Cat destructor called." << std::endl;
    }
};

int main() {
    Animal* myAnimal = new Animal();
    Animal* myDog = new Dog(); // 基类指针指向派生类对象
    Animal* myCat = new Cat(); // 基类指针指向派生类对象

    myAnimal->speak(); // 输出: Animal makes a sound.
    myDog->speak();    // 输出: Dog barks: Woof! Woof! (动态绑定生效)
    myCat->speak();    // 输出: Cat meows: Meow! (动态绑定生效)

    std::cout << "\n--- Deleting objects ---\n";
    delete myAnimal;
    delete myDog; // 如果Animal的析构函数不是虚函数，这里可能只会调用Animal的析构函数，导致Dog的析构函数未被调用，造成资源泄露。
    delete myCat;

    return 0;
}

speak()

Animal*

speak()

Dog

Cat

speak()

virtual

myDog->speak()

myCat->speak()

Animal

speak()

Animal* myDog

myDog->speak()

#include <iostream>
#include <string>

class Base {
public:
    Base() { std::cout << "Base constructor called.\n"; }
    // 如果这里没有 virtual 关键字
    // ~Base() { std::cout << "Base destructor called.\n"; }
    virtual ~Base() { std::cout << "Base destructor called.\n"; } // 正确的做法
};

class Derived : public Base {
private:
    int* data;
public:
    Derived() : data(new int[10]) { 
        std::cout << "Derived constructor called. Allocating data.\n"; 
    }
    ~Derived() override {
        delete[] data; // 释放派生类独有的资源
        std::cout << "Derived destructor called. Deallocating data.\n";
    }
};

int main() {
    Base* obj = new Derived(); // 基类指针指向派生类对象
    // ... 使用 obj ...
    delete obj; // 问题就出在这里！

    return 0;
}

Base

virtual

delete obj;

Base::~Base()

Derived

~Derived()

delete[] data;

data

= 0

#include <iostream>

// 抽象基类
class Shape {
public:
    // 纯虚函数：声明一个接口，但没有实现
    virtual double area() const = 0; 
    virtual void draw() const = 0;

    // 抽象类可以有非纯虚函数和成员变量
    void printInfo() const {
        std::cout << "This is a shape." << std::cout;
    }

    virtual ~Shape() { // 抽象类也应该有虚析构函数
        std::cout << "Shape destructor called.\n";
    }
};

// 派生类 Circle
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}

    // 必须实现所有纯虚函数
    double area() const override {
        return 3.14159 * radius * radius;
    }
    void draw() const override {
        std::cout << "Drawing a circle with radius " << radius << std::endl;
    }

    ~Circle() override {
        std::cout << "Circle destructor called.\n";
    }
};

// 派生类 Rectangle
class Rectangle : public Shape {
private:
    double width;
    double height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}

    double area() const override {
        return width * height;
    }
    void draw() const override {
        std::cout << "Drawing a rectangle with width " << width << " and height " << height << std::endl;
    }

    ~Rectangle() override {
        std::cout << "Rectangle destructor called.\n";
    }
};

int main() {
    // Shape s; // 错误：不能实例化抽象类！

    Shape* s1 = new Circle(5.0);
    Shape* s2 = new Rectangle(4.0, 6.0);

    s1->draw();
    std::cout << "Circle area: " << s1->area() << std::endl;

    s2->draw();
    std::cout << "Rectangle area: " << s2->area() << std::endl;

    delete s1;
    delete s2;

    return 0;
}

Shape