全局函数做友元 其实就是声明一个函数可访问私有属性

[] [c++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include<bits/stdc++.h>
using namespace std;

class Building
{
	//全局函数做友元声明 goodgay可以访问building中私有成员 
	friend void goodGay(Building &building); 
public:
	string m_settingRoom;
	
private:
	string m_BedRoom;
};

//全局函数
void goodGay(Building &building)
{
	cout<<"正在访问全局变量1"<<building.m_settingRoom<<endl; 
    cout<<"正在访问全局变量2"<<building.m_BedRoom<<endl;
    //m_bedroom本来访问不了  
}
void test01() //m_settingRoom是public 随便访问 
{
	Building building;
	goodGay(building);
}


int main()
{
	test01();
	return 0;
}

类做友元 一个类能访问其它类的私有成员
以下代码有些复杂 因为用的是类外声明函数(加定义域)

大致就是
1.先声明一个Building类
2.写一个GoodGay类 里面声明了其构造函数 内部维护一个指针
3.Building类中有一个构造函数 两个属性 公有的客厅以及私有的卧室
4.类外写building的构造函数 初始化了客厅卧室
5.类外写GoodGay的构造函数
6.声明友元 可访问私有的卧室

[] [c++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include<bits/stdc++.h>
using namespace std;
class Building;
class GoodGay
{
	public:
		GoodGay();
		void visit(); //参观函数访问Building中的属性 
	private:
        Building *building;
};

class Building
{
	//声明GoodGay是本类的好朋友 可以访问 
	friend class GoodGay;
public:
    Building();//先声明 

public:
	string m_SittingRoom; //客厅
		
private:
	string m_BedRoom;//卧室 
	     
 };
 //类外写成员函数 加个作用域就行了 
Building::Building()
{
	m_SittingRoom="客厅";
	m_BedRoom="卧室"; 
	
 }
GoodGay::GoodGay()
{
	//相当于在堆区创建建筑物对象 new返回了一个指针
	building=new Building;
 }
 
void GoodGay::visit()
{
	cout<<"好基友类正在访问1"<<building->m_SittingRoom<<endl;
	cout<<"好基友类正在访问2"<<building->m_BedRoom<<endl;
}

void test01()
{
	GoodGay gg;
	gg.visit();
}
int main()
{
	test01();
	return 0;
}

成员函数做友元
其实就是把上文代码中visit函数前面加个friend 放Building类下

[] [c++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Building
{
	//声明visit函数是本类的好朋友 可以访问 
	friend void GoodGay::visit(); 
public:
    Building();

public:
	string m_SittingRoom; 
		
private:
	string m_BedRoom;//卧室    
 };

总结 等于说就是这一个操作