c++语法笔记（下）

多态性与虚函数

多态性(函数重载，运算符重载就是多态性现象)
多态性 ：向不同对象发送同一个消息，不同对象在接收时会产生不同的行为。（每个对象用自己的方式去响应共同的消息）
多态性又可以分为静态多态性和动态多态性
静态多态性在编译时编译系统就可以判定调用哪个重载运算符（函数）。

#include<iostream>
using namespace std;
class point {
public:
 point(float a, float b) {             //构造函数
  x = a; y = b;
 }
 friend ostream & operator <<(ostream &, point &);        //运算符重载
protected:
 float x, y;
};
std::ostream &operator<<(std::ostream &output, point &p) {        //运算符重载的定义
 output << "(" << p.x << "," << p.y << ")" << endl;
 return output;
}
class circle :public point {
public:
 circle(float a, float b, float c) :point(a, b), radius(c) {}      //构造函数
 friend ostream &operator <<(ostream &, circle &); 

protected:
 float radius;
};
 ostream &operator <<(ostream &output, circle &c) {
  output << "(" << c.x << "," << c.y << ")," << "radius=" << c.radius << endl;
  return output;
 }
int main() {
 point a(2.3, 4.6);
 cout << "the point is:" << a << endl;
 circle m(, , );
 cout << "the circle is" << m << endl;
}

利用虚函数实现动态多态性
（所谓虚函数，就是在基类声明函数是虚拟的，并不是实际存在的函数，
  然后在派生类中才正式定义此函数，在程序运行期间，用指针指向某一派生类的对象，这样就能调用指针指向的派生类对象的函数）

#include<iostream>
using namespace std;
class point {
public:
 point(float a, float b) {             //构造函数
  x = a; y = b;
 }
 virtual void display();               //虚函数
protected:
 float x, y;
};
void point::display(){
 cout<<"(" << x << "," << y << ")"<<endl;
} 

class circle :public point {
public:
 circle(float a, float b, float c) :point(a, b), radius(c) {}      //构造函数
 void display();
protected:
 float radius;
};
void circle::display(){
 cout<< "(" << x << "," << y << ")," << "radius=" << radius << endl;
}
int main() {
 point a(2.3, 4.6);
 circle m(, , );
 point *p1=&a;     //基类指针
 p1=&m;
 p1->display();
 return ;
}

输出的结果是：（0，0）radius=8
说明：本来基类指针是用来指向基类对象的，如果把它指向派生类对象，则自动进行指针类型转换，
将派生类的对象的指针先转换为基类指针，这样基类指针指向的就是对象中的基类成分。
虚函数突破了这一限制，基类的display函数声明为虚函数，在声明派生类时被重载，这时派生类的同名函数display就取代了基类的虚函数。
虚函数的使用方法：
1.在基类声明成员函数为虚函数，在类外定义虚函数是不必加virtual
2.一个成员函数被声明为虚函数后，在同一类族中的类就不能在定义一个非virtual的但与该虚函数具有相同参数和函数返回值的同名函数。

 

虚析构函数
析构函数的作用是在对象撤销之前做必要的清理现场的工作，当派生类的对象从内存中撤销时一般先调用派生类的析构函数，然后调用基类的析构函数。
但如果使用new运算符建立了临时对象，若基类有析构函数，并且定义了一个指向该基类的指针。
在程序用带指针参数的delet运算符撤销对象时，系统只会执行基类的析构函数，而不执行派生类的析构函数。
如果在基类的析构函数声明为虚析构函数，就可以使实现先调用派生类的析构函数，再调用基类的析构函数。

#include<iostream>
using namespace std;
class point {
public:
 point(float x = , float y = );             //声明构造函数时指定默认参数
 virtual ~point() {
  cout << "executing point destructor" << endl;
 }
protected:
 float x, y;
};
point::point(float a,float b){                  //在定义构造函数时可以不指定默认参数
 x=a;
 y=b;
}
class circle :public point {
public:
 circle(float x = , float y = , float r = ) ;
 ~circle() {
  cout << "executing circle destructor" << endl;
 }
protected:
 float r;
};
circle::circle(float a,float b,float c){
 x=a;
 y=b;
 r=c;
}
int main() {
 point *p = new circle;
 delete p;
 return ;
}

纯虚函数
由于派生类的需要，将基类中某一成员函数定义为虚函数（预留一个函数名），具体功能由派生类定义。
声明虚函数的例子：
virtual float area() {return 0;}
为了简化，可以不写函数体
virtual float area()=0;

注意：纯虚函数没有函数体
      最后面“=0”只起形式上的作用，告诉编译系统“这是纯虚函数”
       这是一个声明语句，最后有分号；

抽象类
有时定义一些类，它们专门作为基类去建立派生类，而不用来定义对象，我们称它们为抽象类（抽象基类）。凡是包含纯虚函数的类都是抽象类，
纯虚函数是不能被调用的，包含纯虚函数的类是无法建立对象的。（不过可以定义指向抽象类数据的指针变量，当派生类成为具体类时，
就可以用这种指针指向派生类的对象，通过该指针调用虚函数，实现多态性）

//虚函数与抽象基类的应用
#include<iostream>
using namespace std;
//声明抽象抽象基类shape
class shape{
 public:
  virtual float area() const {return ;}             //虚函数
  virtual float volume() const {return ;}
  virtual void shapname() const=;                 //纯虚函数 

};
//声明point类
class point:public shape {
 public:
  point(float x=,float y=);         //声明构造函数
  virtual void shapname() const {cout<<"point";}
 protected:
  float x,y;
};
//定义point
point::point(float a,float b){
 x=a;
 y=b;
}

//声明circle类
class circle:public point{
 public:
  circle(float x=,float y=,float r=);
  virtual float area() const;
  virtual void shapname() const {cout<<"circle:";}
 protected:
  float radius;
};
//定义circle类
circle::circle(float a,float b,float r):point(a,b),radius (r) {}    //定义构造函数 

float circle::area() const {return radius*radius*3.14;}

//声明cylinder类
class cylinder:public circle{
 public:
  cylinder(float x=,float y=,float r=,float h=);
  virtual float area() const;
  virtual float volume() const;
  virtual void shapname() const{cout<<"cylinder:";}
 protected:
  float height;
};
//定义cylinder类
cylinder::cylinder(float a,float b,float r,float h):circle(a,b,r),height(h){}
float cylinder::area() const{
 return *circle::area()+*radius*3.14*height;
}
float cylinder::volume() const{
 return height*circle::area();
}
//main函数
int main(){
 point point(,);
 circle circle(,,);
 cylinder cylinder(,,,);
 point.shapename;                //静态关联（通过对象名调用虚函数）在编译阶段就可以确定调用的是哪一类的虚函数
 shape *pt;                      //定义基类指针
 pt=&point;                      //使指针指向point类
 pt->shapname();                 //用指针建立动态关联 （在编译阶段无法从语句本身确定调用的是哪个类的虚函数）
 cout<<"\n";
 pt=&circle;
 pt->shapname();
 cout<<"area="<<pt->area()<<"\n"<<endl;

 pt=&cylinder;
 pt->shapname();
 cout<<"area="<<pt->area()<<"\n"
 <<"volume="<<pt->volume()<<endl;
 return ;
}