C++中多态实现的关键——虚函数

1.多态的作用

在面向对象程序设计中，使用多态能够增强代码的可扩充性，，即程序需要增加或修改部分功能时，只需修改少量代码就能够达到目的，此外多态也能起到精简代码的作用。

而实现多态的关键点，就是虚函数如何使用。

虚函数

1.虚函数的使用方法

.基同类与派生类同时拥有的同名同参数表的函数，在设计时，最好将其声明为虚函数，只需在函数前面加上关键字virtual即可

下面通过一个具体的例子来说明

#include<iostream>
using namespace std;
class Shape{
    public:
     void Printf(){
     cout<<" The Shape has been called"<<endl;
     }
};
class Rectangle:public Shape{
    public:
       void Printf(){
       cout<<"The Rectangle has been called"<<endl;
       }

};
class Circle:public Shape{
       public:
       void Printf(){
       cout<<"he Circle has been called"<<endl;

       }
};
void Print(Shape &a)
{

    a.Printf();
}
void Print(Rectangle &a)
{

    a.Printf();
}
void Print(Circle &a)
{

    a.Printf();
}
int main()
{
    Shape a;
    Rectangle b;
    Circle c;
    Print(a);
    Print(b);
    Print(c);
    return 0;
}

以上程序定义了一个基类Shape 派生出了Rectangle 和 Circle

又定义了三个全局函数用来输出Shape 和Rectangle ,Circle

程序运行结果如下

可以看出三个Print（）除了参数，其他完全一样，因此需要一种方法，将Printf()的参数表变得足够灵活，能够同时识别Shape Rectngle Circle

这个时候就可以用到虚函数

具体如下

#include<iostream>
using namespace std;
class Shape{
    public:
     virtual void Printf(){
     cout<<" The Shape has been called"<<endl;
     }
};
class Rectangle:public Shape{
    public:
       void Printf(){
       cout<<"The Rectangle has been called"<<endl;
       }

};
class Circle:public Shape{
       public:
       void Printf(){
       cout<<"he Circle has been called"<<endl;

       }
};
void Print(Shape &a)
{

    a.Printf();
}

int main()
{
    Shape a;
    Rectangle b;
    Circle c;
    Print(a);
    Print(b);
    Print(c);
    return 0;
}

可以看出，将三个Prinft()函数简化为了一个，而且参数类型为基类的引用

而且在调用时将三种不同的参数类型传入Printf()也不会报错，程序运行结果也是对的

这说明Printf(）声明为虚函数后,能够被基类对象正确识别。

并且使用虚函数可以大大简化代码量

2虚函数的识别原理

实际上，对于任何一个含有虚函数，或者其基类含有虚函数的类来说，在其对象的存储空间的最前端，都有一个虚函数表，该虚函数表中存储着该对象的虚函数的地址

多态的函数调用语句被被编译成个根据基类指针或引用所指向的对象中存放的虚函数表的地址，在虚函数表中查询虚函数地址，并调用虚函数的一系列指令

3.虚析构函数

先运行如下程序

#include<iostream>
using namespace std;
class A
{
public:
    ~A(){
    cout<<"A destructor"<<endl;
    };

};
class B:public A{

public:
    ~B(){
    cout<<"B destructor"<<endl;
    };
};
int main()
{
    A *p=new B;
    delete p;
    return 0;
}

程序的运行结果说明 最后一句delete p,并没有释放掉B的内存，而只释放掉了A的内存，只引发了A的析构函数被调用，被没有调用B的析构函数

这是因为这条语句是静态联编的，编译器进行到delete p 这一句时，并不知道p此时到底指向的是哪个对象，所以只能根据p的类型是A *来调用A的析构函数，

我们希望delete p这样的语句能够足够智能的根据p所指向的对象来执行相应的析构函数

那么将析构函数声明为虚析构函数是一种有效的解决方式

#include<iostream>
using namespace std;
class A
{
public:
    virtual ~A(){
    cout<<"A destructor"<<endl;
    };

};
class B:public A{

public:
    ~B(){
    cout<<"B destructor"<<endl;
    };
};
int main()
{
    A *p=new B;
    delete p;
    return 0;
}

将基类析构函数声明为虚函数后

程序运行结果如下

类B的析构函数被正确调用，说明开辟的类B的空间被释放掉