多态性之动态联编 虚函数

#include<iostream.h>
class point //动态联编可以得到预期的输出
{

private:
 float x,y;
public:
 void setcon(float i,float j) {x=i;y=j;}
 virtual double area(){return 0.0;}//要使用动态联编，必须将函数说明为虚函数，这只要将
};//将关键字virtual放在类中该函数的函数说明之前即可。使用virtual修饰的成员函数称为虚函数
const double pi=3.14159;//
class circle:public point{
private:
 double radius;
public:
 void setsize(double r){radius=r;}
 virtual double area(){return pi*radius*radius;}//虚函数只能是类中的一个成员函数，但不能是静态成员
};//关键字virtual指示c++编译器，在运行时确定函数调用pp->area()所要调用的函数，即对该调用进行动态联编。
void main()
{

 point p;
    double a=p.area();
    cout<<"The area of the point p is"<<a<<endl;
 circle c;
 c.setsize(3.65637);
 a=c.area();
 cout<<"The area of the circle c is"<<a<<endl;
 point *pp;
 pp=&c;//程序在运行时根据指针pp指向的实际对象，调用该对象的成员函数
 cout<<"The area of the pp->area() is"<<pp->area()<<endl;
 cout<<"/n";
}
/*虚函数声明只能出现在类声明中函数原型中，而不能在成员的函数体实现的时候。必须由成员函数
来调用或者是通过指针、引用来访问虚函数。如果通过对象名来访问虚函数，则联编在编译过程中认为是静态联编*/

/*虚函数的访问权限不影响对它进行动态联编
class base{
public:
virtual void fun()
};
class derived:public base{
private:
void fun();
};
虽然派生类中的fun()和基类中的fun()的访问权限不一样，但它仍是虚函数.所以：
derived d;
base& b=d;//引用
b.fun();//调用derived::fun()
*/

/*虚函数只能是类中的一个成员函数，但不能是静态成员，关键字virtual用于类
中该函数的说明中。例如：

  class A{
  public:
  virtual void fun();
  };
void A::fun(){}
当在派生类中定义了一个同名的成员函数时，只要该成员函数的参数个数和相应类型以及
它的返回类型与基类中同名的虚函数完全一样，则无论是否该成员函数使用virtual，它都将
成为一个虚函数
*/

/*
使用虚函数保证了在通过一个基类类型的指针（包括引用）调用一个虚函数时，c++系统对
该调用进行动态联编。但是，在通过一对象访问一虚函数时使用静态联编
point p;
cicle c;
p=c;
cout<<p.area();//调用p中的area
*/

/*如果派生类中没有对基类的虚函数进行重定义，则它继承基类中的虚函数

class base{
public:
virtual void fun()
};
class derived:public base{
//没有重定义fun();
};
derived类将继承base类的虚函数fun(),所以

 derived d;
 base& b=d;
 b.fun();//调用derived类中从base类继承的fun()

如果从derived派生的类重定义了fun(),则在该派生类中的这个函数仍是虚函数
例如：
class derived1:public derived {
public：
void fun();
};
派生类derived1中的函数fun是虚函数，所以
derived1  d1;
derived& d=d1;//引用
d.fun();//调用derived1::fun()
base& b=d1;
b.fun()//调用derived1::fun()
*/

/*
在调用中对虚函数使用成员名限定可以强制c++对该函数进行静态联编。
例如：
derived1  d1;
derived& d=d1;//引用
d.derived::fun();//调用base::fun()
base& b=d1;
b>base::fun();//调用base::fun()
*/

/*一个类中的虚函数说明只对派生类中重定义的函数有影响，对它的基类中的函数无影响，例如：
class A{
public:
void fun();
};

class B:public A{
public:
virtual void fun();
};

class C:pubilc B{
public:
void fun();
};
A类中的fun不是虚函数，所以
C c;
A& a=c;
a.fun()；//调用A::fun();
个人认为virtual覆盖基类，这时A类中的fun没有被覆盖
*/