友元（C++）

目录

一.简介

二. 前言

三.友元的三种实现

1.全局函数做友元

2类做友元

3.成员函数做友元

---

一. 前言

       家有公共大堂，就是咱家的客厅，人来人往，热闹非凡，就像是个大舞台，谁都能上来露两手。卧室呢，那就是我的小天地，私密又温馨，只有我自己能进去，就像是个秘密基地，，没有我的允许谁都不能乱闯。

       不过嘛，隔壁老王这个家伙，我跟你说，他可是个例外。他就像是我的特邀嘉宾，有时候我也邀请他来我的卧室坐坐，聊聊人生，谈谈理想。毕竟，邻里之间，总得有点互动嘛！

二.简介

       在C++中，友元（friend）是一个非常有用的概念，它允许一个类访问另一个类的私有和保护成员。这通常用于当两个类需要密切合作，但又不希望公开其内部实现细节时。

      友元可以是函数（全局或成员）或者类。当一个函数被声明为另一个类的友元时，它可以访问该类的所有非公有成员。同样地，当一个类被声明为另一个类的友元时，它的所有公有成员函数可以访问该类的所有非公有成员。

三.友元的三种实现

1.全局函数做友元

       首先创立一个建筑类，里面有客厅和卧室。 m_SittingRoom权限公有，m_BedRoom权限是私有的。使用Building函数完成对 m_SittingRoom = "客厅"，m_BedRoom = "卧室"的赋值。

//建筑物
class Building
{
public:
	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";

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

       其次创建全局函数goodgay，并访问客厅和卧室。运行后发现客厅可以正常访问，而卧室不可以，因为卧室权限为私有不允许类外访问。

void goodGay(Building* building)
{
	cout << "好基友全局函数 正在访问：" << building->m_SittingRoom;

	cout << "好基友全局函数 正在访问：" << building->m_BedRoom;
}

void test01()
{
	Building building;
	goodGay(&building);
}

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

   要想成功访问卧室，需要将全局函数goodgay设置为Building类的友元类。只需要在函数声明前加friend并将它放于Building类中即可。重新运行后，发现goodgay可以访问卧室。

//goodGay全局函数作为Building的好朋友
friend void goodGay(Building* building);

//建筑物
class Building
{
	//goodGay全局函数作为Building的好朋友
	friend void goodGay(Building* building);
public:
	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";

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

     完整代码

//全局函数做友元
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string.h>
using namespace std;

//建筑物
class Building
{
	//goodGay全局函数作为Building的好朋友
	friend void goodGay(Building* building);
public:
	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";

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

//全局函数

void goodGay(Building* building)
{
	cout << "好基友全局函数 正在访问：" << building->m_SittingRoom;

	cout << "好基友全局函数 正在访问：" << building->m_BedRoom;
}

void test01()
{
	Building building;
	goodGay(&building);
}

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

    结果截图

 

2.类做友元

   创建Building类

class Building
{
	
public:
	Building();

public:
	string m_SittingRoom;//客厅

private:

	string m_BedRoom;//卧室

};

   创建GoodGay类

class GoodGay
{
public:
	GoodGay();

	void visit();//参观函数 访问Building中的属性

	Building* building;
};

   Building类和GoodGay类中的成员函数，在类外进行实现。函数名前需要加相应所属域名。 倒数第二行代码暂时不能运行，因为还未将GoodGay设为Building的友元类。

//类外成员函数
Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}

GoodGay::GoodGay()
{
	//创建建筑物对象
	building = new Building;
}

void GoodGay::visit()
{
	cout << "好基友类正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友类正在访问：" << building->m_BedRoom << endl;
}

   与全局函数做友元类似，需要在相应类前加friend并放置于Buidling类中即可。

//GoodGay类是本类的好朋友，可以访问本类私有成员
friend class GoodGay;

class Building
{
	//GoodGay类是本类的好朋友，可以访问本类私有成员
	friend class GoodGay;
public:
	Building();

public:
	string m_SittingRoom;//客厅

private:

	string m_BedRoom;//卧室

};

   完整代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string.h>
using namespace std;



class Building;
class GoodGay
{
public:
	GoodGay();

	void visit();//参观函数 访问Building中的属性

	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()
{
	//创建建筑物对象
	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();
	return 0;
}

   重新运行后结果截图

3.成员函数做友元

   创建Building和GoodGay类

class GoodGay
{
public:

	GoodGay();

	void visit();//让visit函数可以访问Building中的私有成员
	void visit2();//让visit函数不可以访问Building中的私有成员

	Building* building;

};

class Building
{
	
public:

	Building();

	string m_SittingRoom;//客厅

private:

	string m_BedRoom;//卧室
};

   类外实现各类的成员函数

Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}

GoodGay::GoodGay()
{
	building = new Building;
}

void GoodGay::visit()
{
	cout << "visit 函数正在访问：" << building->m_SittingRoom << endl;
	cout << "visit 函数正在访问：" << building->m_BedRoom << endl;
}
void GoodGay::visit2()
{
	cout << "visit2 函数正在访问：" << building->m_SittingRoom << endl;
}

    让visit成为Building的友元函数访问私有成员，visit2不可以访问私有成员。与全局函数做友元类似，区别是需要在成员函数前加域名。

//告诉编译器 GoodGay类下的visit成员函数作为本类的好朋友可以访问本类的私有成员
	friend void GoodGay::visit();

class Building
{
	//告诉编译器 GoodGay类下的visit成员函数作为本类的好朋友可以访问本类的私有成员
	friend void GoodGay::visit();
public:

	Building();

	string m_SittingRoom;//客厅

private:

	string m_BedRoom;//卧室
};

   完整代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string.h>
using namespace std;


class Building;
class GoodGay
{
public:

	GoodGay();

	void visit();//让visit函数可以访问Building中的私有成员
	void visit2();//让visit函数不可以访问Building中的私有成员

	Building* building;

};

class Building
{
	//告诉编译器 GoodGay类下的visit成员函数作为本类的好朋友可以访问本类的私有成员
	friend void GoodGay::visit();
public:

	Building();

	string m_SittingRoom;//客厅

private:

	string m_BedRoom;//卧室
};

Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}

GoodGay::GoodGay()
{
	building = new Building;
}

void GoodGay::visit()
{
	cout << "visit 函数正在访问：" << building->m_SittingRoom << endl;
	cout << "visit 函数正在访问：" << building->m_BedRoom << endl;
}
void GoodGay::visit2()
{
	cout << "visit2 函数正在访问：" << building->m_SittingRoom << endl;
}

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

   重新运行后结果截图

以上就是友元的三种实现。

看到这里，不妨点个攒，关注一下吧！

最后，谢谢你的观看