原创 动态联编与虚函数

class  Point
{public:
     Point(double i, double j){x=i;y=j;}
     double Area()  const {return  0.0;}
    //不同类体中，说明完全相同的函数有不同的实现

 private:
     double  x, y;
};

class Rectangle: public Point
{public:
     Rectangle(double i, double j, double k, double l) : Point(i, j)
    { w="k"; h="l"; }

    double Area() const {return  w*h;}
  //不同类体中，说明完全相同的函数有不同的实现

 private:
    double  w, h;
};

void fun(Point  &s)
{ cout<<s.Area()<<endl; }

void main()
{ Rectangle  rec(3.0,5.2,15.0,25.0);
   fun(rec);
}

运行结果： 0

在编译阶段，Point类对象引用s 所执行的Area()操作只能束定到Point类的函数上
要想在程序运行时动态选择函数实现 就要用到动态联编

(1)程序在编译阶段不能确切知道将要调用的函数,

只有在程序执行时才能确定要调用哪个函数；
(2)动态联编在虚函数的支持下才能实现;
说明:
virtual   <类型>  <函数名>(<参数表>)

操作方法
(1)通过对象指针或对象引用操作虚函数
class  Point
{public:
     Point(double i, double j){x=i;y=j;}
     virtual  double Area()  const
     { return  0.0; }
 private:
     double  x, y;
};

class Rectangle: public Point
{public:
     Rectangle(double i, double j, double k, double l) : Point(i, j)
    { w="k"; h="l"; }
    virtual  double Area()  const
    { return  w*h; }
 private:
    double  w, h;
};

void fun(Point  &s)
{ cout<<s.Area()<<endl; }

void main()
{ Rectangle  rec(3.0,5.2,15.0,25.0);
   fun(rec);
}

运行结果：375

运行时，fun()函数的对象引用s 被动态联编, 束定到Rectangle 类的Area()函数

(2)通过成员函数调用虚函数

class  A
{public:
     virtual  void act1();
     void  act2() { act1(); }
};
void A::act1()
{cout<<"A::act1() called."<<endl;}

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

void B::act1()
{cout<<"B::act1() called."<<endl;}

void main()
{  B  b; 
    b.act2();
}

 运行结果：B::act1( ) called.

而构造函数中调用虚函数则:
调用自身类中的虚函数

若自身类没有，则调用基类中的虚函数，

而不是派生类中的虚函数。

#include<iostream.h>
class  A
{public:
    A( ) { }
    virtual  void f( ) {cout<<"A::f( ) called.\n";}
};

class  B: public A
{public:
      B( )  { f( );}            //构造函数中调用虚函数
      // virtual void f() {cout<<"B::f( ) called.\n";}
      void  g( )  { f( ); }  //成员函数中调用虚函数
};

class C: public B
{public:
     C( ) { };
     virtual void f( ){cout<<"C::f( ) called.\n";}
};

void main( )
{   C  c; 
     c.g( );
}

如上将virtual void f() {cout<<"B::f( ) called.\n";}注释.
则运行结果为:
A::f( ) called.

C::f( ) called.
构造函数调用了基类中的虚函数,而非派生类中的虚函数.
如将注释去掉,则运行结果为:
B::f( ) called.

C::f( ) called.
构造函数调用了自身的虚函数.