多态的实现有哪几种？

八股文_C++面向对象面试题 0 490

参考回答

在C++中，多态的实现可以分为两种类型：

编译时多态（静态多态）
- 通过 函数重载 和 运算符重载 实现。
- 在编译阶段确定调用哪个函数。
运行时多态（动态多态）
- 通过 虚函数 和 动态绑定 实现。
- 在运行阶段，根据实际对象类型调用相应的函数。

详细讲解与拓展

一、编译时多态（静态多态）

编译时多态是在编译阶段确定函数调用，主要通过以下两种方式实现：

函数重载（Function Overloading）

同一个作用域内，多个函数同名，但参数列表不同（参数的类型或个数不同）。
根据传入参数的类型或个数决定调用哪个函数。

示例：

class Math {
public:
   int add(int a, int b) { // 两个整数相加
       return a + b;
   }
   double add(double a, double b) { // 两个浮点数相加
       return a + b;
   }
};

int main() {
   Math math;
   cout << math.add(1, 2) << endl;         // 调用整数版，输出 3
   cout << math.add(1.5, 2.5) << endl;     // 调用浮点数版，输出 4.0
   return 0;
}

运算符重载（Operator Overloading）

对已有运算符重新定义功能，使其作用于自定义类型。
运算符重载是函数重载的一种特殊形式。

示例：

class Complex {
public:
   double real, imag;
   Complex(double r, double i) : real(r), imag(i) {}

   // 重载 '+' 运算符
   Complex operator+(const Complex &c) {
       return Complex(real + c.real, imag + c.imag);
   }
};

int main() {
   Complex c1(1.0, 2.0), c2(3.0, 4.0);
   Complex c3 = c1 + c2; // 使用重载的 '+' 运算符
   cout << "Result: " << c3.real << " + " << c3.imag << "i" << endl; // 输出 4.0 + 6.0i
   return 0;
}

二、运行时多态（动态多态）

运行时多态通过继承和 虚函数 实现，其关键在于 动态绑定。动态绑定是在程序运行时，根据对象的实际类型调用适当的方法，而不是在编译时决定。

实现条件：
1. 必须有继承，即子类继承父类。
2. 基类中的方法必须声明为 虚函数（virtual）。
3. 必须通过 父类的指针或引用 操作子类对象。

示例：

class Animal {
public:
    virtual void sound() { // 虚函数
        cout << "Animal makes a sound." << endl;
    }
};

class Dog : public Animal {
public:
    void sound() override { // 重写基类的虚函数
        cout << "Dog barks." << endl;
    }
};

class Cat : public Animal {
public:
    void sound() override {
        cout << "Cat meows." << endl;
    }
};

int main() {
    Animal* animal; // 父类指针
    Dog dog;
    Cat cat;

    animal = &dog;
    animal->sound(); // 输出 "Dog barks."

    animal = &cat;
    animal->sound(); // 输出 "Cat meows."
    return 0;
}

说明：
– 这里的 sound() 函数是虚函数，因此在运行时根据实际对象的类型（Dog 或 Cat）调用相应的函数。
– 如果去掉 virtual，则编译器在编译时就决定调用基类的 sound()，即会输出 "Animal makes a sound."。

动态多态的原理：虚函数表（vtable）

虚函数表：
当类中定义虚函数时，编译器为类生成一个虚函数表（vtable），表中存储该类虚函数的地址。每个对象通过一个隐藏的指针（vptr）指向虚函数表，从而实现动态绑定。
运行时决策：
在运行时，通过 vptr 找到对象的虚函数表，并调用适当的函数。

编译时多态与运行时多态的对比

特性	编译时多态	运行时多态
实现方式	函数重载、运算符重载	虚函数、动态绑定
绑定时间	编译阶段	运行阶段
灵活性	较低	较高
性能开销	无额外开销	有额外的虚函数表开销

总结

C++ 中多态有两种主要实现方式：
1. 编译时多态：通过函数重载和运算符重载，在编译阶段实现。
2. 运行时多态：通过虚函数和动态绑定，在运行阶段实现，具有更高的灵活性和扩展性。

这两种多态各有优缺点，通常结合使用，编译时多态适合性能敏感场景，运行时多态适合复杂系统的扩展设计。