精华内容
下载资源
问答
  • 友元函数详细讲解

    2013-10-26 22:52:36
    友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。类授予它的友元特别的访问权。通常同一个开发者会出于技术和非技术的原因,控制类的友元和成员函数(否则当你想更新你的类时,还要征得其它部分的拥有...
  • 现在先说说赋值运算符“=”的重载C++规定赋值运算符“=”只能重载为类的非静态成员函数,而不可以重载为类的友元函数。不能重载为类的静态成员应该比较容易理解,因为静态成员函数是属于整个类的,不是属于某个对象...
  • C++之中的友元函数作用

    万次阅读 多人点赞 2017-12-09 17:23:22
    友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员...友元函数友元函数是可以直接访问类的私有成员的非成员函

    友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。

    友元的正确使用能提高程序的运行效率,但同时也破坏了类的封装性和数据的隐藏性,导致程序可维护性变差。
    友元函数 :

    友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend,其格式如下:
    friend 类型 函数名(形式参数);

    友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。
      一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
      友元函数的调用与一般函数的调用方式和原理一致。
    

    友元类 :
    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。
    当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。定义友元类的语句格式如下:
    friend class 类名;
    其中:friend和class是关键字,类名必须是程序中的一个已定义过的类。

    
       1:  #include <iostream>
    
       2:  using namespace std;
    
       3:   
    
       4:  class Radius
    
       5:  {
    
     6:  friend class Circle; //声明Circle为Radius的友元类  7:  friend void Show_r(Radius &n); //声明Show_r为友元函数  8:  public:  9:  Radius(int x)  10:  {  11:  r = x;  12:  }  13:  ~Radius()  14:  {  15:  }  16:    17:  private:  18:  int r;  19:  };  20:    21:  void Show_r(Radius &n)  22:  {  23:  cout<<"圆的半径为: "<<n.r<<endl; //调用Radius对象的私有成员变量r  24:  }  25:    26:  class Circle  27:  {  28:  public:  29:  Circle() {}  30:  ~Circle(){}  31:  double area(Radius a)  32:  {  33:  s = a.r * a.r * 3.1415926; //调用Radius对象的私有成员变量r  34:  return s;  35:  }  36:  private:  37:  double s;  38:  };  39:    40:  int main(int argc, char *argv[])  41:  {  42:  Radius objRadius(9);  43:  Circle objCircle;  44:    45:  Show_r( objRadius );  46:  cout<<"面积为:"<<objCircle.area(objRadius)<<endl;  47:    48:  return 0;  49:  } 

    友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend,其格式如下:
    friend 类型 函数名(形式参数);

    友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。
      一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
      友元函数的调用与一般函数的调用方式和原理一致。
    

    转载部分:

    1、为什么要引入友元函数:在实现类之间数据共享时,减少系统开销,提高效率

      具体来说:为了使其他类的成员函数直接访问该类的私有变量
    
      即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类共享同一函数
    
      优点:能够提高效率,表达简单、清晰
    
      缺点:友元函数破环了封装机制,尽量不使用成员函数,除非不得已的情况下才使用友元函数。
    

    2、什么时候使用友元函数:

      1)运算符重载的某些场合需要使用友元。
    
      2)两个类要共享数据的时候
    

    3、怎么使用友元函数:

    友元函数的参数:

       因为友元函数没有this指针,则参数要有三种情况:
    
       1、  要访问非static成员时,需要对象做参数;--常用(友元函数常含有参数)
    
       2、  要访问static成员或全局变量时,则不需要对象做参数
    
       3、  如果做参数的对象是全局对象,则不需要对象做参数
    

    友元函数的位置:

       因为友元函数是类外的函数,所以它的声明可以放在类的私有段或公有段且没有区别。
    

    友元函数的调用:

       可以直接调用友元函数,不需要通过对象或指针
    

    友元函数的分类:

    根据这个函数的来源不同,可以分为三种方法:

    1、普通函数友元函数:

       a) 目的:使普通函数能够访问类的友元
    
       b) 语法:声明位置:公有私有均可,常写为公有
    
                        声明: friend + 普通函数声明
    
                        实现位置:可以在类外或类中
    
                        实现代码:与普通函数相同(不加不用friend和类::)
    
                        调用:类似普通函数,直接调用
    
    class INTEGER
    {  
    private:
        int num;
    public:
        friend void Print(const INTEGER& obj);//声明友元函数
    };
    void Print(const INTEGER& obj)//不使用friend和类::
    {
        //函数体
    }
    void main()
    {
        INTEGER obj;
        Print(obj);//直接调用
    }
    

    2、类Y的所有成员函数都为类X友元函数—友元类

      a)目的:使用单个声明使Y类的所有函数成为类X的友元
    
                        它提供一种类之间合作的一种方式,使类Y的对象可以具有类X和类Y的功能
    
                        具体来说:
    
                                前提:A是B的友元(=》A中成员函数可以访问B中有所有成员,包括私有成员和公有成员--老忘)
    
                                    则:在A中,借助类B,可以直接使用~B . 私有变量~的形式访问私有变量
    
      b)语法:声明位置:公有私有均可,常写为私有(把类看成一个变量)
    
                        声明: friend + 类名---不是对象啊
    
                        调用:
    
      c)代码:
    
    class girl;
    
    class boy
    {  
    private:
        char *name;  
        int age;  
    public:  
        boy();
        void disp(girl &);   
    };  
    
    void boy::disp(girl &x) //函数disp()为类boy的成员函数,也是类girl的友元函数 
    { 
        cout<<"boy's name is:"<<name<<",age:"<<age<<endl;//正常情况,boy的成员函数disp中直接访问boy的私有变量
        cout<<"girl's name is:"<<x.name<<",age:"<<x.age<<endl; 
        //借助友元,在boy的成员函数disp中,借助girl的对象,直接访问girl的私有变量
        //正常情况下,只允许在girl的成员函数中访问girl的私有变量
    }
    
    class girl
    {  
    privatechar *name;  
        int age;  
        friend boy;   //声明类boy是类girl的友元  
    public:  
        girl();   
    };  
    void main()  
    {   
        boy b;  
        girl g;  
        b.disp(g);  //b调用自己的成员函数,但是以g为参数,友元机制体现在函数disp中
    }

    3、类Y的一个成员函数为类X的友元函数

      a)目的:使类Y的一个成员函数成为类X的友元
    
             具体而言:而在类Y的这个成员函数中,借助参数X,可以直接以X。私有变量的形式访问私有变量
    
      b)语法:声明位置:声明在公有中 (本身为函数)
    
                        声明:friend + 成员函数的声明
    
                        调用:先定义Y的对象y---使用y调用自己的成员函数---自己的成员函数中使用了友元机制
    
      c)代码: 
    
    class girl; 
    class boy
    {  
    private:
        char *name;  
        int age;  
    public:  
        boy();
        void disp(girl &);     
    };   
    
    class girl
    {
    private:
        char *name;  
        int age;  
    public:  
        girl(char *N,int A);  
        friend void boy::disp(girl &); //声明类boy的成员函数disp()为类girl的友元函数  
    };  
    
    void boy::disp(girl &x)  
    {   
        cout<<"boy's name is:"<<name<<",age:"<<age<<endl;  //访问自己(boy)的对象成员,直接访问自己的私有变量  
        cout<<"girl's name is:"<<x.name<<",age:"<<x.age<<endl;  
        //借助友元,在boy的成员函数disp中,借助girl的对象,直接访问girl的私有变量
        //正常情况下,只允许在girl的成员函数中访问girl的私有变量  
    }  
    void main()  
    {   
        boy b();  
        girl g();  
        b.disp(g);  }
    

    4、在模板类中使用友元operator<<(对<<运算符的重载)

    a)使用方法:
    

    在模板类中声明:

    friend ostream& operator<< <>(ostream& cout,const MGraph<VexType,ArcType>& G); 

    在模板类中定义:

    template<class VexType,class ArcType>
    ostream& operator<<(ostream& cout,const MGraph<VexType,ArcType>& G)
    {
        //函数定义
    }
    

    b)注意:

    把函数声明非模板函数:
    [cpp] view plain copy

    friend ostream& operator<< (ostream& cout,const MGraph& G);  
    

    把函数声明为模板函数:
    [cpp] view plain copy

    friend ostream& operator<< <>(ostream& cout,const MGraph<VexType,ArcType>& G);  
    

    或:
    [cpp] view plain copy

    friend ostream& operator<< <VexType,ArcType>(ostream& cout,const MGraph<VexType,ArcType>& G);  
    

    说明:
    在函数声明中加入operator<< <>:是将operator<<函数定义为函数模板,将函数模板申明为类模板的友员时,是一对一绑定的
    实际的声明函数:这里模板参数可以省略,但是尖括号不可以省略
    [cpp] view plain copy

    friend ostream& operator<< <VexType,ArcType>(ostream& cout,const MGraph<VexType,ArcType>& G);  
    

    5、友元函数和类的成员函数的区别:成员函数有this指针,而友元函数没有this指针。

    6、记忆:A是B的友元《=》A是B的朋友《=》借助B的对象,在A中可以直接 通过B。成员变量(可以是公有,也可以为私有变量) 的方式访问B


    分割线


    因为友元函数是类外的函数所以友元函数的声明放在了类外或则类内是没有区别的
    友元函数可以直接调用不需要通过对象或者指针

    展开全文
  • 以下是对C++运算符重载 成员函数与友元函数进行了介绍,需要的朋友可以过来参考下
  • 二、友元函数友元函数在类作用域外定义,但它需要在类体中进行说明为了与该类的成员函数加以区别,定义的方式是在类中用关键字friend说明该函数,格式如下: friend 类型 友元函数名(参数表);友元的作用在于提高...
  • 友元函数 friend

    千次阅读 2017-07-06 15:09:24
    一、一个类的成员函数有三个互不相干作用 ...友元函数作用域不属于类的作用域,不是类的成员,也就不是类的方法,不受公有、私有、保护限制。 2.友元函数可以在类中实现,也可以在类外实现(一般是在类的

    一、一个类的成员函数有三个互不相干作用

    1.可以通过类的成员方法,访问它的私有数据。

            2.该函数的作用域在类中。

            3.在外部调动该函数必须通过成员访问符访问,也就是必须经由一个对象去激活(有一个this指针)。

    二、友元函数

    1.友元函数作用域不属于类的作用域,不是类的成员,也就不是类的方法,不受公有、私有、保护限制。

    2.友元函数可以在类中实现,也可以在类外实现(一般是在类的外部实现)。

    3,声明成友元函数,可以通过友元函数实现对类的私有数据进项访问。(但是他没有this指针)

    4.一般友元函数声明在类的最前面

    5.友元函数是为另外一个类的成员方法,则其作用域为另外一个类的作用域。

    6.友元类,在一个类中声明为友元类,则该友元类都可以访问他的私有数据

    在类的外部实现,也可以在内部实现

    三、输出运算符<<、输入运算符>>的重载

    我们平时可以用流 std::cout<<str<<n ; std::cin>>str>>n ; 输出、输入字符串和整型等内置类型的值。但是对于我们自定义的类,比如 Student 类,却不能直接通过 cout<<Student 或 cin>>Student 这样的形式来输出类的内容或给类赋值。怎么办呢?我们可以通过重载输出、输入运算符,让自定义的类也支持这样的操作。

    1.在引入iostream头文件,标准的命名空间的后,ostream 输出流(类),其中cout是它的一个对象, istream输入流对象,cin是它的一个对象。

    2.输入输出流对象一般只是对内置类型进行输出,对对象的输出要进行运算符的重载

    3.输入、输出运算符的重载,一般通过友元函数,进行实现,友元函数可以访问一个类的私有数据,通过友元函数可以实现对类的输出;

           在类中声明成友元函数才能访问私有数据

      这样的话调动cout<<c<<endl;就可以对对象进行输出

    4.输入输出运算符的重载也可以是类的成员方法,在类的内部实现,只不过输出格式比较诡异通过类的对象调动cout对象 c<<cout;

    展开全文
  • 关于c+模板之友元类友元函数的实例化,图形界面之矩形。
  •  讲友元之前先讲普通的成员函数函数指针  <code class=sourceCode>class Std_interface {  public:  virtual void suspend() = 0;  };  // define the pointer of function  typedef void (Std_...
  • 一个实例,实现运算符重载(成员函数和非成员函数两种方式),友元函数的使用,注意事项等,自己学习时编写的,
  • 一、友元函数友元函数是一种特殊的函数,它需要在类体内进行说明,可以访问类的私有成员和保护成员,但又不是类的成员函数。友元函数的说明如下:friend 数据类型函数名(参数)其中,friend是说明友元函数的关键字,...

    af418581e80ee46ab8edbe9e564d37f7.png

    一、友元函数

    友元函数是一种特殊的函数,它需要在类体内进行说明,可以访问类的私有成员和保护成员,但又不是类的成员函数。友元函数的说明如下:

    friend 数据类型函数名(参数)

    其中,friend是说明友元函数的关键字,友元声明可以出现在类中的任何地方。通常,将友元声明成组地放在类定义的开始或结尾是个好主意。归纳起来,友元函数是一种能够访问类中私有成员的非类成员函数,友元函数在定义上和调用上与普通函数一样。友元的作用在于提高程序的运行效率,但是,它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。因此,只有在十分需要的时候才使用友元函数。 例如:分析下面程序的输出结果

    #include

    #include

    using namespace std;

    class TPoint

    {

    private:

    double x,y; //私有数据成员

    public:

    TPoint(double a,double b) //构造函数

    {

    x=a,y=b;

    cout<

    }

    friend double distanceoftwopoints(TPoint &a, TPoint &b) //友元函数

    {

    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));

    }

    } ;

    int main()

    {

    TPoint p1(2,2),p2(5,5);

    cout<

    return 0;

    }

    上述程序中,distaceoftwopoints()是类TPoint的友元函数,在其中可以直接使用a.x等,由于x等是类TPoint的私有成员,所以在普通函数中是不能这么使用的,但是在友元函数中则可以。下面是该程序的输出。

    9eb52dbc6d53aaa00fbc7ec25e70b006.gif

    友元函数的一个重要特点是它可以是多个类的友元。例如,编写一个程序,求一个点到直线的距离。设计一个点类Point,它有两个私有数据成员x和y,表示点的坐标。另一个类为直线类Line,它有三个私有数据成员a,b和c,表示直线方程ax+by+c=0。这两个类中都说明了一个友元函数dist,用于计算一个点到直线的距离。点(x,y)到直线ax+by+c=0的距离d的计算公式如为:d=abs((ax+by+c)/sqrt(a* a+b*b)),其中abs是求绝对值函数,sqrt是求平方根函数。代码如下:

    #include

    #include

    using namespace std;

    class Line;//提前说明

    class Point

    {

    int x,y;

    public:

    Point(int x1,int y1)

    {

    x=x1; y=y1;

    }

    friend double dist(Line l, Point p);//友元函数说明

    } ;

    class Line

    {

    int a,b,c;

    public:

    Line(int a1, int b1, int c1)

    {

    a=a1; b=b1; c=c1;

    }

    friend double dist(Line l, Point p);//友元函数说明

    };

    double dist(Line l, Point p)//注意:类内已经说明,因此函数前不要加friend

    {

    double d;

    d = abs(l.a*p.x+l.b*p.y+l.c)/(sqrt(l.a*l.a+l.b*l.b));

    return d;

    }

    int main()

    {

    Point p(10,10);

    Line l(2,4,-3);

    cout<

    return 0;

    }

    下面是该程序的输出结果:上述程序中有两个类Point和Line,它们都说明了同一个友元函数:friend double dist(Line l, Point p)。由于在Point类中说明时尚未定义类Line,所以需要在前面用class Line语句进行提前说明。该程序的执行如下:

    7726b4b19e263c1a9b9b5b9a1a301c63.gif

    一个类A的成员 函数f()可以作为另一个类B的友元函数,在这种情况下,必须先定义A类,并且在B类中说明友元函数f()时,要加上成员函数所在类的类名,即:

    class A

    {

    ...

    数据类型 f(参数表)

    ...

    }

    class B

    {

    ...

    friend 数据类型 A::f(参数表);

    ...

    }

    数据类型 A::f(参数表)

    {

    函数体;

    }二、友元类

    除了前面所讲过的友元函数外,友元还可以是一个类,即一个类可以作为另一个类的友元。当一个类作为另外一个类的友元时,就意味着这个类的所有成员函数都是另一个类的友元函数。例如,以下程序说明类B是类A的友元类:

    class A

    {

    ...

    Public:

    friend class B;//说明B是A的友元类

    ...

    }

    例如,有如下程序

    #include

    #include

    using namespace std;

    class A

    {

    int x;

    public:

    A() {x=5;}

    friend class B;//说明B是A的友元类

    };

    class B

    {

    public:

    void disp1(A tmp){

    tmp.x++;

    cout<

    }

    void disp2(A tmp){

    tmp.x--;

    cout<

    }

    };

    int main()

    {

    A obj1;

    B obj2;

    obj2.disp1(obj1);

    obj2.disp2(obj1);

    return 0;

    }

    }

    上述程序中,类B是类A的友元类,类B包括两个成员函数,这两个成员函数可以当成类A自己的友元函数一样使用,该程序执行结果如下:

    788942a6c8886aec9b819f8790eb4d9b.gif

    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。关于友元类的注意事项:(1)友元关系不能被继承。(2)友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。(3)友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明。

    三、习题解析

    1.一个类的友元函数能够访问该类的( )。A.私有成员 B.保护成员 C.公有成员 D.所有成员

    解析:一个类的友元函数对类成员的访问能力等同于类的成员函数,即能访问类的所有成员,选D。

    2.下列的各类函数中,( )不是类的成员函数。A、 构造函数 B、析构函数 C、友元函数 D、拷贝初始化构造函数

    答案:C

    3.下列关于友元的描述中,错误的是( )A.友元函数可以访问该类的私有数据成员B.一个类的友元类中的成员函数都是这个类的友元函数C.类与类之间的友元关系可以继承D.友元可以提高程序的运行效率

    解析:友元关系是不能被继承的,并且是单向的,不可交换的。

    4.下列程序利用友元函数求2个点的距离,找出存在的错误(有2个错)。

    #include

    #include

    class Tpoint

    { double x,y;

    public:

    Tpoint(double a,double b)

    { x=a; y=b; }

    friend double distance(Tpoint &, Tpoint &);

    };

    double Tpoint::distance(Tpoint &p1,Tpoint &p2)

    { double dist;

    dist=sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));

    return dist;

    }

    int main()

    { Tpoint p1(2,2),p2(5,6);

    cout<

    return 0;

    }四、小结

    在需要允许某些特定的非成员函数访问一个类的私有成员(及受保护成员),而同时仍阻止一般的访问的情况下,友元是可用的。

    优点:可以灵活地实现需要访问若干类的私有或受保护的成员才能完成的任务;便于与其他不支持类概念的语言(如C语言、汇编等)进行混合编程;通过使用友元函数重载可以更自然地使用C++语言的IO流库,便于实现运算符的重载等功能。

    缺点:一个类将对其非公有成员的访问权限授予其他函数或者类,会破坏该类的封装性,降低该类的可靠性和可维护性。

    参考书目

    《C++ Primer》,《C++语言习题与解析》等

    展开全文
  • 友元函数代码实例

    2015-05-19 19:56:54
    友元函数,类外普通函数声明为类的友元,之后即可与类共享数据
  • 私有成员只能在类的成员函数内部访问,如果想在别处访问对象的私有成员,只能通过类提供的接口(成员函数)间接地进行。这固然能够带来数据隐藏的好处,利于将来程序的扩充,但也会增加程序书写的麻烦。
  • 友元函数的特点是能够访问类中的私有成员的非成员函数。友元函数从语法上看,它与普通函数一样,即在定义上和调用上与普通函数一样
  • C++ 友元函数

    2020-11-20 16:37:25
    1.友元函数的简单介绍 1.1为什么要使用友元函数 在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数。 具体来说:...

    1.友元函数的简单介绍
    1.1为什么要使用友元函数
    在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数。
    具体来说:为了使其他类的成员函数直接访问该类的私有变量。即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类共享同一函数。

    实际上具体大概有下面两种情况需要使用友元函数:(1)运算符重载的某些场合需要使用友元。(2)两个类要共享数据的时候。

    1.2使用友元函数的优缺点
    优点:能够提高效率,表达简单、清晰。
    缺点:友元函数破环了封装机制,尽量不使用成员函数,除非不得已的情况下才使用友元函数。
    2.友元函数的使用
    2.1友元函数的参数:
    因为友元函数没有this指针,则参数要有三种情况:
    要访问非static成员时,需要对象做参数;
    要访问static成员或全局变量时,则不需要对象做参数;
    如果做参数的对象是全局对象,则不需要对象做参数;
    2.2友元函数的位置
    因为友元函数是类外的函数,所以它的声明可以放在类的私有段或公有段且没有区别。
    2.3友元函数的调用
    可以直接调用友元函数,不需要通过对象或指针
    2.4友元函数的分类:
    根据这个函数的来源不同,可以分为三种方法:
    普通函数友元函数:
    目的:使普通函数能够访问类的友元
    语法:
    声明: friend + 普通函数声明
    实现位置:可以在类外或类中
    实现代码:与普通函数相同
    调用:类似普通函数,直接调用
    代码:

    class INTEGER
    
     {
    
      friend void Print(const INTEGER& obj);//声明友元函数
    
     };
    
    void Print(const INTEGER& obj)
    
    {
    
       //函数体
    
    }
    
    void main()
    
    {
    
      INTEGER obj;
    
      Print(obj);//直接调用
    
    }
    

    类Y的所有成员函数都为类X友元函数—友元类

    目的:使用单个声明使Y类的所有函数成为类X的友元,它提供一种类之间合作的一种方式,使类Y的对象可以具有类X和类Y的功能。

    语法:

    声明位置:公有私有均可,常写为私有(把类看成一个变量)

    声明: friend + 类名(不是对象哦)

    代码:

    class girl;
    
    class boy
    
    {
    
    public:
    
      void disp(girl &);
    
    };
    
    void boy::disp(girl &x) //函数disp()为类boy的成员函数,也是类girl的友元函数
    
    {
    
      cout<<"girl's name is:"<<x.name<<",age:"<<x.age<<endl;//借助友元,在boy的成员函数disp中,借助girl的对象,直接访问girl的私有变量
    
    }
    
    class girl
    
    {
    
    private:
    
      char *name;
    
      int age;
    
      friend boy; //声明类boy是类girl的友元
    
    };
    

    main函数就不写了和普通调用时一样的。

    类Y的一个成员函数为类X的友元函数

    目的:使类Y的一个成员函数成为类X的友元,具体而言:在类Y的这个成员函数中,借助参数X,可以直接以X的私有变量

    语法:

    声明位置:声明在公有中 (本身为函数)

    声明:friend + 成员函数的声明

    调用:先定义Y的对象y—使用y调用自己的成员函数—自己的成员函数中使用了友元机制

    代码:

    实现代码和2.4.2.3中的实现及其相似只是设置友元的时候变为friend void boy::disp(girl &);

    小结:其实一些操作符的重载实现也是要在类外实现的,那么通常这样的话,声明为类的友元是必须滴。
    4.友元函数和类的成员函数的区别
    4.1 成员函数有this指针,而友元函数没有this指针。
    4.2 友元函数是不能被继承的,就像父亲的朋友未必是儿子的朋友。
    注意:

    1.类中通过使用关键字friend 来修饰友元函数,但该函数并不是类的成员函数,其声明可以放在类的私有部分,也可放在共有部分。友元函数的定义在类体外实现,不需要加类限定。

    2.一个类中的成员函数可以是另外一个类的友元函数,而且一个函数可以是多个类友元函数。

    3.友元函数可以访问类中的私有成员和其他数据,但是访问不可直接使用数据成员,需要通过对对象进行引用。

    4.友元函数在调用上同一般函数一样,不必通过对对象进行引用。

    例如如下形式:这里解释上面的1,3,4要点的使用,加以理解。

    #include <iostream>
    #include <cstring>
    using namespace std;
    
    class persion{
    public:
          persion(char *pn);
    
          //友元函数;
          friend void setweigth(persion &p,int h);//注意,参数列表中一般会有一个引用类型的形参,原因参考上面的使用要点3和4;
          void disp(); //类成员函数
    private:
          char name[20];
          int weigth,age;      
    };
    
    persion::persion(char *pn)   //构造函数
    {
       strcpy(name,pn);
       weigth=0;
    }
    void persion::disp()
    {
    cout<<name<<"--"<<weigth<<endl;
    }
    
    
    //友元函数的具体实现:这里没有类限定例如 (perion::setweigth)这种形式,这里可以与上面的disp()做个对比,一个属于类的成员,有限定,不属于类的成员函数,没有加限定。
    void setweigth(persion &pn,int w)
    {
    strcpy(pn.name,pn);//实现字符串复制
    pn.weigth=w;       //私有成员数据赋值
    
    }
    
    void  main()
    {
      persion p("zhansan");
      //调用实现setweigth(),与一般函数调用一致。
      setweigth(p,60);
    
      p.disp();  //调用类的成员函数。
    
    }
    

    关于要点2的使用,我给出一段代码案例:

    #include <iostream>
    #include <cstring>
    using namespace std;
    
    class wheel;
    class car{
    public:
        car(char *pn);
        void run(wheel &w);    //成员函数,做成wheel类中友元函数实现
    private:
        char name[20];
    
    };
    car::car(char *pn)
    {
    strcpy(name,pn);
    }
    
    class wheel{
    public:
        wheel(int s);
        friend void car::run(wheel &w);   //这里把car类的成员函数做了友元函数。
    private:
        int speed;
    };
    wheel::wheel(int s)
    {
      speed=s;
    }
    int  main(int argc, char const *argv[])
    {
        wheel w(60);
        car c("New car");
        c.run(w);
        return 0;
    }
    
    void car::run(wheel &w)   //car类成员函数的实现
    {
        cout<<"the car is running"<<endl;
        cout<<"name: "<<name<<" speed :"<<w.speed<<endl;
    }
    

    另外:

    1.C++中引入友元函数,是为在该类中提供一个对外(除了他自己意外)访问的窗口;

    2.这个友元函数他不属于该类的成员函数,他是定义在类外的普通函数,只是在类中声明该函数可以直接访问类中的private或者protected成员。

    3.将数据和处理数据的函数封装在一起,构成类,实现了数据的隐藏,无疑是面向对象程序设计的一大优点。但是有时候封装不是绝对的。

    4.友元函数提供了不同类或对象的成员函数之间、类的成员函数和一般函数之间进行数据共享的机制。通俗的说,友元关系就是一个类主动声明哪些类或函数是它的朋友,进而给它们提供对本类的访问特性。也就是说,通过友元关系,一个普通函数或者类的成员函数可以访问封装于另外一个类中的数据。

    5.从一定程度上讲,友元是对数据隐藏和封装的破坏,但是为了数据共享,提高程序的效率和可读性,很多情况下这种小的破坏是必要的。

    6.在一个类中,利用关键字friend将其它函数或类声明为友元。如果友元是一般函数或类的成员函数,称为友元函数。如果友元是一个类,则称为友元类。友元类的所有成员函数都自动称为友元函数。

    展开全文
  • C++中友元(友元函数和友元类)的用法和功能

    千次阅读 多人点赞 2018-09-04 20:59:07
    但是,有时需要定义一些函数,这些函数不是类的一部分,但又需要频繁地访问类的数据成员,这时可以将这些函数定义为该函数的友元函数。除了友元函数外,还有友元类,两者统称为友元。友元的作用是提高了程序的运行...
  • 一、友元函数 二、友元类 三、友元的优缺点 一、友元函数 结合着类的特性,可知:类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员,程序中的其他函数是无法访问私有成员的。非成员函数可以...
  • C++中的友元函数

    2021-05-13 02:49:54
    1为什么要使用友元函数在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数。具体说:为了使其他类的成员函数直接访问...
  • 友元函数和友元类

    2021-05-26 22:40:49
    友元有:友元函数,友元成员,友元类 友元可以放在类的公有,私有,保护部分。 友元函数 1.友元函数可访问类的私有和保护成员,但不是类的成员函数 2.友元函数不能用const修饰 3.友元函数可以在类定义的任何地方...
  • 在c++中,经常会定义类。类有一个特点就是数据封装数据...使用友元函数将百分制学生的成绩转换成相应的分数等级。 #include<iostream> using namespace std; #include<iomanip> #include<string.h>
  • 当声明了友元函数或者友元类之后,该函数或者类可以访问类的所有成员,包括private成员,当然访问过程需要通过类的对象进行。例如声明一个友元函数,有两种情况: ①该函数是普通的全局函数 一般情况下,使用一个...
  • 主要介绍了C++编程中的友元函数和友元类,属于较为冷僻的知识,在实际开发中较少使用,需要的朋友可以参考下
  • 友元函数

    2014-05-17 21:56:00
    一.友元函数的说明和使用: 在定义
  • C++——友元函数&内联函数

    千次阅读 多人点赞 2018-12-07 23:55:15
    友元函数 类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被...
  • C++:成员友元函数(成员函数友元化) 友元函数 友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。类授予它的友元特别的访问权。 友元函数既可以是不属于任何类的非成员函数(全局函数),也可以是另一...
  • 在一个类中,可以利用关键字friend将其他的函数或类声明为友元,如果友元是一般函数或者类的成员函数,称为友元函数,如果友元是一个类,则成为友元类,友元类的所有成员函数都自动成为友元函数友元函数友元...
  • C++友元函数的定义和使用 <C++析构函数C++友元类> 类的封装性实现了数据隐藏,即类的私有成员在该类的作用域之外是不可见的。但有时可能需要在类的外部访问类的私有成员,为此 C++ 提供了一种允许类外的函数...
  • 输出流函数重载为成员方法以及全局函数 ①以下输出流重载为成员方法虽然解决了this指针抢占第一个参数的问题,但方法的调用必须用对象去驱动如下: t1 << cout ; 或 t1 << cout << endl; 这种...
  • 借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。friend 的意思是朋友,或者说是好友,与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉,倾诉自己的...
  • C++ 之友元函数

    2020-06-25 17:08:42
    友元函数 概念: 类里面可以定义public、protected、private三种属性的成员,通过对象可以访问public成员,只有本类中的函数可以访问本类的private成员。 在C++里有一种特殊机制——友元(friend)。借助友元...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,590
精华内容 19,036
关键字:

友元函数的作用

友情链接: TreeGridViewDemo.rar