基础备忘：多态的实现（重载、虚函数、抽象类）

1.函数重载

由静态联编支持的多态性称为编译时的多态性或静态多态性，也就是说，确定同名操作的具体操作对象的过程是在编译过程中完成的。在C++中，可以用函数重载和运算符重载来实现编译时的多态性。

2.虚函数

由动态联编支持的多态性称为运行时的多太性或动态多态性，也就是说，确定同名操作的具体操作对象的过程是在运行过程中完成的。在C++中，可以用虚函数来实现运行时的多态性。

2.1.虚函数定义

虚函数的定义是在基类中进行的，即把基类中需要定义为虚函数的成员函数声明为virtual。当基类中的某个成员函数被声明为虚函数后，就可以在派生类中被重新定义。在派生类中重定义时，其函数原型，包括返回类型、函数函数名、参数个数和类型、参数的顺序都必须与基类中的原型完全一致。

定义形式为：

virtual <函数类型><函数名>（参数表）｛函数体｝

例如：解决博文多态概念时的问题代码如下：

#include<iostream>using namespace std;class Animal{      public:             void sleep()             {                  cout<<"Animal Sleep"<<endl;                  }            virtual void breathe()//加上virtual              {                  cout<<"Animal Breathe"<<endl;                  }      };class Fish:public Animal{      public:             void breathe()             {                  cout<<"Fish Bubble"<<endl;                  }      };int main(){    Fish fs;    Animal *an=&fs;    an->breathe();    system("pause");    }

只是加了一个virtual问题就解决了。输出结果为：

事实上，当将基类中的成员函数breathe()声明为virtual即虚函数时，编译器在编译的时候发现Animal类中有虚函数，此时编译器会为每个包含虚函数的类创建一个虚表，该表是一个一维数组，在这个数组中存放每个虚函数的地址。上述代码中，Animal类和Fish类都包含了一个虚函数breathe()，因此编译器会为这两个类分别建立一个虚表，如下图所示。

类Animal和类Fish的虚表

在上述代码中，当Fish类的fs对象构造完毕后，其内部的虚表指针也就被初始化为指向Fish类的虚表。在转换后，调用an->breathe()，由于an实际指向的是Fish类的对象，该对象内部的虚表指针指向的是Fish类的虚表，因此最终调用的是Fish类的breathe()函数。

使用派生对象指针时应注意的问题：

1.声明为指向基类对象的指针可以指向它的公有派生类的对象，但不允许指向它的私有派生类的对象。

2.允许声明为指向基类对象的指针指向它的公有派生类的对象，但不允许将一个声明为指向派生类对象的指针指向基类的对象。

3.声明为指向基类对象的指针，当其指向它的公有派生类的对象时（满足第1条），只能直接访问派生类中从基类继承下来的成员，不能直接访问公有派生类中定义的成员。要想访问其公有派生类中的成员，可将基类指针用显式类型转换方式转换为派生类指针。例如：

#include<iostream>using namespace std;class B{      public:             void vf()             {                  cout<<"This is class B"<<endl;                  }      };class D:public B{      public:             void vf()             {                  cout<<"This is class D"<<endl;                  }      };int main(){    B b,*pb;    D d,*pd;    pb= &b;    pb->vf();    pb=&d;//满足第1第2条。     pb->vf(); // pd=&b;//违背第2条。invalid conversion from `B*' to `D*'  // pd->vf();    pd=(D*)&b;//满足第3条。     pd->vf();    pd=&d;    pd->vf();    system("pause");    }

如果把vf改成virtual类型的，有：

#include<iostream>using namespace std;class B{      public:             virtual void vf()             {                  cout<<"This is class B"<<endl;                  }      };class D:public B{      public:             void vf()             {                  cout<<"This is class D"<<endl;                  }      };int main(){    B b,*pb;    D d,*pd;    pb= &b;    pb->vf();    pb=&d;//满足第1第2条。     pb->vf();  //pd=&b;//违背第2条。invalid conversion from `B*' to `D*'   //pd->vf();    pd=(D*)&b;//满足第3条。 这里是多态。    pd->vf();    pd=&d;    pd->vf();    system("pause");    }

虚函数可以很好的实现多态，在使用虚函数时应注意如下问题：

1.虚函数的声明只能出现在类函数原型的声明中，不出现在函数体实现的时候，而且，基类中只有保护成员或公有成员才能被声明为虚函数。

2.在派生类中重新定义虚函数时，关键字virtual可以写也可以不写，但是在容易引起混乱时，应该写上该关键字。

3.动态联编只能通过成员函数来调用或者通过指针、引用来访问虚函数，如果以对象名的形式来访问虚函数，将采用静态联编。

在派生类中重新定义基类中的虚函数，是函数重载的另一种形式，但它与函数重载 又有如下区别：

1.一般的函数重载，要求其函数的参数或参数类型必须有所不同，函数的返回类型也可以不同。

2.重载一个虚函数时，要求函数名、返回类型、参数个数、参数类型和参数顺序都必须与基类中的虚函数完全一致。

3.如果仅返回类型不同，其余相同，则系统会给出错误信息。

4.如果函数名相同，而参数个数、参数的类型或参数的顺序不同，系统认为是普通的函数重载，虚函数的特性将被丢掉。

2.2 多级继承和虚函数

原生态多级继承例子：

#include<iostream>using namespace std;class B{      public:             int ms;      public:            void set()             {                  cout<<"Base set"<<endl;                  }      };class D:public B{      public:             void set()             {                  cout<<"D set"<<endl;                  }      };class DD:public D{      };class DDD:public DD{      public:             void set()             {                  cout<<"DDD set"<<endl;                  }      };class DDDD:public DDD{            };class DDDDD:public DDDD{      };int main(){    DD d;    d.set();    DDDD dddd;    dddd.set();    DDDDD ddddd;    ddddd.set();    system("pause");    }

上述代码结果说明，如果类中没有对应的成员函数，则会向上一级一级找，直到出现所需要的成员函数。如上面的set。d.set在DD类中无set类，就向上找，找到离自己最近的父类的成员函数。

多级继承可以看做是多个单继承的组合，多级继承的虚函数与单继承的虚函数的调用相同，一个虚函数无论被继承多少次，仍保持其虚函数的特性，与继承的次数无关。例如：

#include<iostream>using namespace std;class Base{      public:             virtual ~Base(){}             virtual void func()             {                     cout<<"Base func"<<endl;                     }      };class Derived1:public Base{      void func()      {           cout<<"Derived1 func"<<endl;           }      };class Derived2:public Derived1{      void func()      {           cout<<"Derived2 func"<<endl;           }      };void test(Base &b)//引用方式 {     b.func();     }int main(){    Base b;    Derived1 d1;    Derived2 d2;    test(b);    test(d1);    test(d2);    system("pause");    }

上述代码中在析构函数前面加上关键字virtual，则该析构函数就称为虚析构函数。

上述代码扩展例子：

#include<iostream>using namespace std;class Base{      public:             virtual ~Base(){}             virtual void func()             {                     cout<<"Base func"<<endl;                     }      };class Derived1:public Base{      void func()      {           cout<<"Derived1 func"<<endl;           }      };class Derived2:public Derived1{  /*    void func()      {           cout<<"Derived2 func"<<endl;           }*/      };class Derived3:public Derived2{      void func()      {           cout<<"Derived3 func"<<endl;           }      };class Derived4:public Derived3{      void func()      {           cout<<"Derived4 func"<<endl;           }      };void test(Base &b)//引用方式 {     b.func();     }int main(){    Base b;    Derived1 d1;    Derived2 d2;    Derived3 d3;    Derived4 d4;    test(b);    test(d1);    test(d2);    test(d3);    test(d4);    system("pause");    }

注意d2使用的是其父类的成员函数。

在使用虚析构函数时，要注意以下两点：

1.只要基类的析构函数被声明为虚函数，则派生类的析构函数，无论是否使用virtual关键字进行声明，都自动成为虚函数。

2.如果基类的析构函数为虚函数，则当派生类未定义析构函数时，编译器所生成的析构函数也为虚函数。

一般来说，在程序中最好把基类的析构函数声明为虚函数。这将使所有派生类的析构函数自动成为虚函数。这样，如果程序中用delete运算符准备删除一个对象，而delete运算符操作对象是指向派生类的基类指针，系统会调用相应的析构函数；否则系统只执行蕨类的析构函数，而不执行派生类的析构函数，从而可能导致异常情况的发生。

构造函数不能声明为虚函数。这是因为在执行构造函数时类对象还未完成建立过程，当然谈不上函数与类对象的关联。

补充例子：

#include <iostream> using namespace std; class A { protected:            int m_data; public:         A(int data = 0):m_data(data) { }         int GetData() { return doGetData(); }         virtual int doGetData() { return m_data; } }; class B:public A {       protected:                  int m_data;       public:               B(int data = 1): m_data(data) { }               int doGetData() { return m_data; } }; class C:public B {       protected: int m_data;       public:               C(int data = 2):m_data(data) { } }; int main() {     C c(10);     cout << c.GetData() << endl;     cout << c.A::GetData() << endl;     cout << c.B::GetData() << endl;     cout << c.C::GetData() << endl;     cout << c.doGetData() << endl;     cout << c.A::doGetData() << endl;     cout << c.B::doGetData() << endl;     cout << c.C::doGetData() << endl;     system("pause");    return 0;     } 

1    //C中getdata未定义，B中也是，所以调用A的。A的dogetdata是虚函数，所以调用B的，返回B::m_data1    //同上1    //同上1    //同上1    //C中dogetdata未定义，调用B的，返回B::m_data0    //直接调用A中的dogetdata，返回A::m_data1    //调用B中doggetdata,返回B::m_data1    //同c.doGetData()Press any key to continue . . .

3.纯虚函数与抽象类

抽象类是一种特殊的类，它提供统一的操作接口。建立抽象类是为了多态地使用抽象类成员函数。抽象类是包含纯虚函数的类。

3.1 纯虚函数

定义形式：

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

纯虚函数的作用是为派生类提供一个统一的接口，纯虚函数的实现可以留给派生类来完成。一般来说，一个抽象类中带有至少一个纯虚函数。

例：

#include<iostream>using namespace std;class Point{      protected:                int x0,y0;      public:             Point(int i,int j)             {                       x0=i;                       y0=j;                       }      virtual void set()=0;      virtual void draw()=0;      };class Line:public Point{      protected:                int x1,y1;      public:             Line(int i=0,int j=0,int m=0,int n=0):Point(i,j)             {                      x1=m;                      y1=n;                      }             void set(){cout<<"Line_set()"<<endl;}             void draw(){cout<<"Line_draw()"<<endl;}      };class Ellipse:public Point{      protected:                int x2,y2;      public:             Ellipse(int i=0,int j=0,int p=0,int q=0):Point(i,j)             {                         x2=p;                         y2=q;                      }             void set(){cout<<"Ellipse_set()"<<endl;}             void draw(){cout<<"Ellipse_draw()"<<endl;}      };void drawobj(Point *p){     p->draw();     }void setobj(Point *p){     p->set();     }int main(){  Line *li=new Line();//new Line;  drawobj(li);  setobj(li);  cout<<endl;     Ellipse *el=new Ellipse();//new Ellipse;   drawobj(el);   setobj(el);   cout<<endl;       Line *li2=new Line;   drawobj(li2);   setobj(li2);   cout<<endl;      Ellipse elp;   drawobj(&elp);   setobj(&elp);   cout<<endl;           system("pause");    } 

在上述代码中，类Line和类Ellipse都公有继承自类Point，在该程序中要实现多态，就必须定义set()函数和draw()函数为虚函数。同时，由于点是不需要在应用程序中画出的，因此Point的set()函数和draw()函数定义为虚函数。在主函数main()中，创建Line对象和Ellipse对象后，调用这两个同名的函数即可。这就是虚函数的作用，它一般用于基类函数没有具体操作，而派生类中该函数可能需要的场合。

3.2 抽象类

包含虚函数的类称为抽象类。抽象类是一种特殊的类，是为了抽象和设计的目的而建立的，处于继承层次结构的较上层。抽象类是不能创建对象的，在实际中为了强调一个类是抽象类，可将该类的构造函数声明为保护的访问控制权限。

抽象类的主要作用是将有关的类组织在一个继承层次中，由抽象类来为它们提供一个公共的根，相关的子类是从这个根派生出来的。抽象类刻画了一组子类的操作接口的通用语义，这些语义也传给子类。一般而言，抽象类只描述这组子类共同的操作接口，而完整的实现留给子类。使用抽象类时应该注意以下问题：

1.抽象类只能用做其他类的基类，不能创建抽象类对象，因为它的纯虚函数没有定义功能，其纯属虚函数的实现由派生类给出。

2.抽象类不能用做参数类型、函数的返回类型或显式转换的类型。

3.可以声明抽象类的对象指针或对象引用，从而可以访问派生类对象成员，实现动态联编。

4.若派生类中没有给出抽象类的所有纯虚函数的函数体，派生类仍是一个抽象类。若抽象类的派生类中给出了所有纯虚函数的函数体，这个派生类不再是一个抽象类，它可以创建自己的对象了。例：

#include<iostream>using namespace std;class Vehicle{      protected:                float speed;                int total;      public:             Vehicle(float speed,int total)             {                           Vehicle::speed = speed;//成员变量和函数参数重名，注意加上::以区分成员变量和函数参数，否则初始化会有问题                           Vehicle::total = total;//或者this->total = total;                           }             virtual void ShowMember()=0;      };class Car:public Vehicle{      protected:                int aird;      public:             Car(int aird,float speed,int total):Vehicle(speed,total)             {                     Car::aird = aird;                     }             void ShowMember()             {                  cout<<"Speed is: "<<speed<<endl;                  cout<<"Toatal is: "<<total<<endl;                  cout<<"Aird is: "<<aird<<endl;                  }      };int main(){    Car c(250,150,4);    c.ShowMember();    system("pause");    }