第三节 · 进化论 · 虚函数与抽象基类

多态是面向对象的精髓：同一个接口，不同的实现。通过多态，我们可以用统一的方式处理不同类型的对象。

---

虚函数

class Shape
{
public:
    // 虚函数：允许派生类重写
    virtual void draw() const
    {
        cout << "Drawing a shape" << endl;
    }
};

class Circle : public Shape
{
public:
    void draw() const override  // override 确保是重写
    {
        cout << "Drawing a circle" << endl;
    }
};

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

int main()
{
    Shape* shapes[3];
    shapes[0] = new Shape();
    shapes[1] = new Circle();
    shapes[2] = new Rectangle();
    
    for (int i = 0; i < 3; ++i)
    {
        shapes[i]->draw();  // 根据实际类型调用
    }
    
    // 清理
    for (int i = 0; i < 3; ++i)
        delete shapes[i];
    
    return 0;
}
// 输出：
// Drawing a shape
// Drawing a circle
// Drawing a rectangle

---

override 和 final

class Base
{
public:
    virtual void foo() {}
    virtual void bar() {}
    void baz() {}  // 非虚函数
};

class Derived : public Base
{
public:
    void foo() override {}      // OK：重写虚函数
    // void bar(int) override {}  // 错误：签名不匹配
    // void baz() override {}     // 错误：baz 不是虚函数
};

// final 阻止进一步重写
class FinalDerived : public Base
{
public:
    void foo() final {}  // 派生类不能再重写 foo
};

// final 类不能被继承
class FinalClass final : public Base {};
// class MoreDerived : public FinalClass {};  // 错误

---

纯虚函数与抽象类

// 抽象类：包含纯虚函数
class Shape
{
public:
    // 纯虚函数：= 0 表示没有实现
    virtual double area() const = 0;
    virtual void draw() const = 0;
    
    // 可以有普通成员
    void printArea() const
    {
        cout << "Area: " << area() << endl;
    }
    
    virtual ~Shape() = default;
};

// Shape s;  // 错误：不能实例化抽象类

class Circle : public Shape
{
    double radius;
public:
    Circle(double r) : radius(r) {}
    
    double area() const override
    {
        return 3.14159 * radius * radius;
    }
    
    void draw() const override
    {
        cout << "Circle with radius " << radius << endl;
    }
};

int main()
{
    Circle c(5);
    c.printArea();  // Area: 78.5398
    
    Shape* s = &c;
    s->draw();  // Circle with radius 5
    
    return 0;
}

---

虚析构函数

class Base
{
public:
    ~Base()  // 非虚析构函数
    {
        cout << "~Base()" << endl;
    }
};

class Derived : public Base
{
    int* data;
public:
    Derived() : data(new int[100]) {}
    ~Derived()
    {
        delete[] data;
        cout << "~Derived()" << endl;
    }
};

void danger()
{
    Base* p = new Derived();
    delete p;  // 只调用 ~Base()，内存泄漏！
}

// 正确做法
class SafeBase
{
public:
    virtual ~SafeBase()  // 虚析构函数
    {
        cout << "~SafeBase()" << endl;
    }
};

class SafeDerived : public SafeBase
{
    int* data;
public:
    SafeDerived() : data(new int[100]) {}
    ~SafeDerived() override
    {
        delete[] data;
        cout << "~SafeDerived()" << endl;
    }
};

规则：如果类有虚函数，就应该有虚析构函数。

---

动态绑定原理

class Animal
{
public:
    virtual void speak() { cout << "..." << endl; }
};

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

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

// 多态的威力
void makeSound(Animal& animal)
{
    animal.speak();  // 运行时决定调用哪个版本
}

int main()
{
    Dog d;
    Cat c;
    Animal a;
    
    makeSound(d);  // Woof!
    makeSound(c);  // Meow!
    makeSound(a);  // ...
    
    return 0;
}

---

RTTI：运行时类型识别

#include <typeinfo>

class Base
{
public:
    virtual ~Base() = default;
};

class Derived : public Base {};

int main()
{
    Base* p = new Derived();
    
    // typeid 获取类型信息
    cout << typeid(*p).name() << endl;  // Derived 的类型信息
    
    // dynamic_cast 安全转换
    if (Derived* d = dynamic_cast<Derived*>(p))
    {
        cout << "p points to Derived" << endl;
    }
    
    delete p;
    return 0;
}

---

接口模式

// 纯接口（Java 风格）
class Drawable
{
public:
    virtual void draw() const = 0;
    virtual ~Drawable() = default;
};

class Printable
{
public:
    virtual void print() const = 0;
    virtual ~Printable() = default;
};

// 实现多个接口
class Document : public Drawable, public Printable
{
public:
    void draw() const override
    {
        cout << "Drawing document" << endl;
    }
    
    void print() const override
    {
        cout << "Printing document" << endl;
    }
};

---

NVI 模式（非虚接口）

class Widget
{
public:
    // 公有非虚接口
    void doWork()
    {
        beforeWork();
        doWorkImpl();  // 调用虚函数
        afterWork();
    }
    
    virtual ~Widget() = default;
    
private:
    // 私有虚函数
    virtual void doWorkImpl() = 0;
    
    // 钩子函数
    virtual void beforeWork() {}
    virtual void afterWork() {}
};

class ConcreteWidget : public Widget
{
private:
    void doWorkImpl() override
    {
        cout << "Doing real work" << endl;
    }
};

---

习题

• 解释虚函数表（vtable）的工作原理。

• 什么时候需要虚析构函数？

• 实现一个简单的图形编辑器，使用多态处理不同形状。