动态绑定与虚函数¶

#include <iostream>
using namespace std;

class Base {
public:
    void display() const {
        cout << "Base::display()" << endl;
    }
};

class Derived : public Base {
public:
    void display() const {
        cout << "Derived::display()" << endl;
    }
};

void show(Base* p) {
    p->display();   // 调用哪个版本？
}

int main() {
    Base b;
    Derived d;

    show(&b);   // Base::display()
    show(&d);   // Base::display()  ← 不是期望的 Derived::display()！

    return 0;
}

#include <iostream>
using namespace std;

class Base {
public:
    // 声明为虚函数
    virtual void display() const {
        cout << "Base::display()" << endl;
    }

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

class Derived : public Base {
public:
    // 覆盖基类的虚函数
    virtual void display() const override {
        cout << "Derived::display()" << endl;
    }
};

void show(Base* p) {
    p->display();   // 运行时多态：根据对象实际类型调用
}

int main() {
    Base b;
    Derived d;

    show(&b);   // Base::display()
    show(&d);   // Derived::display()  ✓ 正确！

    return 0;
}

class Base {
public:
    void func() { cout << "Base::func()" << endl; }
    virtual void vfunc() { cout << "Base::vfunc()" endl; }
};

class Derived : public Base {
public:
    void func() { cout << "Derived::func()" << endl; }
    virtual void vfunc() override { cout << "Derived::vfunc()" endl; }
};

int main() {
    Derived d;
    Base* p = &d;

    p->func();     // 静态绑定 → Base::func()（p 的类型是 Base*）
    p->vfunc();    // 动态绑定 → Derived::vfunc()（对象实际是 Derived）

    return 0;
}

class Base {
public:
    virtual void func(int x) const { }
    virtual ~Base() { }
};

class Derived : public Base {
public:
    // 错误！基类没有 virtual void func(int)（参数类型不同）
    // virtual void func(double x) const override { }

    // 错误！基类没有 virtual void func(int)（缺少 const）
    // virtual void func(int x) override { }

    // 正确：完全匹配基类的虚函数
    virtual void func(int x) const override { }
};

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() {
        cout << "Base::show()" << endl;
    }
};

// Derived 中未写 virtual，但 show 仍是虚函数
class Derived : public Base {
public:
    void show() {   // 仍然是虚函数（从 Base 继承来的特性）
        cout << "Derived::show()" << endl;
    }
};

// GrandDerived 中未写 virtual，但 show 仍是虚函数
class GrandDerived : public Derived {
public:
    void show() {   // 仍然是虚函数
        cout << "GrandDerived::show()" << endl;
    }
};

int main() {
    Base* p = new GrandDerived();
    p->show();   // GrandDerived::show()（动态绑定）

    delete p;
    return 0;
}

#include <iostream>
#include <vector>
#include <memory>
using namespace std;

// 基类 Shape
class Shape {
public:
    // 虚函数：计算面积
    virtual double area() const = 0;

    // 虚函数：绘制形状
    virtual void draw() const {
        cout << "Drawing a shape" << endl;
    }

    // 虚析构函数（重要！）
    virtual ~Shape() {
        cout << "Shape destroyed" << endl;
    }
};

// Circle 继承 Shape
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}

    // 覆盖 area
    virtual double area() const override {
        return 3.14159 * radius * radius;
    }

    // 覆盖 draw
    virtual void draw() const override {
        cout << "Drawing a circle with radius " << radius << endl;
    }

    virtual ~Circle() {
        cout << "Circle destroyed" << endl;
    }
};

// Rectangle 继承 Shape
class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}

    virtual double area() const override {
        return width * height;
    }

    virtual void draw() const override {
        cout << "Drawing a rectangle " << width << "x" << height << endl;
    }

    virtual ~Rectangle() {
        cout << "Rectangle destroyed" << endl;
    }
};

// 显示所有形状的信息
void showInfo(const Shape& shape) {
    shape.draw();
    cout << "Area: " << shape.area() << endl;
    cout << "---" << endl;
}

int main() {
    cout << "=== 多态演示 ===" << endl;

    // 使用基类指针指向派生类对象
    Shape* p1 = new Circle(5.0);
    Shape* p2 = new Rectangle(4.0, 3.0);

    // 动态绑定：调用实际类型的函数
    p1->draw();   // Drawing a circle with radius 5
    p2->draw();   // Drawing a rectangle 4x3

    cout << "\n=== 使用引用调用 ===" << endl;
    Circle c(3.0);
    Rectangle r(2.0, 6.0);

    showInfo(c);   // Circle 版本
    showInfo(r);   // Rectangle 版本

    cout << "\n=== 使用 vector 统一管理 ===" << endl;
    vector<Shape*> shapes;
    shapes.push_back(new Circle(2.0));
    shapes.push_back(new Rectangle(3.0, 4.0));
    shapes.push_back(new Circle(1.0));

    for (auto shape : shapes) {
        shape->draw();
        cout << "Area: " << shape->area() << endl;
    }

    cout << "\n=== 清理资源 ===" << endl;
    // 虚析构函数确保正确清理
    delete p1;
    delete p2;
    for (auto shape : shapes) {
        delete shape;
    }

    return 0;
}