精华内容
下载资源
问答
  • 友元函数是在类中用关键字friend修饰友元函数,友元函数可以是个普通函数,也可以是其他类的成员函数。虽然它不是本类的成员函数,但是在它函数体中可以通过对象名访问类私有和保护成员。 ...

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

    友元函数:

    友元函数是在类中用关键字friend修饰的友元函数,友元函数可以是一个普通的函数,也可以是其他类的成员函数。虽然它不是本类的成员函数,但是在它的函数体中可以通过对象名访问类的私有和保护成员。

    友元普通函数:(将普通函数声明为友元函数)

    #include<iostream>
    using namespace std;
    class Time
    {
    public:
    	Time(int, int, int);
    	friend void display(Time &);//普通函数在类中的声明。
    private:
    	int hour;
    	int minute;
    	int second;
    };
    Time::Time(int h,int m,int s)
    {
    	hour = h;
    	minute = m;
    	second = s;
    }
    void display(Time &t)//普通函数在类中声明为友元
    {
    	cout << t.hour << ":" << t.minute << ":" << t.second << endl;
    }
    int main()
    {
    	Time p(13,42,32);
    	display(p);
    	return 0;
    }

    友元成员函数:

    将一个类中的成员函数去作为另一个类的友元成员函数,

    #include<iostream>
    using namespace std;
    class Date;
    class Time
    {
    public:
    	Time(int, int, int);
    	void display(Date &);
    private:
    	int hour;
    	int minute;
    	int second;
    };
    class Date
    {
    public:
    	Date(int, int, int);
    	friend void Time::display(Date &);
    private:
    	int month;
    	int year;
    	int day;
    };
    Time::Time(int h,int m,int s)
    {
    	hour = h;
    	minute = m;
    	second = s;
    }
    Date::Date(int y, int mon, int d)
    {
    	year = y;
    	month = mon;
    	day = d;
    
    }
    void Time::display(Date &t)
    {
    	cout <<t.year<<":"<<t.month<<":"<<t.day<<","<< hour << ":" << minute << ":" << second << endl;
    }
    int main()
    {
    	Time p(13,42,32);
    	Date q(2019, 4, 29); 
    	p.display(q);
    	return 0;
    }

    以上代码的逻辑上是display是Time类中的一个函数,在定义Time类之前声明了Date类,之后在Time类中声明,display函数的参数是Date类的引用,在Date类中进行声明,添加friend关键字,此时需要添加Time类作用符,之后在类外正常定义。目标就是将Time类的成员函数作为Date类的友元函数,就可以通过该友元函数访问Date类的私有成员

    友元类:

    跟友元函数很相似,可以将一个类作为另一个类的友元类,若A类是B类的友元类,则A类的所有成员函数都是B类的友元函数。都可以去访问B类的私有和保护成员,大概形式为:

    class B;
    class A
    {
       friend Class B;  
    }
    #include<iostream>
    using namespace std;
    class Date;
    class Time
    {
    public:
    	Time(int, int, int);
    	void display(Date &);
    private:
    	int hour;
    	int minute;
    	int second;
    };
    class Date
    {
    public:
    	Date(int, int, int);
    private:
    	int month;
    	int year;
    	int day;
    	friend class Time;
    };
    Time::Time(int h,int m,int s)
    {
    	hour = h;
    	minute = m;
    	second = s;
    }
    Date::Date(int y, int mon, int d)
    {
    	year = y;
    	month = mon;
    	day = d;
    
    }
    void Time::display(Date &t)
    {
    	cout << t.year << ":" << t.month << ":" << t.day << "," << hour << ":" << minute << ":" << second << endl;
    }
    int main()
    {
    	Time p(13,42,32);
    	Date q(2019, 4, 29); 
    	p.display(q);
    	return 0;
    }

    先声明一个Date类,然后自己再去定义一个Time类,之后再具体定义Date类,并自己在类中声明一个友元Time类,不过再Time类中的成员函数display()还需要加上Date &形参,之后按照友元函数操作一样,可以直接就实现了友元类的操作。 

    展开全文
  • 友元函数 友元类 友元成员函数

    千次阅读 2018-05-07 22:34:40
    友元 一般来说,类内私有数据是对外不可见,但在有些情况下,我们需要在类外对该类私有数据进行访问,这就需要用到一种新技术——友元(friend),即在声明前...友元函数是指某些非类成员函数,但可以访问类...

    友元

    一般来说,类内的私有数据是对外不可见的,但在有些情况下,我们需要在类外对该类的私有数据进行访问,这就需要用到一种新技术——友元(friend),即在声明前添加关键字friend

    友元关系是单向的,即如果A是B的友元,但B不一定是A的友元;
    友元关系无传递性,即如果A是B的友元,B是C的友元,但A不一定是C的友元。


    1. 友元函数

    友元函数是指某些非类成员函数,但可以访问类内的私有数据。

    #include <iostream>
    using namespace std;
    
    class A {
    private:
        int data;
    public:
        A() : data(1) {}
        friend void show( const A& t );  //添加friend定义友元函数
    };  
    
    /* 友元函数在类外声明时不加friend */
    void show( const A& t ) {
        cout << "data = " << t.data << endl;  
    }
    
    int main(void) {  
        A a;
        show(a);  
    
        return 0;  
    }
    
    /*
    
    运行结果:
    data = 1
    
    */

    2. 友元类

    友元类是指若需要在类B中直接访问类A的私有数据,因此将B作为A的友元(在A中声明friend class B;)。
    友元类中的成员函数、私有数据都可以在另一个类中被使用(即类B中可以直接使用类A的私有数据等)

    class Tv {
    private: 
        int state;
    public: 
        friend class Remote;  //声明Remote为Tv的友元类
        enum{ Off, On };
    
        Tv( int s = Off ) : state(s) {}
        void onoff() { state = (state == On) ? Off : On; }
    };
    
    class Remote {
    public: 
        void onoff( Tv & t ) { t.onoff(); }
    };

    3. 友元成员函数

    友元成员函数是指类中的一个成员函数被定义为友元函数。
    与友元类不同的是,只有友元成员函数可以在另一个中被使用,其余函数都不可以。

    #include <iostream>
    using namespace std;
    
    class B;  //前向声明
    
    class A{
    private: 
        int a;
    public: 
        A() { a = 1; }
        void print( B & b );
    };
    
    /* 示例位置1 */
    
    class B{
    private: 
        int b;
    public: 
        B() { b = 6; }
        void print() { cout << b << endl; }
        friend void A::print( B & b );  //友元成员函数
    };
    
    /* 被定义为友元成员函数的函数必须在类外(另一个使用该函数的类后面)定义 */
    void A::print( B & b ) {
        cout << "b = " << b.b << endl;
    }
    
    int main() {
        A a;
        B b;
        a.print( b );
    
        return 0;
    }
    
    /*
    
    输出结果:
    b = 6
    
    */

    需要注意的是:
    (1)类的前向声明。由于在A中的print函数需要使用B,如果不进行B的前向声明,编译器就不知道B是一个类,会报错。
    (2)类的排列顺序。在类B中会用到A的方法print(),因此需要先定义A,再定义B。
    (3)友元成员函数的定义位置。友元成员函数不能使用内联代码,类中只能有函数声明。函数定义需要放到类之后,在类外进行定义,而且必须放到另一个类定义的后面。(对上面代码来说,若将A::print()的定义放在类B定义之前——示例位置1处,也会报错,提示类B未完成)

    对于友元的位置在何处生明,可以简单记为friend在哪,哪个就可以被外面直接访问。(friend在类A,A就可以被其他特定位置访问)

    展开全文
  • 友元 一般来说,类公有成员能够在类外访问,私有成员只能被类其他成员函数...C++提供一种允许外部类和函数存取类私有成员和保护成员辅助方法,即将它们声明为一个给定类友元(或友元函数),使其具有类成

    友元

    一般来说,类的公有成员能够在类外访问,私有的成员只能被类的其他成员函数访问。

    在C++中,可以定义友元,如果某一个函数定义为类的友元,则该函数就可以访问该类的私有函数。也可以把一个类定义为另一个类的友元。

    友元函数

    如果在某个类的定义中用friend声明了一个外部函数(或者是其他类的成员函数,既可以是public型,也可以是private型)后,这个外部函数称为类的友元函数。

    C++提供一种允许外部类和函数存取类的私有成员和保护成员的辅助方法,即将它们声明为一个给定类的友元(或友元函数),使其具有类成员函数的访问权限,但友元本身不是类的成员,它不属于任何类

    使用:

    • 关键字:friend开头的函数原型,声明可以放在类的私有部分,或者公有部分,无区别,都说明是该类的一个友元函数,但它不是该类的成员函数,不属于任何类;
    • 友元函数的定义,可以在类的内部或外部;
    • 在类外定义友元函数时,与普通函数的定义一样,不应在函数名前用类名加以限制。因此友元函数不像成员函数那样在调用时使用对象名,友元函数要多类的成员进行访问,必须在参数表中显式指明要访问的对象。
    • 友元函数是能访问类的所有成员的普通函数,一个函数可以是多个类的友元函数,只需要在各个类中分别声明;
    • 调用与一般函数的调用方式及原理一致;
    • C++不允许将构造函数、析构函数和虚函数声明为友元函数

    友元的非成员函数

    友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,需要在类的定义中加以声明,声明时只需在友元的名称前加关键字**friend**,

    friend 函数原型;
    

    非成员函数的友元函数有如下特点。

    • 在类内只需对函数进行声明,声明位置没有要求,可以出现在类的任何地方,包括在privatepublic部分。
    • 函数定义要放在类外,具体定义位置没有要求。
    • 友元函数不能直接访问类的成员,必须通过访问对象来实现。为此,必须传递类对象作为函数参数,采用传值、传指针或传引用方式均可,出于对程序执行效率的考虑,建议使用类对象的引用作为参数。
    • 友元函数不是类的成员函数,所以友元函数的实现和普通函数一样,在实现时不用作用域限定符“::”指示属于哪个类,只有成员函数才使用“::”作用域符号。
    • 一个函数可以同时作为多个类的友元函数。

    非成员形式的友元函数代码如下所示。

    //友元函数的例子
    #include <iostream>
    #include <math.h>
    using namespace std;
    class Point
    {
    public:
        Point(double i, double j)                                  //构造函数,带默认参数值
        {
            x = i;
            y = j;
        }
        void disp()
        {
            cout<<"("<<x<<","<<y<<")"<<endl;
        }
    
    private:
        double x;
        double y;
        friend double dis(Point &a, Point &b);                      //友元函数的声明
    };
    
    double dis(Point &a, Point &b)                                 //类外,友元函数的定义
    {
        double dx=a.x-b.x;                                         //友元函数可以访问类的private成员
        double dy=a.y-b.y;
    
        return sqrt(dx*dx+dy*dy);
    }
    
    int main()
    {
        Point p1(3.0,4.0);                                        //声明两个Point类的对象p1和p2;
        Point p2(6.0,8.0);
        p1.disp();                                                //显示p1和p2点的信息
        p2.disp();                    
       
        cout<<"Distance is "<<dis(p1,p2)<<endl;                   //友元函数的调用
        return 0;
    }
    

    友元的成员函数

    除了一般的函数可以作为类的友元外,一个类的成员函数也可以作为另一个类的友元。这样的函数不仅可以访问本类的所有成员,还可以访问其友元类的所有成员。需要注意的是,当在一个类中的某个成员函数定义为另一个类的友元函数时需要首先定义此类。

    例如,要定义类A的某个函数为类B的友元函数,那么需要先定义类B,然后再进行类A的成员函数与B友元的定义。

    对于一个友元成员来说,它不仅可以访问自己所在类中的私有成员和公有成员,同时还可以的一个对声明为友元类的类的成员进行访问。使用友元成员可以使得两个类之间出现互相访问“门”。这样解决了由于类的保护机制而出现的其他类绝对不允许访问的情况。

    成员形式的友元函数代码如下所示。

    //友元函数的例子
    #include <iostream>
    using namespace std;
    class Point;                                                 //声明Point类:在line类的dis函数中传递对象参数。因此必须在line类之前对Point类                                                              //声明,且由于PoInt类的定义在后面,只能对Point对象采取传引用或传指针处理;
    class line                                                    //友元函数所在的类必须选定义,即line类必须定义在Point类前面
    {
        public:
        double dis(Point &p1, Point &p2);                         //友元函数的原型,作为line类的成员函数
    };
    
    class Point
    {
    public:
        Point(double i, double j)                                  //构造函数,带默认参数值
        {
            x = i;
            y = j;
        }
        void disp()
        {
            cout<<"("<<x<<","<<y<<")"<<endl;
        }
    
    private:
        double x;
        double y;
        friend double line::dis(Point &a, Point &b);               //友元的声明
    };
    
    double line::dis(Point &a, Point &b)                           //line类内的成员函数dis()的实现,作为Point类的友元函数;
    {
        double dx=a.x-b.x;                                         //友元函数可以访问类的private成员
        double dy=a.y-b.y;
    
        return sqrt(dx*dx+dy*dy);
    }
    
    int main()
    {
        line line1;                                               //声明一个line类的对象line1;
        Point p1(3.0,4.0);                                        //声明两个Point类的对象p1和p2;
        Point p2(6.0,8.0);
        p1.disp();                                                //显示p1和p2点的信息
        p2.disp();                    
       
        cout<<"Distance is "<<line1.dis(p1,p2)<<endl;                   //友元函数的调用
        return 0;
    }
    

    在这里插入图片描述

    友元类

    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。

    定义友元类的语句格式如下:

    friend class 类名(即友元类的类名);
    

    其中:friendclass是关键字。类名必须是程序中的一个已定义过的类。

    //类B是类A的友元类
    class A
    {
    Public:
        friend class B;
    };
    

    友元类B中的所有成员函数都是类A的友元函数,能存取类A的私有成员和保护成员。
    当把B声明为A类的友元类时,并不一定要求先定义B,只要先对其进行声明即可,这点区别于友元的成员函数。

    • 友元关系是单向的,不具有交换性。若类X是类Y的友元,类Y不一定是类X的友元,要看在类中是否有相应的声明。
    • 友元关系不具有传递性。若类X是类Y的友元,类Y是Z的友元,类X不一定是类Z的友元,同样要看类中是否有相应的申明。
    • 友元关系不能被继承。
    展开全文
  • 友元函数是一种说明在类定义体内的非成员函数。说明友元函数的方法如下: friend 返回值类型 函数名(参数表) 说明: 友元函数是在类中说明的一个函数,不是该类的成员函数,但允许访问该类的所有成员。它是独立于...

    友元分为友元函数、友元成员和友元类三种,友元声明可以放在类的公有、私有或保护,结果都一样的。

    一.友元函数

    友元函数是一种说明在类定义体内的非成员函数。说明友元函数的方法如下:
    friend 返回值类型 函数名(参数表)
    说明:

    1. 友元函数是在类中说明的一个函数,不是该类的成员函数,但允许访问该类的所有成员。它是独立于任何类的一般外界函数。
    2. 由于友元函数不是类的成员,所以没有this指针,访问该类的对象成员时,必须使用对象名。
    3. 虽然友元函数是在类中说明的,但其名字的作用域在类外,作用域的开始点在说明点,作用域的结束点和类名相同。
    4. 在类外定义友元函数时,去点friend关键字。

    二.友元成员

    另一个类的成员函数可以作为某个类的友元,只是在声明友元函数时要加上成员函数所在的类名,称为友元成员。
    声明如下:
    friend 类名::成员函数名(形参列表)

    三.友元类

    某一个类可以是另一个类的友元,这样作为友元类中的所有成员函数都可以访问另一个类中的私有成员。
    说明方式如下:
    friend class 类名;

    例题

    设计一个JX类表示矩形,矩形的长和宽作为其两个数据成员。编写一个求矩形面积的函数area(),并将它声明为JX的一个友元函数。利用area()求出该矩形的面积。
    运行结果如下:

    在这里插入图片描述
    代码如下:

    #include<iostream>
    using namespace std;
    class JX
    {
    friend int area(JX j);
    public:
    JX(int a,int b)
    {
    this->x=a;
    this->y=b;
    }
    void print()
    {
    cout<<"length:"<<this->x<<endl;
    cout<<"width:"<<this->y<<endl;
    }
    int x,y;
    };
    int area(JX j)
    {
    int a,b;
    a=j.x;
    b=j.y;
    return a*b;
    }
    int main()
    {
    JX j(12,5);
    j.print();
    int i;
    i=area(j);
    cout<<"area:"<<i<<endl;
    return 0;
    }
    展开全文
  • 1.友元函数是一种定义在类外部普通函数或类,但需要在类体内进行说明;成员函数是在一个类里面所定义函数。2.友元函数和成员函数一样可以访问类中私有成员成员函数,会破坏了类封装性和隐藏性。3.友元...
  • 例如声明友元函数,有两情况: ①该函数是普通的全局函数 一般情况下,使用个函数需要先声明,或者定义在前,但是声明个全局函数为友元函数的时候,可以理解为只是声明,而非调用,因此不用先在类的前面...
  • 友元一种允许非类成员函数访问类的非公有成员的一种机制。 可以把一个函数指定为类的友元,也可以把整个类指定为另一个类的友元。 (1)友元函数 (2)友元类,友元类的成员函数可以访问另一个类的所有 成员,但是...
  • C++中的友元机制允许类非公有成员被个类或者函数访问,友元按类型分为三:普通非类成员函数作为友元、类的成员函数作为友元、类作为友元。1、友元的内容友元包括友元的声明以及友元的定义。友元的声明默认为了...
  • 静态函数毫无疑问具有类作用域,而友元函数本身可能是全局函数、也可能是其他类的成员函数,所以我猜测是不是可以理解为静态函数是友元函数的一种特例。 接下来,我想验证友元函数是否也可以具有类作用域,所以我...
  • 友元函数

    2019-10-01 14:36:53
    友元函数是一种 1.定义在类外, 2.但是可以访问类域中的私有和保护成员。 即便友元函数的原型出现在类定义中,友元函数并不是成员函数,这一点尤其需要注意。 友元可以是函数、函数模版、成员函数;或者...
  • 私有成员对于类外部的所有程序部分而言都是隐藏的,访问它们需要调用一个公共成员函数,但有时也可能会需要创建该规则的一项例外。 友元函数是一个不属于类成员的函数,但它可以访问该类的私有成员。换句话说,...
  • 友元一种允许非类成员函数访问类的非公有成员的一种机制。可以把一个函数指定为类的友元,也可以把整个类指定为另一个类的友元。 友元函数友元类 二、友元函数友元函数在类作用域外定义,但它需要在类体中进行说明...
  • 友元一种允许非类成员函数访问类的非公有成员的一种机制。可以把一个函数指定为类的友元,也可以把整个类指定为另一个类的友元。 二、友元函数 友元函数在类作用域外定义,但它需要在类体中进行说明,为了与该...
  • 友元在我的理解中“朋友之间互通有无的一种表现”,只要在类体中声明了某个函数为友元(切记:这个函数为外来函数,并不是类的成员函数),那么无论这个函数声明在类体中那个位置(private,protected,public三者...
  • C++的友元函数

    2020-05-14 18:53:18
    友元 生活中你的家有客厅(Public),有你的卧室(Private) 客厅所有来的客人都可以进去,但是你的卧室私有的,也就是说只有你能...以上对友元函数的描述,可以知道友元函数可以访问class的private成员,但是友元函数
  • 只有类的成员函数才能访问类私有成员,程序中其他函数是无法访问私有成员。非成员函数可以访问类中公有成员,但是如果将数据成员都定义为公有,这又破坏了隐藏特性。另外,应该看到在某些情况下,特别是...
  • 要求: 编写个复数类complex, 用友元函数重载运算符 “+”...+和*均为双目运算符, 两处理方式参数个数不一样:运算符重载函数作为类的成员函数时,有个参数隐含 #include<iostream> using name...
  • 友元函数和友元类

    2019-10-05 12:00:39
    友元函数是一种特殊的函数,它需要在类体内进行说明,可以访问类的私有成员和保护成员,但又不是类的成员函数。 其中,friend是说明友元函数的关键字,友元声明可以出现在类中的任何地方。通常,将友元声明成组地...
  • 友元函数是一种特殊的函数,它必须要在类中进行声明,但其本身并不是类的成员函数,但友元函数可以访问类的私有成员变量。 友元函数的好处: 1、实现类之间的数据共享 2、提高程序运行效率,方便编程 友元函数的坏处...
  • cpp的友元函数

    2016-10-24 11:34:15
    友元函数的简单介绍为什么要使用友元函数友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。类授予它的友元特别的访问权。通常同个开发者会出于技术和非技术的原因,控制类的友元和成员函数(否则当你...
  • 友元是一种允许非类的成员函数访问该类的私有成员的一种方式。我们常用的方式用两种—友元函数,友元类。 友元函数 友元函数是可以访问类的私有成员的函数。他一般是在类外定义的全局函数,不属于任何类。子啊...
  • 2.联系:不管是成员函数还是友元函数重载,运算符: 使用方法相同。 传递参数方式不同,实现代码不同,应用场合也不同 。 二. 用成员函数重载运算符 1.当一元运算符操作数,或者二元运算符左操作数是类对象...
  • 友元函数的简单说明

    2020-12-21 15:46:47
    首先友元函数为了方便个类去访问另个类中的成员函数和成员变量,需要使用关键字friend在函数的声明时,友元函数不属于任何类的成员函数,它在类外定义的全局函数。可以在本类中声明友元函数,声明如下: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 854
精华内容 341
关键字:

友元函数是成员函数的一种