精华内容
参与话题
问答
  • C++ 友元函数

    万次阅读 2020-07-25 09:22:23
    在程序里,有些私有属性也想让类外特殊的一些函数或者类进行访问, 就需要用到友元的技术 友元的目的就是让一个函数或者类访问另-个类中私有成员 友元的关键字为friend I 友元的三种实现 ●全局函数做友元 ●类做...

    生活中你的家有客厅(Public),有你的卧室(Private)
    客厅所有来的客人都可以进去,但是你的卧室是私有的,也就是说只有你能进去
    但是呢,你也可以允许你的好闺蜜好基友进去。
    在程序里,有些私有属性也想让类外特殊的一些函数或者类进行访问, 就需要用到友元的技术
    友元的目的就是让一个函数或者类访问另-个类中私有成员
    友元的关键字为friend I
    友元的三种实现
    ●全局函数做友元
    ●类做友元
    ●成员函数做友元

    我们先用第一种实现友元函数全局函数做友元:

    #include<iostream>
    #include<string>
    using namespace std;
    
    
    
    class Building{
    	//告诉编译器goodGay全局函数是Building类的好朋友,可以访问类中的私有内容
    	friend void goodGay(Building * building);
    public:
    	Building() {
    
    		this->m_SittingRoom = "客厅";
    		this->m_BedRoom = "卧室";
    	}
    public:
    	string m_SittingRoom; //客厅
    private:
    	string m_BedRoom; //卧室
    };
    void goodGay(Building * building) {
    	cout << "好基友正在访问:" << building->m_SittingRoom << endl;
    	cout << "好基友正在访问: "<< building->m_BedRoom << endl;
    }
    
    
    void test01(){
    	Building b;
    	goodGay(&b);
    }
    int main() {
    	test01();
    	system("pause");
    }

    类做友元:

    #include<iostream>
    #include<string>
    using namespace std;
    
    
    
    class Building;
    class goodGay{
    	public:
    		goodGay();
    		void visit();
    	private:
    	
    		Building * building;
    };
    class Building{
    	//告诉编译器goodGay类是Building美的好朋友,可以访问到Building类中私有内容
    	friend class goodGay;
    	public:
    		Building();
    	public:
    		string m_SittingRoom; //客厅
    	private:
    		string m_BedRoom;//卧室
    
    };
    
    
    Building::Building() {
    	this->m_SittingRoom = "客厅";
    	this->m_BedRoom = "卧室";
    }
    goodGay::goodGay() {
    	building = new Building;
    
    }
    void goodGay :: visit(){
    			 cout << "好基友正在访问"<< building->m_SittingRoom << endl;
    			 cout << "好基友正在访问"<< building->m_BedRoom << endl;
    }
    
    
    void test01() {
    	goodGay gg;
    	gg.visit();
    }
    
    int main() {
    	test01();
    	system("pause");
    }

    成员函数做友元:

    #include<iostream>
    #include<string>
    using namespace std;
    
    
    
    class Building {
    	//告诉编译器goodGay全 局函数是Building类的好朋友,可以访问类中的私有内容
    	friend void goodGay(Building * building);
    	public:
    		Building(){
    			this->m_SittingRoom = "客厅";
    			this->m_BedRoom = "卧室";
    		}
    
    	public:
    		string m_SittingRoom; //客厅
    	private:
    		string m_BedRoom; //卧室
    
    
    };
    
    void goodGay(Building * building) {
    	cout << "好基友正在访问:" << building-> m_SittingRoom << endl;
    	cout << "好基友正在访问:" << building->m_BedRoom << endl;
    }
    
    
    void test01() {
    	Building b;
    	goodGay(&b);
    }
    int main() {
    	test01();
    	system("pause");
    	return 0;
    }

     

    展开全文
  • c++友元

    2020-10-15 08:58:13
    1友元函数 例如 class A1 { public: A1() { a1 = 100; a2 = 200; } int getA1() { return this->a1; } //声明一个友元函数 friend void setA1(A1 *p, int a1); //这个函数是这个类的好朋友 protected: private:...

    1友元函数
    在这里插入图片描述
    在这里插入图片描述
    例如
    class A1
    {
    public:
    A1()
    {
    a1 = 100;
    a2 = 200;
    }
    int getA1()
    {
    return this->a1;
    }
    //声明一个友元函数
    friend void setA1(A1 *p, int a1); //这个函数是这个类的好朋友

    protected:
    private:
    int a1;
    int a2;
    };

    void setA1(A1 *p, int a1)
    {
    p->a1 = a1;
    }
    void main()
    {
    A1 mya1;
    cout<<mya1.getA1()<<endl;
    setA1(&mya1, 300); //通过友元函数 修改A类的私有属性
    cout<<mya1.getA1()<<endl;
    system(“pause”);
    }
    在这里插入图片描述
    2友元类
    若B类是A类的友员类,则B类的所有成员函数都是A类的友员函数
    友员类通常设计为一种对数据操作或类之间传递消息的辅助类
    在这里插入图片描述

    展开全文
  • C++ 友元

    2020-04-24 11:28:24
    友元函数、友元全局函数、友元成员函数 友元函数: 友元函数是一个不属于类成员的函数,但它可以访问该类的私有成员。换句话说,友元函数被视为好像是该类的一个成员。友元函数可以是常规的独立函数,也可以是其他类...

    友元函数、友元全局函数、友元成员函数

    友元函数:
    友元函数是一个不属于类成员的函数,但它可以访问该类的私有成员。换句话说,友元函数被视为好像是该类的一个成员。友元函数可以是常规的独立函数,也可以是其他类的成员。整个类都可以是另一个类的友元。
    友元全局函数:
    将一个全局函数设为一个类得友元,则该全局函数可以访问该类中的私有成员。
    友元成员函数:
    将一个类中的成员函数设置为另一个类的友元,则该类中这个成员函数可以访问另一个类中的私有成员。
    一般语法格式:

    friend <return type><function name> (<parameter type list>);
    

    友元函数注意点:
    1、友元函数的声明可以放在类的私有部分,也可以放在公有部分。
    2、一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
    3、友元函数的调用与一般函数的调用方式和原理一致。
    4、友元函数中没有this指针,所以要访问非static成员时,需要对象做参数。
    5、友元成员函数的定义必须在能访问的类定义后再定义,不然无效。
    例子(友元全局函数):

    #include<iostream>
    #include"stdlib.h"
    #include"Time.h"
    using namespace std;
    
    //友元全局函数
    class Time
    {
    	friend void printTime(Time& t);
    public:
    	Time(int hour, int min, int sec)
    	{
    		m_iHour = hour;
    		m_iMinute = min;
    		m_iSecond = sec;
    	}
    private:
    	int m_iHour;
    	int m_iMinute;
    	int m_iSecond;
    };
    
    void printTime(Time& t)
    {
    	cout << "时:"<< t.m_iHour   ;
    	cout << "分:"<< t.m_iMinute ;
    	cout << "秒:"<< t.m_iSecond ;
    }
    
    
    int main()
    {
    	Time t(10, 47, 33);
    	printTime(t);
    	system("pause");
    	return 0;
    }
    

    友元成员函数

    #include<iostream>
    #include"stdlib.h"
    #include"Time.h"
    using namespace std;
    
    class Time;
    class Match
    {
    public:
    	void printTime(Time& t);               
    };
    
    class Time
    {
    public:
    	friend void Match::printTime(Time& t);   //声明Match类中的printTime为友元成员函数
    	Time(int hour, int min, int sec)
    	{
    		m_iHour = hour;
    		m_iMinute = min;
    		m_iSecond = sec;
    	}
    private:
    	int m_iHour;
    	int m_iMinute;
    	int m_iSecond;
    };
    
    void Match::printTime(Time& t)              //必须在Time定义后才能定义该函数。
    {
    	cout << "时:" << t.m_iHour;
    	cout << "分:" << t.m_iMinute;
    	cout << "秒:" << t.m_iSecond;
    }
    
    int main()
    {
    	Time t(10, 47, 33);
    	Match a;
    	a.printTime(t);
    	system("pause");
    	return 0;
    }
    

    友元函数:

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

    友元类

    友元类:
    友元也可以是一个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。
    语句格式如下:
    friend class 类名;
    其中:friend和class是关键字,类名必须是程序中的一个已定义过的类。
    注意点:
    1、友元关系不能被继承。
    2、友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    3、友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元。
    实例:

    #include<iostream>
    using namespace std;
    
    class Circle;
    class Coordinate
    {
    	friend Circle;
    public:
    	Coordinate(int x = 5, int y = 7) {
    		m_iX = x;
    		m_iY = y;
    	}
    private:
    	int m_iX;
    	int m_iY;
    };
    
    class Circle
    {
    public:
    	void printXY()
    	{
    		cout << m_coor.m_iX <<" "<< m_coor.m_iY;
    	}
    private:
    	Coordinate m_coor;
    };
    
    int main()
    {
    	Circle a;
    	a.printXY();
    	return 0;
    }
    
    展开全文
  • c++ 友元

    2020-02-18 16:14:56
    友元函数,通过这个函数可以直接访问类的私有成员变量 友元也可以是一个类,但是它破坏了类的封装,使得非成员函数可以访问类的私有成员 // 友元函数.cpp: 定义控制台应用程序的入口点。 // #include "stdafx.h" #...

    友元函数,通过这个函数可以直接访问类的私有成员变量
    友元也可以是一个类,但是它破坏了类的封装,使得非成员函数可以访问类的私有成员

    // 友元函数.cpp: 定义控制台应用程序的入口点。
    //
    #include "stdafx.h"
    #include<math.h>
    #include<iostream>
    
    using namespace std;
    class Point
    {
    public:
    	Point(int x, int y)
    	{
    		this->x = x;
    		this->y = y;
    	}
    	int getx()
    	{
    		return this->x;
    	}
    	int gety()
    	{
    		return this->y;
    	}
    	//声明全局函数是我Point 类的一个友元函数
    	friend double PointDistance(Point &p1, Point &p2);
    private:
    	int x;
    	int y;
    
    };
    double PointDistance(Point &p1,Point &p2)
    {
    	double dis;
    	//int d_x = p1.getx() - p2.getx();
    	//int d_y = p1.gety() - p2.gety();
    	int d_x = p1.x - p2.x;
    	int d_y = p1.y - p2.y;
    	dis = sqrt(d_x*d_x + d_y * d_y);
    	return dis;
    }
    int main()
    {
    	Point p1(1, 1);
    	Point p2(2, 2);
    	double dis=PointDistance(p1, p2);
    	cout << "距离是" << dis << endl;
        return 0;
    }
    
    
    

    在其他类中定义有元函数

    // 友元函数.cpp: 定义控制台应用程序的入口点。
    //
    #include "stdafx.h"
    #include<math.h>
    #include<iostream>
    
    using namespace std;
    class PointManager
    {
    public:
    	double PointDistance(Point &p1, Point &p2);
    };
    //谁在上都矛盾 可以用多文件
    class Point
    {
    public:
    	Point(int x, int y)
    	{
    		this->x = x;
    		this->y = y;
    	}
    	int getx()
    	{
    		return this->x;
    	}
    	int gety()
    	{
    		return this->y;
    	}
    	//声明全局函数是我Point 类的一个友元函数
    	//friend double PointDistance(Point &p1, Point &p2);
    	friend double PointManager:: PointDistance(Point &p1, Point &p2);
    private:
    	int x;
    	int y;
    
    };
    double PointManager:: PointDistance(Point &p1, Point &p2)
    {
    	double dis;
    	//int d_x = p1.getx() - p2.getx();
    	//int d_y = p1.gety() - p2.gety();
    	int d_x = p1.x - p2.x;
    	int d_y = p1.y - p2.y;
    	dis = sqrt(d_x*d_x + d_y * d_y);
    	return dis;
    }
    
    
    /*
    double PointDistance(Point &p1,Point &p2)
    {
    	double dis;
    	//int d_x = p1.getx() - p2.getx();
    	//int d_y = p1.gety() - p2.gety();
    	int d_x = p1.x - p2.x;
    	int d_y = p1.y - p2.y;
    	dis = sqrt(d_x*d_x + d_y * d_y);
    	return dis;
    }
    */
    /*
    class PointManager
    {
    public:
    	double PointDistance(Point &p1, Point &p2)
    	{
    		double dis;
    		//int d_x = p1.getx() - p2.getx();
    		//int d_y = p1.gety() - p2.gety();
    		int d_x = p1.x - p2.x;
    		int d_y = p1.y - p2.y;
    		dis = sqrt(d_x*d_x + d_y * d_y);
    		return dis;
    	}
    
    
    
    };
    */
    
    int main()
    {
    	Point p1(1, 1);
    	Point p2(2, 2);
    	//double dis=PointDistance(p1, p2);
    	//cout << "距离是" << dis << endl;
    	PointManager pm;
    
    
        return 0;
    }
    
    
    

    1.有元是单向的,不具有交换性B是A的有元,A不一定是B的友元
    2.友元关系不能被继承
    3.友元不具有传递性,B是A的友元,C是B的友元,C不一定是A的友元

    // 友元函数.cpp: 定义控制台应用程序的入口点。
    //
    #include "stdafx.h"
    #include<math.h>
    #include<iostream>
    
    using namespace std;
    class A
    {
    public:
    	//声明友元类B
    	friend class B;
    	A(int a)
    	{
    		this->a = a;
    	}
    	void printA()
    	{
    		cout << "a=" << this->a << endl;
    		
    	}
    private:
    	int a;
    
    };
    class B {
    public:
    	B(int b)
    	{
    		this->b = b;
    	}
    	void printB()
    	{
    		A objA(100);
    		cout << objA.a << endl;
    		cout << "b= " << b << endl;
    	}
    private:
    	int b;
    };
    int main()
    { 
    	B b(10);
    	b.printB();
    
        return 0;
    }
    
    
    
    展开全文

空空如也

1 2 3 4 5 ... 20
收藏数 6,985
精华内容 2,794
关键字:

c++友元

c++ 订阅