多态的概念和意义

在之前同名覆盖引发问题的那一篇文章,我们说过了编译器在同名覆盖中所作的行为并不是我们期望的行为,面向对象中期望的行为是根据实际的对象类型判断如何调用重写函数,期望做到父类指针(引用)指向父类对象则调用父类中定义的函数,指向子类对象则调用子类中定义的重写函数,不要根据指针类型去调用,要根据指针指向的对象类型去调用,现在我们引入多态的概念

要实现多态,就需要用到virtual关键字对多态进行支持,被virtual声明的函数被重写后具有多态特性,另外,被virtual声明的函数叫做虚函数

sice@sice:~$ ./a.out 
I'm Parent.
I'm Child.
sice@sice:~$ cat a.cpp
#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    virtual void print()
    {
        cout << "I'm Parent." << endl;
    }
};

class Child : public Parent
{
public:
    virtual void print()
    {
        cout << "I'm Child." << endl;
    }
};

void how_to_print(Parent* p)
{
    p->print();     // 展现多态的行为
}

int main()
{
    Parent p;
    Child c;
    
    how_to_print(&p);    
    how_to_print(&c);    
    
    return 0;
}

结果:

sice@sice:~$ ./a.out 
I'm Parent.
I'm Child.

可以看出我们加入virtual后父类中的print变成虚函数,编译器能根据指针实际指向的实际对象调用相应的print函数实现了多态,函数重写必须多态实现,否则没有意义

#include <iostream>
#include <string>
using namespace std;
class Parent
{
  public:
  void fun(int i)
  {
    cout<<"fun(int i) in Parent: "<<i<<endl;
  }
  void fun(int a,int b)
  {
    cout<<"fun(int a,int b) in Parent :"<<a<<b<<endl;
  }
  virtual void printf()
  {
    cout<<"in the Parent"<<endl;   
  }
};
class Child : public Parent
{
  public:
  void fun(int i)
  {
    cout<<"fun(int i): in Child "<<i<<endl;
  }
  void fun(int a,int b)
  {
    cout<<"fun(int a,int b): Child"<<a<<b<<endl;
  }
  void printf()
  {
    cout<<"in the child"<<endl;
    
  }
};
void print(Parent * obj)
{
 obj->printf();
}
int main()
{
   Child c;
   c.fun(1);//静态联编
   c.fun(2,3);//静态联编
   
   Parent p;
   p.fun(4);//静态联编
   p.fun(5,6);//静态联编

   print(&c);//动态联编
   return 0;
}

结果:

sice@sice:~$ ./a.out 
fun(int i): in Child 1
fun(int a,int b): Child23
fun(int i) in Parent: 4
fun(int a,int b) in Parent :56
in the child