虚函数 和 友元函数

友元可以是一个函数,该函数称为友元函数;友元也可以是一个类,该类被称为友元类。  

友元函数   友元函数是能够访问类中的私有成员的非成员函数。    

#include   <iostream.h>   
    
  #include   <math.h>   
    
  class   Point   
    
  ...{   
    
                public:   
    
                    Point(double   xx,double   yy)   ...{   x=xx;y=yy;}   
    
                    void   Getxy(   );   
    
                    friend   double   Distance(Point   &a,Point   &   b);   
    
                private:   
    
                    double   x,y;   
    
  };   
    
  void   Point::Getxy(   )   
    
  ...{   
    
                cout<<”(“<<x<<”,”<<y<<”)”<<endl;   
    
  }   
    
  double   Distance(Point   &a,Point   &b)   
    
  ...{   
    
                double   dx=a.x-b.x;   
    
  //对象的私有成员一般只有成员函数才能访问，这里友元函数中允许访问对象的   
    
  //私有成员   
    
                double   dy=a.y-b.y;   
    
                return   sqrt(dx*dx+dy*dy);   
    
  }   
    
  void   main(   )   
    
  ...{   
    
                Point   p1(3.0,4.0),p2(6.0,8.0);   
    
                p1.Getxy(   );   
    
                p2.Getxy(   );   
    
                double   d=Distance(p1,p2);   
    
  cout<<”Distance   is”<<d<<endl;   
    
  }   

     输出结果：       

  （3，4）   
    
  （6，8）   
    
  Distance   is   5   

    说明：该程序中的Point类中说明了一个友元函数Distance(   )，它在说明时前面加上了friend关键字，标示它不是成员函数，而是友元函数。但是，它可以引用类中的私有成员，函数体中a.x，b.x，a.y，b.y都是类的私有成员，它们是通过对象引用的。在调用友元函数时，与普通函数的调用一样，不需要像成员函数那样调用。本例中，p1.Getxy()和p2.Getxy(   )这是成员函数的调用，因此要用对象来表示。而Distance(p1,p2)是友元函数的调用，它可直接调用，不需要用对象表示。但如果在友元函数中处理数据成员，都必须使用对象参数。   

虚函数：以C++中，我们是通过将一个函数定义成虚函数来实现运行时的多态的。如果一个函数被定义为虚函数，那么，即使是使用指向基类对象的指针来调用该成员函数，C++也能保证所调用的是正确的特定于实际对象的成员函数。  
   
  如果类c1,c2...由基类base派生而来，base有一个用virtual修饰的公有或保护函数成员f()，而在c1,c2...中的一些类中重新定义了成员函数f()，而对f()的调用都是通过级基类的对象或指针进行的，在程序执行时才决定是调用c1还是c2或其它派生类中定义的f()。这样的函数f()称为虚函数。  
  让我们通过以下的例子来理解虚函数的概念：     

class   base   ...{     
          public:   
                  virtual   void   f();   
  };   
  class   derived   :   public   base   ...{   
          ...   //没有重定义f()   
  };   
  class   derived1   :   public   derived   ...{   
          public:   
                  void   f();   
  }   

  下面是调用的例子，注意可用成员名强制实行静态联编。 

          derived1   d1;   
          derive&   d=d1;   
          d.f();   //调用derived1::f()   
          base&   b=d1;   
          b.f();//调用derived1::f()   
          d.derived::f();//调用base::f()   
          b.base::f();//调用base::f()   

  派生类中重新定义的虚函数，不论访问权限是什么，都可被动态联编。  
  例如：     

  class   base   ...{   
          public:   
                  virtual   void   f();   
  }   
  class   derived   :   public   base   ...{   
          private:   
                  void   f();   
  }   

  虽然派生类derived中函数成员f()是私有的，但不影响以下的访问：   

          derived   d;   
          base&   b=d;   
          b.f();//调用derived::f()   

     注意：基类成员可以调用派生类中重新定义的虚函数，但构造函数却只能调用本类中定义的虚函数，而不能调用派生类中重新定义的虚函数，因为当时可能还没有建立派生类的对象。   

 简单点就是，虚拟函数只是告诉你将会有些什么样的方法（函数）在基于这个抽象接口上实现，具体方法不再此接口中实现  
   
  friendship就是这个函数不是此类的成员函数，他不能访问此类中封装的数据，但是当他加入了friend声明之后，他就可以访问这些已经封装的数据。很多的经典的计算机图书中都说它破坏了类的封装性，不过这也不是什么不好的，毕竟c++实现了很多的面向对象的大胆尝试，而且为了兼容c，当然有很多不是很纯的“面向对象”。友元就是这样