1.纯虚函数

    • 在基类中将某一成员函数定为虚函数，并不是基类本身的要求，而是考虑到派生类的需要，在基类中预留了一个函数名，具体功能留给派生类根据需要去定义。
    • 声明纯虚函数的一般形式是: **virtual 函数类型 函数名 (参数表列) =0;**
    • 说明
      • 纯虚函数没有函数体；
      • 最后面的“=0”并不表示函数返回值为0，它只起形式上的作用，告诉编译系统“这是纯虚函数”;
      • 这是一个声明语句，最后应有分号。
    • 纯虚函数只有函数的名字而不具备函数的功能，不能被调用。在派生类中对此函数提供定义后，它才能具备函数的功能，可被调用。
    • 纯虚函数的作用是在基类中为其派生类保留一个函数的名字，以便派生类根据需要对它进行定义**。如果在基类中没有保留函数名字，则无法实现多态性。 **
    • 如果在一个类中声明了纯虚函数，而在其派生类中没有对该函数定义，则该虚函数在派生类中仍然为纯虚函数。

    2.抽象类

    • 在面向对象程序设计中，有一些类不用来生成对象，而是用它作为基类去建立派生类，用派生类去建立对象。这种不用来定义对象而只作为一种基本类型用作继承的类，称为**抽象类，由于它常用作基类，通常称为抽象基类**。
    • 凡是包含纯虚函数的类都是抽象类。因为纯虚函数是不能被调用的，包含纯虚函数的类是无法建立对象的。
    • 抽象类的作用是作为一个类族的共同基类，或者说，为一个类族提供一个公共接口。
    • 如果在抽象类所派生出的新类中对基类的所有纯虚函数进行了定义**，这个派生类就不是抽象类，而是可以用来定义对象的具体类(concrete class)。**
    • 如果在派生类中没有对所有纯虚函数进行定义，则此派生类仍然是抽象类，**不能用来定义对象。**
    • 虽然抽象类不能定义对象(或者说抽象类不能实例化)，但是可以定义指向抽象类数据的指针变量。


    3.例：**在程序中使用虚函数和抽象基类。
    类的层次结构的顶层是抽象基类Shape(形状)。Point(点), Circle(圆), Cylinder(圆柱体)都是Shape类的直接派生类和间接派生类。 

    1. #include <iostream>
    2. using namespace std;
    3. class Shape //声明抽象基类Shape
    4. {public:
    5.  virtual float area( ) const {return 0.0;}//虚函数
    6.  virtual float volume() const {return 0.0;} //虚函数 
    7.  virtual void shapeName() const =0; //纯虚函数 
    8. };
    9. class Point:public Shape //Point是Shape的公用派生类
    10. {public: Point(float=0,float=0);
    11.  void setPoint(float,float); 
    12.  float getX( ) const {return x;}
    13.  float getY( ) const {return y;} 
    14.  virtual void shapeName( ) const {cout<<″Point:″;} //对纯虚函数进行再定义 
    15.  friend ostream & operator<<(ostream &,const Point &);
    16.  protected:
    17.  float x,y;
    18. };
    19. Point::Point(float a,float b) {x=a;y=b;}
    20. void Point::setPoint(float a,float b) {x=a;y=b;} 
    21. ostream & operator<<(ostream &output,const Point &p)
    22. {output<<″[″<<p.x<<″,″<<p.y<<″]″;
    23.  return output; }
    24.  class Circle:
    25. public Point //声明Circle类
    26. {public: 
    27.  Circle(float x=0,float y=0,float r=0);
    28.  void setRadius(float);
    29.  float getRadius( ) const; 
    30.  virtual float area( ) const; 
    31.  virtual void shapeName( ) const {cout<<″Circle:″;}//对纯虚函数进行再定义 
    32.  friend ostream &operator<<(ostream &,const Circle &);
    33.  protected:
    34.  float radius;
    35. };
    36. Circle::Circle(float a,float b,float r):Point(a,b),radius(r){ }
    37. void Circle::setRadius(float r):radius(r){ }
    38. float Circle::getRadius( ) const {return radius;}
    39. float Circle::area( ) const {return 3.14159*radius*radius;} 
    40. ostream &operator<<(ostream &output,const Circle &c) 
    41. {output<<″[″<<c.x<<″,″<<c.y<<″], r=″<<c.radius;
    42.  return output;}
    43. class Cylinder:public Circle //声明Cylinder类 
    44. {public:
    45.  Cylinder (float x=0,float y=0,float r=0,float h=0); 
    46.  void setHeight(float); 
    47.  virtual float area( ) const;
    48.  virtual float volume( ) const; 
    49.  virtual void shapeName( ) const {cout<<″Cylinder:″;}//对虚函数进行再定义 
    50.  friend ostream& operator<<(ostream&,const Cylinder&);
    51.  protected: 
    52.  float height;
    53. };
    54. Cylinder::Cylinder(float a,float b,float r,float h) :Circle(a,b,r),height(h){ } void Cylinder::setHeight(float h){height=h;}
    55. float Cylinder::area( ) const { return 2*Circle::area( )+2*3.14159*radius*height;} float Cylinder::volume( ) const {return Circle::area( )*height;} 
    56. ostream &operator<<(ostream &output,const Cylinder& cy) 
    57. {output<<″[″<<cy.x<<″,″<<cy.y<<″], r=″<<cy.radius<<″, h=″<<cy.height;
    58.  return output;}
    59. int main( )
    60. {Point point(3.2,4.5);//建立Point类对象point
    61.  Circle circle(2.4,1.2,5.6); //建立Circle类对象circle
    62.  Cylinder cylinder(3.5,6.4,5.2,10.5); //建立Cylinder类对象cylinder point.shapeName(); //静态关联 
    63.  cout<<point<<endl; 
    64.  circle.shapeName(); //静态关联 
    65.  cout<<circle<<endl; 
    66.  cylinder.shapeName(); //静态关联 
    67.  cout<<cylinder<<endl<<endl;
    68.  Shape *pt; //定义基类指针 
    69.  pt=&point; //指针指向Point类对象
    70.  pt->shapeName( ); //动态关联
    71.  cout<<″x=″<<point.getX( )<<″,y=″<<point.getY( )<<″\\narea=″<<pt->area( ) <<″\\nvolume=″<<pt->volume()<<″\\n\\n″; pt=&circle; //指针指向Circle类对象
    72.  pt->shapeName( ); //动态关联
    73.  cout<<″x=″<<circle.getX( )<<″,y=″<<circle.getY( )<<″\\narea=″<<pt->area( ) <<″\\nvolume=″<<pt->volume( )<<″\\n\\n″;
    74.  pt=&cylinder; //指针指向Cylinder类对象
    75.  pt->shapeName( ); //动态关联 
    76.  cout<<″x=″<<cylinder.getX( )<<″,y=″<<cylinder.getY( )<<″\\narea=″<<pt->area( ) <<″\\nvolume=″<<pt->volume( )<<″\\n\\n″; 
    77.  return 0;
    78. }
    • 结论
      • 一个基类如果包含一个或一个以上纯虚函数，就是抽象基类。抽象基类不能也不必要定义对象。
      • 抽象基类与普通基类不同，它一般并不是现实存在的对象的抽象，它可以没有任何物理上的或其他实际意义方面的含义。
      • 在类的层次结构中，顶层或最上面的几层可以是抽象基类。抽象基类体现了本类族中各类的共性，把各类中共有的成员函数集中在抽象基类中声明。
      • 抽象基类是本类族的公共接口。或者说，从同一基类派生出的多个类有同一接口。
      • 如果在基类声明了虚函数，则在派生类中凡是与该函数有相同的函数名、函数类型、参数个数和类型的函数，均为虚函数(不论在派生类中是否用virtual声明)。
      • 使用虚函数提高了程序的可扩充性