C++ 中的多态

本文定义了 C++ 中的多态性，并列举了几种多态性。每个多态性类型都通过示例和源代码进行描述。教程中涵盖了编译时多态和运行时多态之间的区别。通过代码和示例来教授虚函数和纯虚函数的概念。

多态：它是什么？

多态性来源于“poly”（许多）和“morphs”（形式）这两个词，它们共同表示多种形式。当一个对象或函数在不同情况下表现不同时，这在 C++ 中称为多态性。消息能够以多种形式显示，这就是我们用简单的话来定义多态性的方式。一个人同时是父亲、配偶和雇员，会让人觉得他是一个人。因此，同一个人根据情况表现不同。这就是多态性。多态性是面向对象编程的关键组成部分之一。

让我们看一个真实的例子，说明“right”这个词在不同情况下可以有不同的含义。

• 你是对的。句子中的“Right”表示正确。
• 请向右转。在这个句子中，“right”一词指的是正确的方向。

C++ 中多态的简单示例

#include <bits/stdc++.h>
using namespace std;

int main() {
    int a = 20;
    int b = 50;
    
    cout << "Value of a + b is: " << a + b;
 return 0;
}
 

输出

Value of a + b is: 70

在上面的示例中，当使用运算符 + 组合值 a=20 和 b=50 时，输出值为 a + b 是 70。

但是，两个字符串操作数也可以使用 + 运算符进行连接。

#include <bits/stdc++.h>
using namespace std;

int main() {
    string a = "Poly";
    string b = "morphism";
    
    cout << "So a + b is: " << a + b;
 return 0;
}
 

输出

So a + b is: Polymorphism

在上面的示例中，a+b 的输出值是“Polymorphism”，因为 + 用于组合/连接字符串 a= Poly 和 b = morphism。

多态的类型

在 C++ 中，主要有两种多态性

1. 编译时多态
2. 运行时多态

1. 编译时多态

   编译时多态的另一个名称是静态绑定或早期绑定。通过重载运算符或函数，可以实现编译时多态。

   为什么将其称为编译时多态？

   仅仅通过比较参数的类型和参数的数量，就可以调用重载函数。编译器在编译期间可以访问这种数据。因此，C++ 编译器将在编译时选择适当的函数。

   C++ 中提供以下几类编译时多态

   

   函数重载

   当使用两个同名但参数不同的函数时，会根据参数的数量和类型调用不同的函数。这就是函数重载。

   以下两种情况可能导致函数重载

   • 这些函数同名且返回类型相同，但其参数类型不同。
   • 这些函数同名且返回类型相同，但其参数数量不同。

   函数重载的示例程序

   
   #include <bits/stdc++.h>
   using namespace std;
   class Temp
   {
       private:
           int x = 20;
           double x1 = 20.1;
       public:
           void add(int y)
           {
              cout << "The value of x + y is: " << x + y << endl;
           }
           // differ in the type of argument
           void add(double d)
           {
              cout << "Value of x1+d is: " << x1 + d << endl;
           }
           //differ in  number of arguments
           void add(int y, int z)
           {
              cout << "The value of x+y+z is: " << x + y + z << endl;
           }
   };
   int main() {
       Temp t1;
       t1.add(20);
       t1.add(20.1);
       t1.add(13,14);
    
       return 0;
   }
    
   

   输出

   
   The value of x + y is: 40
   Value of x1+d is: 40.2
   The value of x+y+z is: 47
   

   程序解释

   上述示例中的 add 函数被重载。对象 t1 属于类 Temp。Add (20)。这将调用 void add (int y)。t1.add(20.1) 将调用 void add (double d)。t1.add(13,14) 将调用 void add (int y, int z)。当类型和参数数量匹配时，将调用重载函数。编译器选择适当的函数，因为此信息在编译时可用。

   运算符重载

   运算符重载是指更新运算符以支持用户定义的数据类型（对象等）。为了使用运算符重载，至少一个操作数必须是用户定义的数据类型。

   C++ 中可以重载的一些操作如下

   算术运算符: -, +, /, *,% 和 -=, +=, /=, *=, %=

   布尔代数 : !=, ==, >, <, >=, <=, &&, ||

   位操作: &, |, ^, <<, >>, 和 |=, &=, >>=, <<=, ^=

   内存管理: new[], delete[], delete, new

   运算符重载的示例程序

   
   #include<iostream>
   using namespace std;
   
   class Count
   {
       int x;
       public:
        //  constructor
       Count(int X = 0)
       {
           this -> x = X;
       }
       // Overloading the ++ operator
       Count operator++()
       {
          Count c ;
          
          c.x = ++x;
          
          return c;
       }
       // print value of x
       void print()
       {
           cout << x << endl;
       }
       
   };
   
   int main()
   {
       Count c1(22);
       
       cout << "So before using ++ operator: ";
       c1.print();
       
       Count c2 = ++c1;
       cout << "So after using ++ operator: ";
       c2.print();
       
   }
    
   

   输出

   
   So before using ++ operator: 22
   So after using ++ operator: 23
   

   程序解释

   在上面的示例中，++ 运算符被重载用于用户定义的数据类型，以及 Count 类的一个对象。

   Count c1(22); 生成一个 Count 类型的对象，其数据成员 x 将设置为 22。

   Count c2 = ++c1，它在 t1 上调用 ++ 运算符函数并将 x 设置为 23。

2. 运行时多态

   

   当函数在运行时而不是编译时被调用，或者当对重写方法的调用在运行时而不是编译时动态解析时，这种现象被称为运行时多态。它通常被称为动态绑定或后期绑定。

   函数重写和虚函数相结合以创建运行时多态。虚函数的完整概念将在下一个教程中讨论。

编译时多态与运行时多态

结论

在 C++ 中，多态性指的是当同一个对象或函数在不同情况下表现不同。它有两种类型：编译时和运行时。

编译时要调用的函数只在编译时确定。它通过重载函数或运算符来实现。

编译时调用的函数在运行时确定。它通过函数重写和虚函数来实现。