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

int main() {
    Print obj;
    obj.show(5);       // 調(diào)用show(int)
    obj.show(3.14);    // 調(diào)用show(double)
    obj.show("Hello"); // 調(diào)用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() { // 虛函數(shù)
        cout << "Base class show()" << endl;
    }
    void print() { // 非虛函數(shù)
        cout << "Base class print()" << endl;
    }
};

class Derived : public Base {
public:
    void show() override { // 重寫虛函數(shù)
        cout << "Derived class show()" << endl;
    }
    void print() { // 隱藏基類的print()
        cout << "Derived class print()" << endl;
    }
};

int main() {
    Base* bptr;
    Derived d;
    bptr = &d;
    
    // 運行時多態(tài)，根據(jù)實際對象類型調(diào)用函數(shù)
    bptr->show(); // 輸出: Derived class show()
    
    // 非虛函數(shù)，根據(jù)指針類型調(diào)用函數(shù)
    bptr->print(); // 輸出: Base class print()
    
    return 0;
}

class Shape { // 抽象類
public:
    virtual float area() = 0; // 純虛函數(shù)
    virtual void draw() = 0;  // 純虛函數(shù)
};

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; } // 虛析構(gòu)函數(shù)
};

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

int main() {
    Base* b = new Derived();
    delete b; // 會調(diào)用Derived的析構(gòu)函數(shù)，然后是Base的析構(gòu)函數(shù)
    return 0;
}

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

class Derived : public Base {
public:
    void foo() override {} // 正確：重寫基類虛函數(shù)
    // 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(); // 多態(tài)調(diào)用

Derived::Derived() {
    // 1. 首先初始化Base部分，此時vptr指向Base的vtable
    // 2. 然后初始化Derived成員，vptr改為指向Derived的vtable
    // 3. 最后執(zhí)行構(gòu)造函數(shù)體
}

Derived::~Derived() {
    // 1. 執(zhí)行析構(gòu)函數(shù)體（此時vptr指向Derived的vtable）
    // 2. 析構(gòu)Derived特有成員
    // 3. vptr改為指向Base的vtable
    // 4. 調(diào)用Base的析構(gòu)函數(shù)
}

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;
};