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_data
1    //同上
1    //同上
1    //同上
1    //C中dogetdata未定义，调用B的，返回B::m_data
0    //直接调用A中的dogetdata，返回A::m_data
1    //调用B中doggetdata,返回B::m_data
1    //同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");
    }