virtual 多态

“virtual 多态”是指通过使用虚函数实现的多态性。在面向对象的编程中，多态性是指同一种操作可以根据对象的不同类型而具有不同的行为。通过在基类中声明虚函数，并在派生类中重写这些虚函数，我们可以实现在运行时动态绑定具体的函数实现。这意味着，当我们通过基类的指针或引用调用虚函数时，实际调用的是指针或引用所指向的对象的类型所对应的函数。

当使用基类的指针或引用调用虚函数时，编译器无法在编译时确定实际调用的是哪个类的函数，而是在运行时根据对象的类型决定调用的函数。这种动态绑定的特性使得我们可以通过基类的指针或引用来操作不同的派生类对象，实现了多态性。

相关问题

多态

多态是面向对象编程的一个重要特性，它允许在派生类中重写基类中的同名方法，并且在运行时根据对象的实际类型来选择正确的方法实现。多态性可以通过虚函数来实现。

在多态性的实现中，程序可以使用基类指针或引用指向派生类对象，并调用同名的虚函数。在运行时，程序会根据指针或引用指向的对象的实际类型来选择正确的函数实现。

例如，我们可以定义一个基类 `Shape` 和它的两个派生类 `Circle` 和 `Rectangle`，并在 `Shape` 类中声明一个虚函数 `draw()`，在派生类中重写 `draw()` 方法：

class Shape {
public:
    virtual void draw() {
        // 基类中的默认实现
    }
};

class Circle : public Shape {
public:
    void draw() override {
        // 画圆形的实现
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        // 画矩形的实现
    }
};

现在，我们可以使用指向 `Shape` 类的指针或引用来指向 `Circle` 或 `Rectangle` 对象，并调用它们的 `draw()` 方法：

Shape* s1 = new Circle();
Shape* s2 = new Rectangle();

s1->draw(); // 调用 Circle 类中的 draw() 方法
s2->draw(); // 调用 Rectangle 类中的 draw() 方法

在这个例子中，`s1` 指向一个 `Circle` 对象，因此调用 `s1->draw()` 时会调用 `Circle` 类中的 `draw()` 方法。类似地，`s2` 指向一个 `Rectangle` 对象，因此调用 `s2->draw()` 时会调用 `Rectangle` 类中的 `draw()` 方法。

多态性让程序具有更高的灵活性和可扩展性，因为它允许我们在不改变基类代码的情况下增加新的派生类。

c++ 多态

C++中的多态（Polymorphism）是指在父类和子类之间的相互转换，以及在不同对象之间的相互转换。

C++中的多态性有两种：静态多态和动态多态。

1. 静态多态

静态多态是指在编译时就已经确定了函数的调用，也称为编译时多态。C++中实现静态多态的方式主要有函数重载和运算符重载。

函数重载是指在同一作用域内定义多个同名函数，但它们的参数列表不同。编译器根据传递给函数的参数类型和数量来确定调用哪个函数。例如：

void print(int num) {
    std::cout << "This is an integer: " << num << std::endl;
}

void print(double num) {
    std::cout << "This is a double: " << num << std::endl;
}

int main() {
    int a = 10;
    double b = 3.14;

    print(a);   // 调用第一个print函数
    print(b);   // 调用第二个print函数
}

运算符重载是指对C++中的运算符进行重新定义，使其能够用于自定义的数据类型。例如：

class Complex {
public:
    Complex(double real, double imag) : m_real(real), m_imag(imag) {}
    Complex operator+(const Complex& other) const {
        return Complex(m_real + other.m_real, m_imag + other.m_imag);
    }
private:
    double m_real;
    double m_imag;
};

int main() {
    Complex a(1.0, 2.0);
    Complex b(3.0, 4.0);

    Complex c = a + b;  // 调用Complex类中重载的+运算符
}

2. 动态多态

动态多态是指在运行时根据对象的实际类型来确定调用哪个函数，也称为运行时多态。C++中实现动态多态的方式主要有虚函数和纯虚函数。

虚函数是在父类中定义的可以被子类重写的函数，使用virtual关键字声明。当一个对象的指针或引用指向一个子类对象时，调用虚函数时会根据实际的对象类型来确定调用哪个函数。例如：

class Shape {
public:
    virtual void draw() {
        std::cout << "Drawing a shape." << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle." << std::endl;
    }
};

int main() {
    Shape* shape_ptr = new Circle();
    shape_ptr->draw();  // 调用Circle类中重写的draw函数
}

纯虚函数是在父类中定义的没有实现的虚函数，使用纯虚函数声明（如virtual void func() = 0;）。父类中包含纯虚函数的类称为抽象类，抽象类不能被实例化，只能作为基类来派生子类。子类必须实现父类的纯虚函数才能实例化。例如：

class Shape {
public:
    virtual void draw() = 0;
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle." << std::endl;
    }
};

int main() {
    Shape* shape_ptr = new Circle();
    shape_ptr->draw();  // 调用Circle类中重写的draw函数
}