C++多态：同一个方法做不同的事情

coolBetter233

已于 2024-08-15 21:22:02 修改

阅读量97

点赞数 3

文章标签： c++

于 2024-07-25 13:46:37 首次发布

本文链接：https://blog.csdn.net/m0_70445737/article/details/140687778

版权

C++ 中的多态是面向对象编程的核心特性之一，允许使用相同的接口来处理不同类型的对象，从而实现代码的灵活性和可扩展性。

1. 静态多态（编译时多态）

静态多态在编译时确定，主要通过函数重载和模板实现。

函数重载（Function Overloading）：

同名函数根据参数的个数、类型或顺序不同来实现多态。
在编译时根据函数参数类型选择调用哪个函数。

示例：

#include <iostream>
void print(int x) {
    std::cout << "Integer: " << x << std::endl;
}
void print(double x) {
    std::cout << "Double: " << x << std::endl;
}

int main() {
    print(10);    // 调用 print(int)
    print(10.5);  // 调用 print(double)
    return 0;
}

模板（Templates）：

模板允许编写通用代码，使得函数或类可以适用于不同的数据类型，提供一种泛型编程的方式。

示例：

#include <iostream>
template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(3, 4) << std::endl;       // 调用 int 版
    std::cout << add(3.5, 4.2) << std::endl;   // 调用 double 版
    return 0;
}

运算符重载（Operator Overloading）：

运算符重载是允许为自定义类型定义新的行为的方式，使得对象能像内置类型一样进行运算。

示例：

#include <iostream>
class Complex {
public:
    int real, imag;
    Complex(int r, int i) : real(r), imag(i) {}

    Complex operator + (const Complex& c) {
        return Complex(real + c.real, imag + c.imag);
    }
};

int main() {
    Complex c1(1, 2), c2(2, 3);
    Complex c3 = c1 + c2;  // 运算符重载
    std::cout << "Sum: " << c3.real << " + " << c3.imag << "i" << std::endl;
    return 0;
}

2. 动态多态（运行时多态）

动态多态是在程序运行时决定的，主要通过虚函数（virtual）机制来实现。通过继承和虚函数，子类可以重写父类中的虚函数，使得同一个函数在不同的对象中表现不同的行为。

虚函数（Virtual Functions）：

在基类中定义虚函数，派生类可以重写该虚函数。
当通过基类指针或引用调用虚函数时，根据实际指向的对象类型决定调用哪个版本的函数（即实现动态绑定）。

关键字：

virtual：用于基类函数声明，表示该函数可以在派生类中重写。
override：用于派生类函数声明，显式表明该函数覆盖了基类的虚函数（C++11 引入，增强代码可读性）。

示例：

#include <iostream>

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

class Derived : public Base {
public:
    void show() override {  // 派生类重写虚函数
        std::cout << "Derived class show" << std::endl;
    }
};

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

    basePtr->show();  // 动态绑定，调用 Derived::show()
    return 0;
}

纯虚函数（Pure Virtual Functions）：

纯虚函数是没有具体实现的虚函数，在基类中声明，派生类必须重写它。
含有纯虚函数的类称为抽象类，不能实例化，只能用作基类。

语法：

virtual void function() = 0;  // 纯虚函数

示例：

#include <iostream>

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override {  // 必须重写纯虚函数
        std::cout << "Drawing Circle" << std::endl;
    }
};

int main() {
    Shape* shape = new Circle();
    shape->draw();  // 调用派生类的实现
    delete shape;
    return 0;
}

虚析构函数：

如果一个类中含有虚函数，且希望通过基类指针删除派生类对象时，确保正确调用派生类的析构函数，就需要将基类的析构函数声明为虚函数。

示例：

#include <iostream>

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

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

int main() {
    Base* basePtr = new Derived();
    delete basePtr;  // 调用基类虚析构函数，确保派生类析构函数被调用
    return 0;
}