C++ 多态性

“多态性”一词是“poly”和“morphs”的组合，意思是“许多形式”。这是一个希腊词。在面向对象编程中，我们使用三个主要概念：继承、封装和多态性。

多态性的现实生活例子

让我们考虑一个多态性的现实生活例子。一个女士在教室里表现得像一位教师，在家里像母亲或女儿，在市场上像顾客。在这里，一个人根据不同的情况表现得不同。

C++中有两种类型的多态性：

C++ 多态性

编译时多态 ：重载函数通过匹配参数的类型和数量来调用。这些信息在编译时是可用的，因此编译器在编译时选择适当的函数。这是通过函数重载和运算符重载实现的，也被称为静态绑定或早期绑定。现在，让我们考虑函数名和原型相同的情况。

   class A                                  //  base class declaration.
  {
       int a;
       public:
       void display()
       { 
             cout<< "Class A ";
        }
  };
class B : public A                       //  derived class declaration.
{
    int b;
    public:
   void display()
  {
        cout<<"Class B";
  }
};

在上述情况中，display()函数的原型在基类和派生类中是相同的。因此，静态绑定无法应用。如果能在运行时选择适当的函数，就太好了。这就是所谓的运行时多态性。

运行时多态性 ：当对象的方法在运行时而不是编译时调用时，就实现了运行时多态性。这是通过方法重写实现的，也称为动态绑定或迟绑定。

编译时多态性和运行时多态性之间的区别。

编译时多态性	运行时多态性
在编译时已知要调用的函数。	在运行时已知要调用的函数。
也称为重载、早期绑定和静态绑定。	也称为重写、动态绑定和晚期绑定。
重载是一种编译时多态性，多个方法具有相同的名称，但参数的数量或类型不同。	重写是一种运行时多态性，多个方法具有相同的名称、参数的数量和类型。
它通过函数重载和操作符重载实现。	它通过虚函数和指针实现。
它在编译时已知，因此执行速度快。	它在运行时已知，因此执行速度慢。
它不太灵活，因为大部分事情在编译时执行。	它更加灵活，因为所有的事情都在运行时执行。

C++运行时多态示例

让我们来看一个C++中运行时多态的简单示例。

//没有使用virtual关键字的示例。

#include <iostream>  
using namespace std;  
class Animal {  
    public:  
void eat(){    
cout<<"Eating...";    
    }      
};   
class Dog: public Animal    
{    
 public:  
 void eat()    
    {           cout<<"Eating bread...";    
    }    
};  
int main(void) {  
   Dog d = Dog();    
   d.eat();  
   return 0;  
}

输出:

Eating bread...

C++运行时多态的示例：使用两个派生类

让我们看一个C++中运行时多态的另一个示例，其中我们有两个派生类。

//一个使用虚关键字的示例。

#include <iostream>  
using namespace std;  
class Shape {                                        //  base class
    public:  
virtual void draw(){                             // virtual function
cout<<"drawing..."<<endl;    
    }      
};   
class Rectangle: public Shape                  //  inheriting Shape class.
{    
 public:  
 void draw()    
   {    
       cout<<"drawing rectangle..."<<endl;    
    }    
};  
class Circle: public Shape                        //  inheriting Shape class.

{    
 public:  
 void draw()    
   {    
      cout<<"drawing circle..."<<endl;    
   }    
};  
int main(void) {  
    Shape *s;                               //  base class pointer.
    Shape sh;                               // base class object.
       Rectangle rec;  
        Circle cir;  
      s=&sh  
     s->draw();   
        s=&rec  
     s->draw();    
    s=?  
    s->draw();   
}

输出结果：

drawing...
drawing rectangle...
drawing circle...

运行时多态性与数据成员

在C++中可以通过数据成员实现运行时多态性。让我们看一个例子，通过引用变量访问字段，该引用变量引用了派生类的实例。

#include <iostream>  
using namespace std;  
class Animal {                                          //  base class declaration.
    public:  
    string color = "Black";    
};   
class Dog: public Animal                       // inheriting Animal class.
{    
 public:  
    string color = "Grey";    
};  
int main(void) {  
     Animal d= Dog();    
    cout<<d.color;   
}

输出：