精华内容
下载资源
问答
  • 友元函数 友元类 友元成员函数

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

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

    千次阅读 2018-03-21 21:10:40
    C++中的友元函数:功能:可以直接访问类的私有成员...下面是访问私有成员的两方法,分别是编写的成员函数以及友元函数//成员函数访问类的私有成员#include&lt;iostream&gt; using namespace std; class In...

    C++中的 友元函数:
    功能:可以直接访问类的私有成员,同样成员函数也可以访问,而普通非成员函数不可以。并且友元函数不受类的控制,无论是放到public,protected或者private中,都是一样的。

    下面是访问私有成员的两种方法,分别是编写的成员函数以及友元函数
    //成员函数访问类的私有成员

    #include<iostream>
    using namespace std;
    class Int;
    class Int
    {
    public:
    	Int(int i = 0) : m_i(i)
    	{
    	}
    	int GETI()//创建一个成员函数返回类的私有成员
    	{
    		return  m_i;
    	}
    private:
    	int m_i;
    };
    void main()
    {
    	Int a(6);
    	cout<<a.GETI()<<endl;//调用成员函数访问私有成员
    }


    //友元函数访问私有成员
    #include<iostream>
    using namespace std;
    class Int;
    class Int
    {
    	friend void show(Int &);//友元函数
    public:
    	Int(int i = 0) : m_i(i)
    	{
    	}
    private:
    	int m_i;
    };
    void show(Int &i)//友元函数的实现
    {
    	cout<<i.m_i<<endl;
    }
    void main()
    {
    	Int a(6);
    	show(a);//调动友元函数访问私有成员
    }

    展开全文
  • 文章目录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实验室
    
    */
    
    
    
    
    
    展开全文
  • 个类中,可以利用关键字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 &形参,之后按照友元函数操作一样,可以直接就实现了友元类的操作。 

    展开全文
  • 搬运自:... ... 友元包括友元函数、友元类 友元函数: 个人理解为在类中声明的可以外部访问类的内部成员变量的个函数,这个函数并不是类的成员函数,只是在类中声明,而定义在类外。换...
  • 例如声明友元函数,有两情况: ①该函数是普通的全局函数 一般情况下,使用个函数需要先声明,或者定义在前,但是声明个全局函数为友元函数的时候,可以理解为只是声明,而非调用,因此不用先在类的前面...
  • C++ friend 友元函数,友元类,友元成员函数看这里友元函数友元类友元成员函数 友元函数 友元函数:是个函数。 三访问权限:public,protected,private。 把函数成为类的友元函数,函数就能访问类的所有成员...
  • 友元是一种允许非类成员函数访问类的非公有成员的一种机制。可以把一个函数指定为类的友元,也可以把整个类指定为另一个类的友元。 友元函数友元类 二、友元函数友元函数在类作用域外定义,但它需要在类体中进行说明...
  • 友元函数一种说明在类定义体内的非成员函数。说明友元函数的方法如下: friend 返回值类型 函数名(参数表) 说明: 友元函数是在类中说明的一个函数,不是该类的成员函数,但允许访问该类的所有成员。它是独立于...
  • 友元函数】: 友元函数是指某些虽然不是类成员函数却能够访问类的所有成员的函数。类授予它的友元特别的访问权,这样该友元函数就能访问到类中的所有成员。 如果要声明函数为个类的友元,需要在类定义中该函数...
  • C++——友元函数&内联函数

    千次阅读 多人点赞 2018-12-07 23:55:15
    尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是个函数,该函数被称为友元函数;友元也可以是个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元。 如果要...
  • 友元函数 :既可以是不属于任何类的非成员函数,也可以是另个类的成员函数,统称为友元函数友元函数不是当前类的成员函数,而是独立于类的外部函数,但它可以访问该类所有的成员,包括私有成员、保护成员和公有...
  • 运算符重载 对于面向对象的程序设计来说,运算符重载可以完成两个对象之间的复杂操作...为了重载运算符,首先要定义运算符重载函数,它通常是类的非静态成员函数或者友元函数,运算符的操作数通常也应为对象。 定...
  •  个类的私有数据成员通常只能由类的函数成员来访问,而友元函数可以访问类的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载操作符和生成迭代...
  • c++(友元函数,静态成员

    千次阅读 2018-06-15 08:59:35
    友元函数并不是类中的个成员(1)注意:a、友元函数可访问类的私有成员,但不是类的成员函数b、友元函数不能用const修饰c、友元函数可以在类定义的任何地方声明(除了在函数体内),不受类访问限定符限制(不是类...
  • 静态函数毫无疑问具有类作用域,而友元函数本身可能是全局函数、也可能是其他类的成员函数,所以我猜测是不是可以理解为静态函数是友元函数一种特例。 接下来,我想验证友元函数是否也可以具有类作用域,所以我...
  • 在C++中,类与C语言中的结构体类似,类与结构体的不同之处便是在其内部多了几个成员函数还有几个访问限定符,访问限定符有public(公共)、protected(保护)、private(私有),而成员函数总的来说共包括六大类,...
  • 在这种情况下,C++提供了另外一种形式的访问权限:友元,友元有3种: 友元函数、友元类、友元成员函数。 通过让函数成为类的友元(即:友元函数),可以赋予该函数与类的成员函数相同的访问权限。在介绍如何成为...
  • 成员友元函数重载运算符

    千次阅读 2020-06-14 17:33:25
    运算符重载为类的成员函数或类的友元函数 1.区别: 成员函数具有this 指针,友元函数没有this指针 2.联系:不管是成员函数还是友元函数重载,运算符的: 使用方法相同。 传递参数的方式不同,实现代码不同,应用场合...
  • 私有成员对于类外部的所有程序部分而言都是隐藏的,访问它们需要调用个公共成员函数,但有时也可能会需要创建该规则的项例外。 友元函数个不属于类成员的函数,但它可以访问该类的私有成员。换句话说,...
  • C++之中的友元函数的作用

    万次阅读 多人点赞 2017-12-09 17:23:22
    通过友元个不同函数或另个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了个小孔,外界可以通过这个小孔窥视内部的秘密。友元的正确使用能提高程序的运行效率,...
  • 友元函数 :既可以是不属于任何类的非成员函数,也可以是另个类的成员函数,统称为友元函数友元函数不是当前类的成员函数,而是独立于类的外部函数,但它可以访问该类所有的成员,包括私有成员、保护成员和公有...
  • 尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是个函数,该函数被称为友元函数;友元也可以是个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元。 如果要...
  • 友元一种定义在类外部的普通函数,但它需要在类体内进行说明,为了与该类的成员函数加以区别,在说明时前面加以关键字friend。友元不是成员函数,但是它可以访问类中的私有成员。友元的作用在于提高程序的运行效
  • 1.友元函数一种定义在类的外部的普通函数或类,但需要在类体内进行说明;成员函数是在一个类里面所定义的函数。2.友元函数成员函数一样可以访问类中的私有成员的非成员函数,会破坏了类的封装性和隐藏性。3.友元...
  • 转自:http://blog.chinaunix.net/uid-10673338-id-2936852.html 转自:...   对以上两篇文章,我添加了自己已有的部分知识,并重新地汇总整理 ... ...从函数定义的位置来粗略理解
  • 在该例中运算符重载函数operator+作为Complex类中的成员函数。 可能有的读者会提出这样的问题:”+“是双目运算符,为什么在例10.2程序中的重载函数中只有个参数呢?实际上,运算符重载函数有两个参数,由于重载函...
  • 友元 一般来说,类的公有成员能够在类外访问,私有的成员只能被类的其他成员函数...C++提供一种允许外部类和函数存取类的私有成员和保护成员的辅助方法,即将它们声明为一个给定类的友元(或友元函数),使其具有类成

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,031
精华内容 9,212
关键字:

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