C++编程之多态的使用

class Print {
public:
    void show(int i) {
        cout << "整数: " << i << endl;
    }
    void show(double f) {
        cout << "浮点数: " << f << endl;
    }
    void show(string s) {
        cout << "字符串: " << s << endl;
    }
};

int main() {
    Print obj;
    obj.show(5);       // 调用show(int)
    obj.show(3.14);    // 调用show(double)
    obj.show("Hello"); // 调用show(string)
    return 0;
}

class Complex {
private:
    double real, imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
    
    Complex operator + (const Complex& obj) {
        return Complex(real + obj.real, imag + obj.imag);
    }
    
    void display() {
        cout << real << " + " << imag << "i" << endl;
    }
};

int main() {
    Complex c1(3, 4), c2(5, 6);
    Complex c3 = c1 + c2; // 运算符重载
    c3.display(); // 输出: 8 + 10i
    return 0;
}

class Base {
public:
    virtual void show() { // 虚函数
        cout << "Base class show()" << endl;
    }
    void print() { // 非虚函数
        cout << "Base class print()" << endl;
    }
};

class Derived : public Base {
public:
    void show() override { // 重写虚函数
        cout << "Derived class show()" << endl;
    }
    void print() { // 隐藏基类的print()
        cout << "Derived class print()" << endl;
    }
};

int main() {
    Base* bptr;
    Derived d;
    bptr = &d;
    
    // 运行时多态，根据实际对象类型调用函数
    bptr->show(); // 输出: Derived class show()
    
    // 非虚函数，根据指针类型调用函数
    bptr->print(); // 输出: Base class print()
    
    return 0;
}

class Shape { // 抽象类
public:
    virtual float area() = 0; // 纯虚函数
    virtual void draw() = 0;  // 纯虚函数
};

class Circle : public Shape {
private:
    float radius;
public:
    Circle(float r) : radius(r) {}
    float area() override {
        return 3.14 * radius * radius;
    }
    void draw() override {
        cout << "Drawing Circle" << endl;
    }
};

class Square : public Shape {
private:
    float side;
public:
    Square(float s) : side(s) {}
    float area() override {
        return side * side;
    }
    void draw() override {
        cout << "Drawing Square" << endl;
    }
};

int main() {
    Shape* shapes[2];
    shapes[0] = new Circle(5);
    shapes[1] = new Square(4);
    
    for (int i = 0; i < 2; i++) {
        shapes[i]->draw();
        cout << "Area: " << shapes[i]->area() << endl;
    }
    
    delete shapes[0];
    delete shapes[1];
    return 0;
}

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

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

int main() {
    Base* b = new Derived();
    delete b; // 会调用Derived的析构函数，然后是Base的析构函数
    return 0;
}

class Base {
public:
    virtual void foo() {}
    virtual void bar() final {} // 不能被子类重写
};

class Derived : public Base {
public:
    void foo() override {} // 正确：重写基类虚函数
    // void bar() override {} // 错误：bar是final的
};

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

class Base {
public:
    virtual void func1() { cout << "Base::func1" << endl; }
    virtual void func2() { cout << "Base::func2" << endl; }
    void func3() { cout << "Base::func3" << endl; }
    int a;
};

class Derived : public Base {
public:
    void func1() override { cout << "Derived::func1" << endl; }
    virtual void func4() { cout << "Derived::func4" << endl; }
    int b;
};

Base* ptr = new Derived();
ptr->func1(); // 多态调用

Derived::Derived() {
    // 1. 首先初始化Base部分，此时vptr指向Base的vtable
    // 2. 然后初始化Derived成员，vptr改为指向Derived的vtable
    // 3. 最后执行构造函数体
}

Derived::~Derived() {
    // 1. 执行析构函数体（此时vptr指向Derived的vtable）
    // 2. 析构Derived特有成员
    // 3. vptr改为指向Base的vtable
    // 4. 调用Base的析构函数
}

class Base1 {
public:
    virtual void f1() {}
    int a;
};

class Base2 {
public:
    virtual void f2() {}
    int b;
};

class Derived : public Base1, public Base2 {
public:
    void f1() override {}
    void f2() override {}
    virtual void f3() {}
    int c;
};