多态与虚函数

多态的基本概念

实现了多态机制的程序，可以使用同一个名字完成不同的功能。

多态分为编译时多态和运行时多态。

多态

静态多态在编译期间就可以确定函数的调用地址，并产生代码。

函数调用与代码入口地址的绑定需要在运行时刻才能确定，称为动态联编或动态绑定。

在类之间满足赋值兼容的前提下，实现动态绑定必须满足以下两个条件

• 必须声明虚函数
• 通过基类类型的引用或者指针调用虚函数。

虚函数

所谓虚函数，就是在函数声明时前面加了virtual关键字的成员函数。
声明虚函数成员的格式

virtual 函数返回值类型 函数名(形参表);

通过基类指针实现多态

程序6-1 通过基类指针实现多态示例

#include 
using namespace std;

class A
{
    public:
        virtual void Print()
        {
            cout<<"A::Print"<Print();        //多态，目前指向基类对象，调用a.Print(),输出A::Print
    pa = pb;            //派生类指针赋给基类指针，pa指向派生类对象b
    pa->Print();        //多态，目前指向派生类对象，调用b.Print(),输出B::Print
    pa = &d;            //基类指针pa指向派生类对象d
    pa->Print();        //多态，目前指向派生类对象，调用d.Print(),输出D::Print
    pa = &e;            //基类指针pa指向派生类对象e
    pa->Print();        //多态，目前指向派生类对象，调用e.Print(),输出E::Print
    return 0; 
}

A::Print
B::Print
D::Print
E::Print

程序6-2 用基类指针访问基类对象及派生类对象

#include 
#include 
using namespace std;
class A
{
    public:
        void put_name(string s)
        {
            name = s;
        }
        virtual void print_name() const
        {
            cout<<"A::"<put_name("多态示例_名字");       //赋给基类对象A_obj
    cout<<"A_p->print_name的输出内容：\t";
    A_p->print_name();          //使用指针输出，A_obj中的值
    cout<<"A_obj.print_name()的输出内容：\t";
    A_obj.print_name(); //使用对象输出
    
    A_p = &B_obj;       //基类指针指向派生类对象 
    A_p->put_name("另一个名字");     //多态，赋给派生类对象B_obj 
    cout<<"A_p->print_name()的输出内容：\t";
    A_p->print_name();      //多态，使用指针输出，B_obj中的值，继承的name的值 
    cout<<"B_obj.print_name()的输出内容：\t";
    B_obj.print_name();     //使用对象输出，B_obj中的值，继承的name值 
    B_obj.put_phone("电话号码999"); //派生类对象赋值 
    
    cout<<"((B *)A_p)->print_phone()的输出内容：\t";
    ((B*)A_p)->print_phone();   //强制转换基类指针，输出的是派生类对象中的值 
    cout<<"B_obj.print_phone()的输出内容：\t\t";
    B_obj.print_phone();    //输出的是派生类对象中的值 
    return 0; 
}

A_p->print_name的输出内容：     A::多态示例_名字
A_obj.print_name()的输出内容：  A::多态示例_名字
A_p->print_name()的输出内容：   B::另一个名字,另一个名字
B_obj.print_name()的输出内容：  B::另一个名字,另一个名字
((B *)A_p)->print_phone()的输出内容：   电话号码999
B_obj.print_phone()的输出内容：         电话号码999

通过基类引用实现多态

通过基类指针调用虚函数时可以实现多态，通过基类的引用调用虚函数的语句也是多态的。

程序6-3 基类引用实现多态

#include 
using namespace std;

class A
{
    public:
        virtual void Print()
        {
            cout<<"A::Print"<

*多态的实现原理

多态的关键在于通过基类指针或引用调用一个虚函数时，编译阶段不能确定到底调用的时基类还是派生类的函数，运行时才能确定。

程序6-4 多态机制下对象存储空间的大小

#include 
using namespace std;

class A
{
    public:
        int i;
        virtual void func(){}
        virtual void func2(){}
};

class B:public A
{
    int j;
    void func(){}
};

int main()
{
    cout<

多态实例

在面向对象的程序设计中，使用多态能够增强程序的可扩充性。

使用多态也能起到精简代码的作用。

程序6-5 使用多态出来图形示例

#include 
#include 
using namespace std;

class CShape        //基类：图形类 
{
    protected:
        double acreage;     //图形的面积，子类可以访问
    public:
        CShape()
        {
//          cout<<"基类构造函数"<a = a;
            this->b = b;
            this->c = c;
        };
        CTriangle()
        {
//          cout<<"三角形无参构造函数"<a<<","<b<<","<c<<",面积="<acreage<>n;
    for(i=0;i>c;
        switch(c)
        {
            case 'R':case 'r':      //矩形
                cin>>temp1>>temp2;
                pr = new CRectangle(temp1,temp2);
                pr->setAcreage(pr->CalAcr());
                pShapes[i] = pr;
                break;
            case 'C':case 'c':
                cin>>temp1;         //圆形
                pc = new CCircle(temp1);
                pc->setAcreage(pc->CalAcr());
                pShapes[i] = pc;
                break;
            case 'T':case 't':      //三角形
                cin>>temp1>>temp2>>temp3;
                pt = new CTriangle(temp1,temp2,temp3);
                pt = new CTriangle(temp1,temp2,temp3);
                pt->setAcreage(pt->CalAcr());
                pShapes[i]= pt;
                break; 
        }   
    }   
    if(n == 1) cout<<"共有"<PrintInfo();
        delete pShapes[i];      //释放空间 
    }
    return 0; 
} 

3
C 6
R 7.6 8.2
T 3 4 5
共有3种图形，分别是：
圆。    半径=6,面积=113.04
矩形。  宽度=7.6,高度=8.2,面积=62.32
三角形。三条边分别是：3,4,5,面积=6

多态的使用

类的成员函数直接按可以互相调用。

在普通成员函数(静态成员函数、构造函数和析构函数除外)中调用其他虚成员函数也是允许的，并且是多态的。
程序6-6 在成员函数中调用虚函数

#include 
using namespace std;
class CBase
{
    public:
        void func1()        //不是虚函数
        {
            cout<<"CBase::func1()"<

程序6-7 在构造函数与析构函数中调用虚函数

#include 
using namespace std;
class A
{
    public:
        virtual void hello()
        {
            cout<<"A::hello"<

实现多态时，必须满足的条件是：使用基类指针或引用来调用基类中声明的虚函数。

程序6-8 多态与非多态的对比

#include 
using namespace std;

class A
{
    public:
        void func1()
        {
            cout<<"A::func1"<func2();    //多态 
    pa->func1();    //不是多态 
    pb->func1();    //多态 
    return 0;
}

C::func2
A::func1
C::func1

虚析构函数

声明虚析构函数的格式

virtual ~类名();

虚析构函数没有返回值类型，没有参数。

如果一个类的析构函数是虚函数，则由它派生的所有子类的析构函数也是虚析构函数。

程序6-9 不使用虚析构函数的情况

#include 
using namespace std;
class ABase
{
    public:
        ABase()
        {
            cout<<"ABase 构造函数"<

改写，将基类析构函数修改为虚析构函数。

virtual ~ABase()
        {
            cout<<"ABase 析构函数"<

纯虚函数喝抽象类

纯虚函数

纯虚函数是声明在基类中的虚函数，没有具体的定义，而由各派生类根据识记需要给出各自的定义。

声明纯虚函数的格式

virtual 函数类型 函数名(参数表)  = 0;

抽象类

包含纯虚函数的类称为抽象类。

纯虚函数和函数体为空的虚函数的区别：

• 纯虚函数没有函数体，而空的虚函数的函数体为空。
• 纯虚函数所在的类是抽象类，不能直接进行实例化；而空的虚函数所在的类是可以实例化的。
  共同特点是：都可以派生出新的类，然后在新类中给出虚函数的实现，而且这种新的实现具有多态特征。

程序6-10 抽象类示例

#include 
using namespace std;

class A
{
    private:
        int a;
    public:
        virtual void print() = 0;
        void func1()
        {
            cout<<"A_func1"<print();
    B b;
    A *pc = &b;
    pc->func1();
    return 0;
}

B_print
A_func1

虚基类

定义虚基类的格式

class 派生类名 : virtual 派生方式 基类名
{
  派生类体
};

程序6-11 虚基类

#include 
using namespace std;
class A
{
    public:
        int a;
        void showa()
        {
            cout<<"a="<