精华内容
下载资源
问答
  • 以下是对C++运算符重载 成员函数友元函数进行了介绍,需要的朋友可以过来参考下
  • 友元函数 友元 友元成员函数

    千次阅读 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就可以被其他特定位置访问)

    展开全文
  • 当声明了友元函数或者友元之后,该函数或者可以访问的所有成员,包括private成员,当然访问过程需要通过的对象进行。例如声明一个友元函数,有两种情况: ①该函数是普通的全局函数 一般情况下,使用一个...

    友元声明

    前面加上关键字friend,该声明可以放在任何一个地方,一般放在类的定义中。当声明了友元函数或者友元类之后,该函数或者类可以访问类的所有成员,包括private成员,当然访问过程需要通过类的对象进行。例如声明一个友元函数/类,有三种情况:
    ①友元是普通的全局函数
    一般情况下,使用一个函数需要先声明,或者定义在前,但是声明一个全局函数为友元函数的时候,可以理解为只是声明,而非调用,因此不用先在类的前面声明该全局函数。另外,如果要在类的前面声明该友元函数,需要用到类,因此还得在该声明的前面声明类的定义,比较麻烦。故总结顺序如下:类的定义,类中友元函数声明,类后友元函数实现。 这样的顺序应该万无一失了。

    #include<iostream>
    using namespace std;
    
    class student{
    	friend func(student *stu);//声明全局函数func为友元函数,不用在类前面声明,定义在后面。
    	private:
    		int age;
    //		void set_age(int t_age):age(t_age){};//不能使用初始化列表
    		void set_age(int t_age)
    		{
    			age = t_age;
    		 } 
    	public:
    		student(int t_age):age(t_age){};
    		void show_age(){cout<<"age = "<<age<<endl;};
    }; 
    void func(student *stu){
    	stu->set_age(-1); //可以通过对象访问private成员 
    	stu->show_age(); //当然也可以访问public成员
    }
    int main()
    {
    	student* stu = new student(10);
    	func(stu); //结果为: age = -1;
    	//查看age是否被修改
    	stu->show_age(); //结果为-1
    	//注意不能直接输出cout<<stu->age<<endl;
    	return 0;
    }
    

    这里刚开始的时候出了一个问题,set_age函数我使用了初始化列表,然后报错,搜查之后发现错误原因在于初始化列表的使用,注意:只有构造函数初始化的时候能使用初始化列表
    这里又发现了一个新的问题,在经过func函数之后,我想查看stu中的private成员age是否发生了变化,于是我试图通过直接输出age:

    cout << stu->age << endl;
    

    但是发现不可以,难道对象自己不能直接访问自己的私有数据成员么?
    查阅资料之后发现解释如下,private,public是针对类外的对象,类外的其他类对象的,这里stu定义在类外,因此不能访问私有数据成员。但是有一个例外,那就是友元函数,友元函数可以直接访问。而定义在类内的成员函数可以直接访问。总结一句话就是:在类内定义,可以访问,在类外定义,不能访问,友元函数可以访问
    ②友元是一个类
    同友元是一个函数一样,友元类可以先不定义,在当前类中声明友元类不会报错。所以顺序应该为:当前类的定义,类中声明友元类,友元类定义
    当然,如果先定义友元类,那么在友元类之前需要声明当前类。

    #include<iostream>
    using namespace std;
    
    class student {
    	friend class teacher; //声明一个友元类
    	//该友元类teacher还没有声明/定义,不会报错。
    private:
    	int age;
    	void set_age(int t_age);
    public:
    	student(int t_age) :age(t_age) {};
    	void show_age();
    };
    //友元类的实现
    class teacher {
    public:
    	teacher() {};
    	void func(student *stu); //如果把友元类定义在前,那么需要先声明student类,否则报错
    };
    void teacher::func(student* stu)
    {
    	stu->set_age(-1);
    	stu->show_age();
    }
    void student::set_age(int t_age)
    {
    	age = t_age;
    }
    void student::show_age()
    {
    	cout<<"age = "<<age<<endl;
    }
    int main()
    {
    	teacher* tea = new teacher();
    	student* stu = new student(10);
    	tea->func(stu); //age = -1
    	return 0;
    }
    

    ③友元是类中的一个成员函数
    这里需要注意的是:被声明为友元函数的成员函数必须定义在该类的前面,也就是这个成员函数所属的类在该类的前面定义,里面的成员函数可以只是先声明。也就是友元函数的类定义要在前面定义。但是问题来了,友元函数中的参数类型是当前类,所以得提前声明当前类。因此顺序为:当前类声明,友元类定义,当前类定义,两个类各种函数的具体实现。

    #include<iostream>
    using namespace std;
    class student; //必须提前声明,因为友元类中的函数要用到
    //友元函数所属类的定义必须在前,具体函数实现可以最后考虑
    class teacher {
    public:
    	teacher() {};
    	void func(student* stu); //友元函数
    };
    
    class student {
    	friend void teacher::func(student *stu); //声明一个类中的成员函数为友元函数
    private:
    	int age;
    	void set_age(int t_age);
    public:
    	student(int t_age) :age(t_age) {};
    	void show_age();
    };
    //两个类中的成员函数实现
    void teacher::func(student* stu)
    {
    	stu->set_age(-1);
    	stu->show_age();
    }
    void student::set_age(int t_age)
    {
    	age = t_age;
    }
    void student::show_age()
    {
    	cout<<"age = "<<age<<endl;
    }
    int main()
    {
    	student* stu = new student(10);
    	teacher* tea = new teacher();
    	tea->func(stu); //teacher类中的成员函数func被student类声明为友元函数,该函数可以访问student类所定义的对象的private成员
    
    	return 0;
    }
    
    

    最后需要注意两点:
    派生类中的友元函数对其基类不起作用,不能访问基类的private成员
    只有当某个类中的成员函数的定义都完整给出之后才能定义该类的对象。可以理解为,定义还没完成,无法确定存储空间大小,也就无法生成一个对象。

    展开全文
  • 搬运自:... ... 友元包括友元函数、友元 友元函数: 个人理解为在中声明的可以外部访问的内部成员变量的一个函数,这个函数并不是成员函数,只是在中声明,而定义在外。换...

    搬运自:https://www.cnblogs.com/zhuguanhao/p/6286145.html

    以及:https://blog.csdn.net/qq_26337701/article/details/53996104

    友元包括友元函数、友元类

    友元函数:

    个人理解为在类中声明的可以外部访问类的内部成员变量的一个函数,这个函数并不是类的成员函数,只是在类中声明,而定义在类外。换言之,某个类的友元函数的声明只能在这个类的内部,可以在private部分也可以在public部分,一般做法是将友元声明成组地放在类定义的开始或结尾处。

    友元函数的形式:

    friend <返回类型> <函数名> (<参数列表>);

    几个要点:

    1. 一个类中的成员函数可以是另外一个类的友元函数,而且一个函数可以是多个类友元函数。
    2. 友元函数可以访问类中的私有成员和其他数据,但是访问不可直接使用数据成员,需要通过对对象进行引用。
    3. 友元函数在调用上同一般函数一样,不必通过对对象进行引用。

    搬运https://blog.csdn.net/qq_26337701/article/details/53996104中的例子如下:

    #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();  //调用类的成员函数。
    
    }

    有一类特殊的友元函数,它本身是某个类中的成员函数,即使类B中的成员函数成为类A的友元函数。

    当用到友元成员函数时,需注意友元声明和友元定义之间的相互依赖,在该例子中,类B必须先定义,否则类A就不能将一个B的函数指定为友元。然而,只有在定义了类A之后,才能定义类B的该成员函数。更一般的讲,必须先定义包含成员函数的类,才能将成员函数设为友元。另一方面,不必预先声明类和非成员函数来将它们设为友元。

    搬运https://blog.csdn.net/u012796139/article/details/46404401的例子如下:

    #include <iostream>
     
    using namespace std;
     
    class A;    //当用到友元成员函数时,需注意友元声明与友元定义之间的互相依赖。这是类A的声明
    class B
    {
    public:
        void set_show(int x, A &a);             //该函数是类A的友元函数
    };
     
    class A
    {
    public:
        friend void B::set_show(int x, A &a);   //该函数是友元成员函数的声明
    private:
        int data;
        void show() { cout << data << endl; }
    };
     
    void B::set_show(int x, A &a)       //只有在定义类A后才能定义该函数,毕竟,它被设为友元是为了访问类A的成员
    {
        a.data = x;
        cout << a.data << endl;
    }
     
    int main(void)
    {
        class A a;
        class B b;
     
        b.set_show(1, a);
     
        return 0;
    }
    

    友元类:

    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括private成员和protected成员)。当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。

    关于友元类的注意事项:

    1. 友元关系不能被继承。
    2. 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    3. 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明。

    举例如下

    #include <iostream>
     
    using namespace std;
     
    class A
    {
    public:
        friend class C;                         //这是友元类的声明
    private:
        int data;
    };
     
    class C             //友元类定义,为了访问类A中的成员
    {
    public:
        void set_show(int x, A &a) { a.data = x; cout<<a.data<<endl;}
    };
     
    int main(void)
    {
        class A a;
        class C c;
     
        c.set_show(1, a);
     
        return 0;
    }
    

     

    展开全文
  • 二、友元函数友元函数作用域外定义,但它需要在体中进行说明为了与该成员函数加以区别,定义的方式是在中用关键字friend说明该函数,格式如下: friend 类型 友元函数名(参数表);友元的作用在于提高...
  • 文章目录022普通函数做类友元函数023友元024友元成员函数 022普通函数做类友元函数 #include<iostream> #include<cstdlib> #include<string> #include<vector> using namespace std; ...

    022普通函数做类友元函数

    
    #include<iostream>
    #include<cstdlib>
    #include<string>
    #include<vector>
    using namespace std;
    
    class  Human
    {
    private:
    	int age;
    	string name;
    public:
    	//构造函数
    	Human();
    	Human(int age, string name);
    	//析构函数
    	~Human()
    	{
    		cout << "Human析构函数" << endl;
    	}
    	//友元函数
    	friend  void myFriendFunction01(const Human&temHuman) ;	//声明这个函数是Human的友元函数
    };
    
    
    //友元函数的实现
    void myFriendFunction01(const Human&temHuman)
    {
    	cout << "我是Human类的友元函数" << endl;
    	cout << temHuman.age << endl;//友元函数可以访问private成员
    	
    }
    
    
    Human::Human()
    {
    	cout << "Human默认构造函数" << endl;
    }
    
    Human::Human(int age, string name)
    {
    	this->age = age;
    	this->name = name;
    
    }
    
    
    
    int main(void)
    {
    	Human h1 = Human(12, "jisuanji");
    	myFriendFunction01(h1);
    
    	
    	system("pause");
    	return 0;
    
    }
    /*
    *(1)普通函数做类友元函数,
    *3种访问权限:public,protected,private.
    *只要让函数成为类的友元函数,就可以访问类的所有成员(包括成员函数和成员变量(public ,protected private))都可以
    *
    *	在类内部声明友元函数,使用 friend 函数声明
    *	在类外部定义友元函数
    *	1.一般要传递类成员作为函数参数,因为只有类对象才可以访问成员属性和成员函数。
    *
    *	2019年11月20日16:45:35
    *	 Sunrise于东北电力大学第二教学楼1121实验室
    */
    
    
    
    
    

    023友元类

    
    #include<iostream>
    #include<cstdlib>
    #include<string>
    #include<vector>
    using namespace std;
    
    class A
    {
    private:
    	int number;
    public:
    	//构造函数
    	A(int number)
    	{
    		this->number = number;
    	}
    	friend class  B;	//这里还没有定义类B,但是没报错,如果有的编译器报错,可以在前面加一个类声明 class B;
    	
    };
    
    class B
    {
    private:
    	int number02=0;
    public:
    	
    	void myFunction01(const A&temA);
    };
    
    
    
    void B::myFunction01(const A&temA)
    {
    	cout << "可以访问类A的私有成员" << endl;
    	cout << temA.number << endl;
    	
    }
    
    
    int main(void)
    {
    	A a(12);
    	B b;
    	b.myFunction01(a);
    
    
    	system("pause");
    	return 0;
    
    }
    /*
    *(1)友元类
    *	声明一个类B是类A的友元类(在类A里面声明friend class B;),
    *		则类B的成员函数可以访问类A的所有成员函数和成员属性
    *
    *	1.每个类都负责控制自己的友元函数和友元函数。(自己类的友元函数,友元函数在自己类声明)
    *	2.友元关系不能被继承
    *	3.友元关系是单向的。类A是类B的友元类,但是类B是类A的友元类
    *	4.友元关系没有传递性。A-->B-->C
    *	
    *
    *2019年11月20日16:52:37
    * Sunrise于东北电力大学第二教学楼1121实验室
    
    */
    
    
    
    
    

    024友元成员函数

    
    #include<iostream>
    #include<cstdlib>
    #include<string>
    #include<vector>
    class A;
    
    //class C;	//因为不仅仅用到了C的类声明,而且包含了里面的函数。甩下面的形式
    class C
    {
    private:
    	int number03;
    public:
    	void myFunctionC(int x, A&a);
    
    public:
    };
    
    using namespace std;
    
    
    class A
    {
    	friend class  B;	//这里还没有定义类B,但是没报错,如果有的编译器报错,可以在前面加一个类声明 class B;
    
    	friend void C::myFunctionC(int x, A& a);
    private:
    	int number;
    public:
    	//构造函数
    	A(int number)
    	{
    		this->number = number;
    	}
    	
    };
    
    class B
    {
    private:
    	int number02 = 0;
    public:
    
    	void myFunction01(const A&temA);
    };
    
    
    
    
    
    void C::myFunctionC(int x, A& a)
    {
    	a.number = x;
    	cout << a.number << endl;
    	
    }
    
    
    
    void B::myFunction01(const A&temA)
    {
    	cout << "可以访问类A的私有成员" << endl;
    	cout << temA.number << endl;
    
    }
    
    
    int main(void)
    {
    	A a(12);
    	C c;
    	c.myFunctionC(1, a);
    
    
    	system("pause");
    	return 0;
    
    }
    /*
    *(1)友元成员函数--有的时候不需要让类中的所有成员函数都去访问另一个类的成员函数和成员变量。而只需要一个成员函数去访问
    *
    *总结:
    *	(1)friend允许在特定情况下访问类的成员属性和成员函数。
    *	(2)破坏了类的封装性,降低了类的可靠性与可维护性。
    *	(3)要看具体的情况使用友元函数和友元类。
    *
    *
    *2019年11月20日16:52:37
    * Sunrise于东北电力大学第二教学楼1121实验室
    
    */
    
    
    
    
    
    展开全文
  • 有些情况下,允许特定的非成员函数访问一个的私有成员,同时仍阻止一般的访问,这是很方便做到的。例如被重载的操作符,如输入或输出操作符,经常需要访问的私有数据成员。 友元(frend)机制允许一个将对其非...
  • xxx xxxxx 目 录 页 C++语言程序设计 绪 论 大连理工大学出版社 地址大连市软件园路80号 E-mail : dutp@ URLhttp://www.dutp,cn 友元函数和友元 友元函数和友元 具有封装性和隐藏性只有成员函数才能访问该...
  • C++ friend 友元函数,友元,友元成员函数看这里友元函数友元友元成员函数 友元函数 友元函数:是个函数。 三种访问权限:public,protected,private。 把函数成为友元函数,函数就能访问的所有成员...
  • 写的很好的c++PPT
  • 在一个中,可以利用关键字friend将其他的函数或声明为友元,如果友元是一般函数或者成员函数,称为友元函数,如果友元是一个,则成为友元,友元的所有成员函数都自动成为友元函数友元函数友元...
  • 友元既可以是独立的一个非成员函数,也可以是其他中的成员函数,还可以一个独立的其他。 一.非成员函数作为友元函数。 使用友元函数将百分制学生的成绩转换成相应的分数等级。 #include<iostream> using ...
  •  一个的私有数据成员通常只能由函数成员来访问,而友元函数可以访问的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载操作符和生成迭代...
  • 友元函数】: 友元函数是指某些虽然不是类成员函数却能够访问的所有成员的函数。授予它的友元特别的访问权,这样该友元函数就能访问到中的所有成员。 如果要声明函数为一个的友元,需要在定义中该函数...
  • 私有成员只能在成员函数内部访问,如果想在别处访问对象的私有成员,只能通过提供的接口(成员函数)间接地进行。这固然能够带来数据隐藏的好处,利于将来程序的扩充,但也会增加程序书写的麻烦。
  • 友元函数和友元的需要:具有封装和信息隐藏的特性。只有成员函数才能访问的私有成员,程序中的其他函数是无法访问私有成员的。非成员函数可以访问中的公有成员,但是如果将数据成员都定义为公有的,这又...
  • 有些情况下,允许特定的非成员函数访问一个的私有成员,同时仍阻止一般的访问,这是很方便做到的。例如被重载的操作符,如输入或输出操作符,经常需要访问的私有数据成员。 友元(frend)机制允许一个将对其非...
  • 友元函数 :既可以是不属于任何的非成员函数,也可以是另一个成员函数,统称为友元函数友元函数不是当前成员函数,而是独立于的外部函数,但它可以访问该所有的成员,包括私有成员、保护成员和公有...
  • C++----类成员函数友元函数

    千次阅读 2018-12-13 21:21:40
    //成员函数友元函数: //只让visit1做building的好朋友(只有visit1能访问building的私有属性) class Building; class goodGay { public: goodGay(); void visit1(); void visit2(); private: Building * ...
  •  一个的私有数据成员通常只能由函数成员来访问,而友元函数可以访问的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载操作符和生成...
  • 友元函数和友元

    2021-05-26 22:40:49
    1.友元函数可访问的私有和保护成员,但不是成员函数 2.友元函数不能用const修饰 3.友元函数可以在定义的任何地方声明,不受访问限定符限制 4.一个函数可以是多个友元函数的定义中用friend声明了...
  • 声明中,使用 friend 关键字和非成员函数名称或其他,以允许其访问你的的专用和受保护成员。 语法 friend class-name; friend function-declarator; 友元声明 如果声明以前未声明的友元函数,则该函数将...
  • 如果在某个的定义中用friend声明了一个外部函数(或者是其他成员函数,既可以是public型,也可以是private型)后,这个外部函数称为友元函数。 C++提供一种允许外部和函数存取的私有成员和保护成员的...
  • C++一个成员函数作为另一个友元函数

    千次阅读 多人点赞 2019-04-27 18:17:07
    分别用全局函数、友元函数计算两者的和。 #include<iostream> using namespace std; class B; class A; // 此行可不加,这里加此行是因为下面举例子有用 class A { public: A(int n = 0): num...
  • 一、友元函数介绍  一般情况下,非类成员函数是不能访问成员变量的。但是有时候我们为了提高程序运行效率,希望外部函数能直接...友元函数作用域外定义,但它需要在体中进行说明,为了与该成员函数加以区
  • c++友元函数和友元详解

    千次阅读 2017-07-16 19:51:19
    这些私有的数据成员只能由类成员函数所访问,外函数不能访问;当在某些情况下,我们可能又需要访问对象的私有成员,那我们应该怎么办呢?为了能够访问私有成员,我们可以采用友元函数,在c++中以关键字friend...
  • 有些情况下,允许特定的非成员函数访问一个的私有成员,同时仍阻止一般的访问,这是很方便做到的。例如被重载的操作符,如输入或输出操作符,经常需要访问的私有数据成员。 友元(frend)机制允许一个将对其...
  • 现在先说说赋值运算符“=”的重载C++规定赋值运算符“=”只能重载为的非静态成员函数,而不可以重载为友元函数。不能重载为的静态成员应该比较容易理解,因为静态成员函数是属于整个的,不是属于某个对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,891
精华内容 15,556
关键字:

友元函数一定是类的成员函数