# C++ 中的多态

> 原文： [https://beginnersbook.com/2017/08/cpp-polymorphism/](https://beginnersbook.com/2017/08/cpp-polymorphism/)

多态是 [OOP](https://beginnersbook.com/2017/08/cpp-oops-concepts/) 的一个特征，它允许对象在不同条件下表现不同。在 C++ 中，我们有两种类型的多态：

1）编译时多态 - 这也称为静态（或早期）绑定。

2）运行时多态 - 这也称为动态（或晚期）绑定。

## 1）编译时多态

函数重载和运算符重载是编译时多态的完美例子。

### 编译时多态示例

在这个例子中，我们有两个具有相同名称但参数数量不同的函数。根据我们在函数调用期间传递的参数确定要调用哪个函数，这就是为什么它被视为多态的一个例子，因为在不同的条件下输出是不同的。因为，在编译期间确定调用，这就是为什么它被称为编译时多态。

```cpp
#include <iostream>
using namespace std;
class Add {
public:
  int sum(int num1, int num2){
     return num1+num2;
  }
  int sum(int num1, int num2, int num3){
     return num1+num2+num3;
  }
};
int main() {
  Add obj;
  //This will call the first function
  cout<<"输出： "<<obj.sum(10, 20)<<endl;
  //This will call the second function
  cout<<"输出： "<<obj.sum(11, 22, 33);
  return 0;
}

输出：
```

```cpp
输出： 30
输出： 66
```

## 2）运行时多态

函数覆盖是运行时多态的一个例子。

**函数覆盖**：当子类声明一个已存在于父类中的方法时，这称为函数覆盖，这里子类覆盖父类。

在函数覆盖的情况下，我们有两个相同函数的定义，一个是父类，一个是子类。在**运行时**确定对函数的调用，以决定调用函数的哪个定义，这就是它被称为运行时多态的原因。

### 运行时多态的例子

```cpp
#include <iostream>
using namespace std;
class A {
public:
  void disp(){
     cout<<"Super Class Function"<<endl;
  }
};
class B: public A{
public:
  void disp(){
     cout<<"Sub Class Function";
  }
};
int main() {
  //Parent class object
  A obj;
  obj.disp();
  //Child class object
  B obj2;
  obj2.disp();
  return 0;
}
```

输出：

```cpp
Super Class Function
Sub Class Function
```