多态性与虚函数

客官°小女子只卖身不卖艺 2021-12-10 11:31 251阅读 0赞

## 多态性 ##

1.  所谓多态性就是不同对象收到相同的信息时，产生不同的动作。直观地说，多态性是指用一个名字定义的不同函数，这些函数执行不同但又类似的操作，从而可以使用相同的方式来调用这些具有不同功能的同名函数。在C++中，可以利用多态性的特征，用相同的函数名来标识这些函数。这样，就可以达到用同样的接口访问不同功能的函数，从而实现“一个接口，多种方法”。
2.  从实现的角度来讲，多态可以划分为两类：编译时的多态和运行时的多态。在C++中，多态的实现和连编这一概念有关。所谓连编就是把函数名与函数体的程序代码连接在一起的过程。静态连编就是在编译阶段完成的连编。编译时的多态是通过静态连编来实现的。
3.  静态连编时，系统用实参与形参进行匹配，对于同名的重载函数便根据参数上的差异进行区分，然后进行连编，从而实现了多态性。运行时的多态是用动态连编实现的。动态连编是运行阶段完成的连编。即当程序调用到某一函数名时，才去寻找和连接其程序代码，对面向对象程序设计而言，就是当对象接受到某一消息时，才去寻找和连接相应的方法。一般而言，编译型语言采用静态连编，而解释性语言采用动态连编。静态连编要求在程序编译时就知道调用函数的全部信息，而动态连编方式恰好相反，一直要到程序运行时才能确定调用哪个函数，它降低了程序的运行效率，但增强了程序的灵活性。
4.  纯粹的面向对象程序语言由于其执行机制是消息传递，所以只能采用动态连编，这就给基于C语言的C++带来了麻烦。因为，为了保持C语言的高效性，C++仍是编译型的，仍采用静态连编。好在C++的设计者想出了虚函数的机制，解决了这个问题。利用虚函数机制，C++可部分地采用动态连编。这就是说，C++实际上是采用了静态连编和动态连编相结合的连编方法。**在C++中，编译时多态性主要是通过函数重载和运算符重载实现的；运行时多态主要是通过虚函数实现的。**

## 虚函数 ##

虚函数的定义是在基类中进行的，它是在基类中需要定义为虚函数的成员函数的声明中冠以关键字virtual，从而提供一种接口界面。定义虚函数的方法如下：

virtual 返回类型 函数名(形参表)
    {
        
       函数体
    }

在基类中的某个成员函数被声明为虚函数后，此虚函数就可以在一个或多个派生类中被重新定义。虚函数在派生类中重新定义是，其函数原型，包括返回类型，函数名，参数个数，参数类型的顺序，都必须与基类中的原型完全相同。

#include<iostream>
    #include<string>
    using namespace std;
    class Student
    {
        
    public:
        Student(string name="科目"):subjects(name){
        }
        string getname()
        {
        
            return subjects;
        }
        virtual void like()
        {
        
            cout<<"每个人都有喜欢的"<<getname()<<endl;
        }
    private:
        string subjects;
    };
    class Xiaoming:public Student
    {
        
    public:
        Xiaoming(string name="英语"):Student(name){
        }
        void like()
        {
        
            cout<<"小明喜欢"<<getname()<<endl;
        }
    };
    class Xiaoliang:public Xiaoming
    {
        
    public:
        Xiaoliang(string name="数学"):Xiaoming(name){
        }
        void like()
        {
        
            cout<<"小亮喜欢"<<getname()<<endl;
        }
    };
    class Xiaohui:public Xiaoliang
    {
        
    public:
        Xiaohui(string name="语文"):Xiaoliang(name){
        }
        void like()
        {
        
            cout<<"小辉喜欢"<<getname()<<endl;
        }
    };
    
    int main()
    {
        
        Student *ptr;
        Student st;
        Xiaoming xm;
        Xiaoliang xl;
        Xiaohui xh;
        ptr=&st;
        ptr->like();
        ptr=&xm;
        ptr->like();
        ptr=&xl;
        ptr->like();
        ptr=&xh;
        ptr->like();
        return 0;
    }

程序在基类Student中显式定义了like()为虚函数。C++规定，如果在派生类中，没有用virtual显式地给出虚函数声明，这时系统就会遵循以下的规则来判断一个成员函数是不是虚函数：  
①。该函数与基类的虚函数胡有相同的名称  
②。该函数与基类的虚函数有相同的参数个数及相同的对应参数类型  
③。该函数与基类的虚函数有相同的返回类型或者满足赋值兼容规则地指针，引用型的返回类型  
派生类的函数满足了上述条件，就被自动确定为虚函数。因此，在本程序的派生类Xiaoming中like()为虚函数，并且在类Xiaoming的派生类Xiaoliang中like()和类Xiaoliang的派生类Xiaohui中like()还是虚函数。  
下面对虚函数的定义做几点说明：  
①。由于虚函数使用的基础是赋值兼容规则，而赋值兼容规则成立的前提条件是派生类从其基类公有派生。因此，通过定义虚函数来使用动态类机制时，派生类必须从它的基类公有派生。  
②。必须首先在基类中定义虚函数。由于基类与派生类是相对的，因此，这项说明并不表明必须在类等级的最高层中声明虚函数。在实际应用中，应该在类等级内需要具有动态多态性的几个层次中的最高层类内首先声明虚函数。  
③。在派生类对基类中声明的虚函数进行重新定义时，关键字virtual可以写也可以不写。但在容易引起混乱的情况下，最好在对派生类的虚函数进行重新定义时也加上关键字virtual。  
④。虽然使用对象名和点运算符的方式也可以调用虚函数，如语句：xm.like();可以调用虚函数Xiaoming::like()。但是，这种调用是在编译时进行的静态连编，它没有充分利用虚函数的特性，只有通过基类指针访问虚函数时才能获得运行时的多态性。  
⑤。一个虚函数无论被公有继承多少次，它仍然保持其虚函数的特性。  
⑥。虚函数必须是其所在类的成员函数，而不能是友元函数，也不能是静态成员函数，因为虚函数调用要靠特定的对象来决定该激活哪个函数。  
⑦。内联函数不能是虚函数，因为内联函数是不能在运行中动态确定其位置的。即使虚函数在类的内部定义，编译时仍将其看作非内联的。  
⑧。构造函数不能是虚函数，但是析构函数可以是虚函数，而且通常说明为虚函数。

## 虚析构函数 ##

#include<iostream>
    #include<string>
    using namespace std;
    class Base
    {
        
    public:
        ~Base()
        {
        
            cout<<"调用基类Base的析构函数"<<endl;
        };
    };
    
    class Derived:public Base
    {
        
    public:
        ~Derived()
        {
        
            cout<<"调用派生类Derived的析构函数"<<endl;
        };
    };
    
    int main()
    {
        
        Base *p;
        p=new Derived;
    
        delete p;
        return 0;
    }

当用delete运算符撤销无名对象时，系统只执行基类的析构函数，而不执行派生类的析构函数。  
原因是当撤销指针p所指的派生类的无名对象，而调用析构函数时，采用了静态连编方式，只调用了基类Base的析构函数。如果希望程序执行动态连编方式，在用delete运算符撤销派生类的无名对象时，先调用派生类的析构函数，再调用基类的析构函数，可以将基类的析构函数声明为虚析构函数，由该基类所派生的所有派生类的析构函数也都自动成为虚函数。

#include<iostream>
    #include<string>
    using namespace std;
    class Base
    {
        
    public:
        virtual ~Base()
        {
        
            cout<<"调用基类Base的析构函数"<<endl;
        };
    };
    
    class Derived:public Base
    {
        
    public:
        ~Derived()
        {
        
            cout<<"调用派生类Derived的析构函数"<<endl;
        };
    };
    
    int main()
    {
        
        Base *p;
        p=new Derived;
    
        delete p;
        return 0;
    }

## 虚函数与重载函数的关系 ##

在一个派生类中重新定义基类的虚函数是函数重载的另一种形式，但它不同于一般的函数重载。  
普通的函数重载时，其函数的参数或参数类型必须有所不同，函数的返回类型也可以不同。但是，当重载一个函数时，也就是说**在派生类中重新定义虚函数时，要求函数名，返回类型，参数个数，参数的类型和顺序与基类中的虚函数原型完全相同**。如果仅仅返回类型不同，其余均相同，系统会给出错误信息；若仅仅函数名相同，而参数的个数，类型或顺序不同，系统将它作为普通函数的重载函数，这时将丢失虚函数的特性。

## 多继承与虚函数 ##

多继承可以视为多个单继承的组合。因此，多继承情况下的虚函数调用与单继承情况下的虚函数调用有相似之处。

#include<iostream>
    using namespace std;
    class A1
    {
        
    public:
        virtual void fun()
        {
        
            cout<<"-----A1-----"<<endl;
        }
    };
    class A2
    {
        
    public:
    
        void fun()
        {
        
            cout<<"-----A2-----"<<endl;
        }
    };
    class B:public A1, public A2
    {
        
    public:
        void fun()
        {
        
            cout<<"------B-----"<<endl;
        }
    };
    int main()
    {
        
        A1 obj1,*ptr1;
        A2 obj2,*ptr2;
        B obj3;
        ptr1=&obj1;
        ptr1->fun();
        ptr1=&obj3;
        ptr1->fun();
        ptr2=&obj2;
        ptr2->fun();
        ptr2=&obj3;
        ptr2->fun();
        return 0;
    }

从程序运行结果可以看出，由于派生类B中的函数fun()有不同的继承路径，所以呈不同的性质。相对于类A1的派生路径，由于类A1中的fun()是虚函数，当声明为指向类A1的指针指向派生类B的对象obj3时，函数fun()呈现出虚特性。因此，此时的"ptr->fun();"调用的是B::fun()函数，相对于A2的派生路径，由于类A2中的fun()是一般成员的函数，所以此时它只能是一个普通的重载函数。当声明为指向类A2的指针指向类B的对象obj3时，函数fun()只呈现普通函数的重载特性。因此，此时的"ptr->fun();"调用的是A2::fun()函数。

## 纯虚函数和抽象类 ##

**纯虚函数**  
有时，基类往往表示一种抽象的概念，它并不与具体的事物相联系。这时在基类中将某一成员函数定义为虚函数，并不是基类本身的要求，而是考虑到派生类的需要，在基类中预留了一个函数名，具体功能留给派生类根据需要去定义。Circle是一个基类，它表示具有封闭图形的东西。从Circle可以派生出三角形类，矩形类和圆类。在这个类等级中基类Circle体现了一个抽象的概念，在基类Circle中定义一个求面积的函数显然是无意义的，但是可以将其说明为虚函数，为它的派生类提供一个公共的界面，各派生类根据所表示的图形的不同重定义这些虚函数，以提供求面积的各自版本。  
纯虚函数是在声明虚函数时被“初始化”为0的函数。声明纯虚函数的一般形式如下：

virtual void show_area()=0;

声明为纯虚函数之后，基类中就不再给出函数的实现部分。纯虚函数的作用是在基类中为其保留一个函数的名字，以便派生类根据需要对它进行重新定义。纯虚函数没有函数体，不具备函数的功能，不能被调用。

#include<iostream>
    using namespace std;
    class Rectangle
    {
        
    public:
        void setSide(int w,int h)
        {
        
            width=w;
            height=h;
        }
        virtual void show()=0;
    protected:
        int width;
        int height;
    };
    class Area:public Rectangle
    {
        
    public:
        void show()
        {
        
            cout<<"矩形的面积是"<<width*height<<endl;
        }
    };
    class Perimeter:public Rectangle
    {
        
    public:
        void show()
        {
        
            cout<<"矩形的周长是"<<2*width+2*height<<endl;
        }
    };
    
    int main()
    {
        
        Rectangle *p;
        Area ar;
        Perimeter pe;
        ar.setSide(10,20);
        pe.setSide(10,20);
        p=&ar;
        p->show();
        p=&pe;
        p->show();
        return 0;
    }

在上面的例子中，Rectangle是一个基类，它表示一个矩形。从它可以派生出面积类Area和周长类Perimeter。显然，基类中定义的show()函数是没有任何意义的，它只是用来提供派生类使用的公共接口。所以，在程序中将其定义为纯虚函数，但在派生类中，则根据它们自身的需要，重新具体地定义虚函数。  
**抽象类**  
如果一个类至少有一个纯虚函数，那么就称该类为抽象类。因此，上述程序中定义的类Rectangle就是一个抽象类。定义抽象类的唯一目的是用它作为基类去建立派生类。抽象类作为一种基本类型提供给用户，用户在这个基础上面根据自己的需要定义出功能各异的派生类，并用这些派生类去建立对象。对于抽象类的使用有以下几点规定：  
①。由于抽象类中至少包含有一个没有定义功能的纯虚函数。因此，抽象只能作为其他类的基类来使用，不能建立抽象类对象。  
②。不允许从具体类派生出抽象类。所谓具体类，就是不包含纯虚函数的普通类。  
③。抽象类不能用做函数的参数类型，函数的返回类型或显式转换的类型。  
④。可以声明指向抽象 类的指针或引用，此指针可以指向它的派生类，进而实现多态性。  
⑤。如果派生类中没有定义纯虚函数的实现，而派生类只是继承基类的纯虚函数，则这个派生类仍然是一个抽象类。如果派生类中给出了基类纯虚函数的实现，则该派生类就不再是抽象类了，它是一个可以建立对象的具体类了。