精华内容
下载资源
问答
  • 今天在牛客网刷题的时候遇到这样一个题,和大家分享一下 这道题我做错了,看完解析之后还是有些似懂非懂,于是去查看了一些友元函数和友元类的相关资料,给大家...D:在外部定义友元函数时,不必加关键字friend 友...

    今天在牛客网刷题的时候遇到这样一个题,和大家分享一下
    牛客网
    这道题我做错了,看完解析之后还是有些似懂非懂,于是去查看了一些友元函数和友元类的相关资料,给大家分享一下,首先我们先来分析一下这个题:

    • A:在C++中友元函数是独立于当前类的外部函数
    • B:一个友元函数可以同时定义为两个类的友元函数
    • C:友元函数既可以在类的内部,也可以在类的外部定义;
    • D:在外部定义友元函数时,不必加关键字friend

    友元的定义

    • 友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员
    • c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。
    • 友元的正确使用能提高程序的运行效率,但同时也破坏了类的封装性和数据的隐藏性,导致程序可维护性变差,因此友元不建议多使用和乱使用。

    友元函数 :

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

    friend 类型 函数名(形式参数);

    • 友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。
    • 友元函数既可以在类的内部,也可以在类的外部定义,在外部定义友元函数时,不必加关键字friend
    • 一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
    • 友元函数的调用与一般函数的调用方式和原理一致。

    友元类 :

    • 友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。
    • 当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。定义友元类的语句格式如下:

    friend class 类名;
    其中:friend和class是关键字,类名必须是程序中的一个已定义过的类。

    举个栗子看看友元函数和友元类

    class Radius
    {
    	friend class Circle;            //声明Circle为Radius的友元类
    	friend void Show_r(Radius &n);     //声明Show_r为友元函数
    public:
    	Radius(int x)
    	{
    		r = x;
    	}
    	~Radius(){}
    		
    private:
    	int r;
    };
    
    void Show_r(Radius &n)//友元函数可在类外定义,不用加关键字friend
    {
    	     cout << "圆的半径为: " << n.r << endl;    //友元函数可以调用Radius对象的私有成员变量r
    	 }
    
    class Circle
    {
     public:
    	 Circle(){}
    	~Circle(){}
    	 double area(Radius a)
    	 {
    		 s = a.r * a.r * 3.1415926;   //友元类可调用Radius对象的私有成员变量r
    		 return s;
    	 }
    private:
    	double s;
    };
    int main()
    {
    	Radius objRadius(9);
    	Circle objCircle;
    	Show_r(objRadius);
    	cout << "面积为:" << objCircle.area(objRadius) << endl;
    	
    	return 0;
    }
    

    友元函数和友元类
    一个函数可以被声明为两个类的友元

    //一个函数可以被两个类声明为友元
    class Teacher;//只申明
    class Student
    {
    public:
    	friend bool is_equal(Student&,Teacher&);
    private:
    	int _sid;
    };
    
    class Teacher
    {
    public:
    	friend bool is_equal(Student&, Teacher&);
    private:
    	int _tid;
    };
    

    使用友元类时注意:

    • (1) 友元关系不能被继承,举个栗子:若A是B的友元,C是A的派生类,C不是B的友元。
    • (2) 友元关系是单向的,不具有交换性。举个栗子:若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    • (3) 友元关系不具有传递性。举个栗子:若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明
    展开全文
  • 友元函数

    2018-04-14 18:12:21
    友元函数和友元类友元函数和不同函数的区别:友元函数在类中声明,那么这个函数就能访问里面的所有成员变量。...那么怎么定义友元函数呢?常规的定义一个函数(这个函数里面的形参是一个对象),然后把这...

    友元函数和友元类

    友元函数和不同函数的区别:

    友元函数在类中声明,那么这个函数就能访问里面的所有成员变量。

     

    友元函数想干嘛?

    如果我自己定义了一个函数,函数的形参是一个对象,在函数体里面,通过这个对象我访问对象里的所有成员变量,这显然是不行的,因为private/protected不能被外部访问。那怎么办?通过友元函数!

    那么怎么定义友元函数呢?

    常规的定义一个函数(这个函数里面的形参是一个对象),然后把这个函数就是把一个函数放在对象所在的类里面,并且要在前面加个friend.

    有点extern的味道

     

     

    如果一个类A想访问类B的成员变量,那么:

    在类B中声明友元函数时,必要要指明这个友元函数时类A中的。为什么呢?

    显然,如果不指明他是类A空间里的话,那么在外部编写这个友元函数时候就不能访问成员变量,这是因为,类A并没有准确的将他做朋友啊~~~

    展开全文
  • 一、友元函数介绍  一般情况下,非类成员函数是不能访问成员变量的。但是有时候我们为了提高程序运行效率,希望外部函数能直接...友元函数在类作用域外定义,但它需要在类体中进行说明,为了与该类的成员函数加以区

    一、友元函数介绍

            一般情况下,非类成员函数是不能访问成员变量的。但是有时候我们为了提高程序运行效率,希望外部函数能直接访问类的成员变量。此时我们可以使用友元。友元是一种允许非类成员函数访问类的非公有成员的一种机制。可以把一个函数指定为类的友元,也可以把整个类指定为另一个类的友元。

    二、友元函数

    友元函数在类作用域外定义,但它需要在类体中进行说明,为了与该类的成员函数加以区别,定义的方式是在类中用关键字friend说明该函数,格式如下:
    friend  类型 友元函数名(参数列表);
    比如我们定义了一个Point类,我们希望提供一个函数计算两点之间的距离。我们有两种选择,可以使用成员函数如:Point a;Point b; a.Distance(b);但是这样不太直观,因为我们比较习惯传入两个Point对象,返回它们的Distance。例子如下:
    #include <math.h>
    #include <iostream>
    using namespace std;
    
    class Point
    {
    <span style="white-space:pre">	</span>friend double Distance(const Point& p1, const Point& p2);
    public:
    <span style="white-space:pre">	</span>Point(int x, int y);
    private:
    <span style="white-space:pre">	</span>
    <span style="white-space:pre">	</span>int x_;
    <span style="white-space:pre">	</span>int y_;
    };
    Point::Point(int x, int y) : x_(x), y_(y)
    {
    
    
    }
    double Distance(const Point& p1, const Point& p2)
    {
    <span style="white-space:pre">	</span>double dx = p1.x_ - p2.x_;
    <span style="white-space:pre">	</span>double dy = p1.y_ - p2.y_;
    
    
    <span style="white-space:pre">	</span>return sqrt(dx*dx + dy*dy);
    }
    
    int main(void)
    {
    <span style="white-space:pre">	</span>Point p1(3, 4);
    <span style="white-space:pre">	</span>Point p2(6, 9);
    
    
    <span style="white-space:pre">	</span>cout<<Distance(p1, p2)<<endl;
    <span style="white-space:pre">	</span>return 0;
    }
    注意:友元函数必须有一个参数是友元类的指针或引用。这是理所当然的,既然是类的友元函数,必须要访问类的成员,而访问类的成员要有一个该类的指针或引用参数。(想一想为什么必须是指针或引用?)
    友元函数注意事项:
    • 友元函数不是类的成员函数。在函数体中访问对象的成员,必须用对象名加运算符“.”加对象成员名(指针用->)。但友元函数可以访问类中的所有成员(公有的、私有的、保护的),一般函数只能访问类中的公有成员。
    • 友元函数不受类中的访问权限关键字限制。可以把它放在类的公有、私有、保护部分,但结果一样。
    • 某类的友元函数的作用域并非该类作用域。如果该友元函数是另一类的成员函数,则其作用域为另一类的作用域,否则与一般函数相同。
    • 友元函数破坏了面向对象程序设计类的封装性。所以友元函数如不是必须使用,则尽可能少用。或者用其他手段保证封装性。
    三、友元类
            如果某类B的成员函数会频繁的存取另一个类A的数据成员, 而A的数据成员的Private/Protectd限制造成B存取的麻烦, B只能通过A的Public的成员函数进行间接存取,可以把B做成A类的友元类,即A类向B类开发其Private/Protectd内容, 让B直接存取。
    友元类:一个类可以作另一个类的友元
    友元类的所有成员函数都是另一个类的友元函数
    友元类的声名:friend class 类名;
    例子如下(类B能访问类A的所有私有成员):
    #include <iostream>
    using namespace std;
    class A
    { 
    	friend class B ;
    public :
    	void  Display() { cout << x << endl ; } ;
    private :
    	int  x ;
    } ;
    class  B
    { 
    public :
    	void Set ( int i ) { Aobject.x = i ; } //通过类成员访问A的私有成员
    	void Display ()  { Aobject.Display () ; } 
    private :
    	A  Aobject ;
    };
    int main()
    {
    	B  Bobject ;
    	Bobject.Set(100) ;
    	Bobject.Display() ;
    	return 0;
    }
    友元类注意事项:
    • 友元关系是单向的。B是A的友元类,但是B不是A的友元类。(A把B当成好朋友,但是B不把A当做好朋友)
    • 友元关系不能被传递。B是A的友元,A是C的友元。那么B不是C的友元。
    • 友元关系不能被继承。B是A的友元,C继承了B,那么B不是C的友元。




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

    2019-03-09 21:59:34
    友元函数的原型有声明在类中,友元函数定义在类外部友元函数并不是类的成员函数,但是有权访问类的所有私有(private)成员和保护(protected)成员。 因为友元函数没有this指针,则参数要有三种情况: 1.要...

    友元函数的原型有声明在类中,友元函数是定义在类外部,友元函数并不是类的成员函数,但是有权访问类的所有私有(private)成员和保护(protected)成员。

    因为友元函数没有this指针,则参数要有三种情况: 

    1.要访问非static成员时,需要对象做参数;

    2.要访问static成员或全局变量时,则不需要对象做参数;

    3.如果做参数的对象是全局对象,则不需要对象做参数.

    #include <iostream>
     
    using namespace std;
     
    class Box
    {
       double width;
    public:
       friend void printWidth( Box box );
       void setWidth( double wid );
    };
    
    // 成员函数定义
    void Box::setWidth( double wid )
    {
        width = wid;
    }
    
    // 请注意:printWidth() 不是任何类的成员函数
    void printWidth( Box box )
    {
       /* 因为 printWidth() 是 Box 的友元,它可以直接访问该类的任何成员 */
       cout << "Width of box : " << box.width <<endl;
    }
     
    // 程序的主函数
    int main( )
    {
       Box box;
     
       // 使用成员函数设置宽度
       box.setWidth(10.0);
       
       // 使用友元函数输出宽度
       printWidth( box );
     
       return 0;
    }

     

    展开全文
  • 友元函数,友元类

    2019-10-05 18:45:49
    类的友元函数定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • c++ 友元函数

    2020-04-23 10:13:18
    类的友元函数定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • 友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类, 但是需要在类的内部声明,声明时候需要加friend关键字 需注意 1、友元函数可以访问类的私有和保护成员,但不是类
  • C++友元函数

    2020-09-06 23:03:35
    类的友元函数定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • 换言之,某个类的友元函数的声明只能在这个类的内部,可以在private部分也可以在public部分,一般做法是将友元声明成组地放在类定义的开始或结尾处。 友元函数的形式: friend <返回类型> <函数名> (&...
  • 友元函数,内联函数

    2018-10-13 00:25:52
    类的友元函数定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • 友元函数和友元类

    2017-10-24 21:50:00
    类的友元函数定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • 目录​​​​​​​ 友元函数友元函数说明: ...1:友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字。 友元函数的...
  • C++友元函数和友元类

    2020-08-03 12:20:55
    类的友元函数定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • 一、友元介绍我们知道,类的成员函数可以访问同类的...友元函数友元类二、友元函数友元函数在类作用域外定义,但它需要在类体中进行说明为了与该类的成员函数加以区别,定义的方式是在类中用关键字friend说明该函数...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 368
精华内容 147
关键字:

外部定义友元函数