浅谈C++中的友元

设想这样一个场景，有一个类A，其中有一个m_A属性，修饰符是private，当我们想要访问这个数据的时候，除了在类中进行访问之外，还有一个办法就是在类外进行访问。实际中大多数时候都会在类外对其进行操作，但是在类外进行访问是有限制的。这个时候就通过友元这个技术来进行访问。

• 全局函数做友元
• 类做友元
• 成员函数做友元

• 全局函数做友元

#define _CRT_SECURE_NO_WARNINGS
#include 
#include
using namespace std;

//全局函数做友元
class Car {
//
friend void Friend(Car *car);
public:

	string m_brand;  //汽车品牌

	//构造函数初始化操作
	Car() {

		m_brand ="奔驰-迈巴赫";
		m_price = 1200000;
	}

private:
	int m_price;  //汽车价格
	
};

void Friend(Car *car) {

	cout << "全局函数Friend正在访问: " << "汽车品牌: "<< car->m_brand << endl;
    cout << "全局函数Friend正在访问: " << "汽车价格: " << car->m_price << endl;

}

void test() {

	Car car;
	Friend(&car);
}
int main()
{
	test();

	system("pause");
	return 0;
}

这里我们声明一个汽车类Car，其中m_brand汽车品牌是公有数据，m_price汽车价格是私有数据，当我们当我们想要访问m_brand的时候，这个很简单，直接在外面定义一个Friend函数就可以进行访问，结果如上图所示。

但是这里如果想要访问汽车的价格m_price呢？这里就要用到友元了。

具体操作如下：

还是保持全局函数Friend不变，在Friend前面加上 friend 关键字即可。
同时，将friend void Friend(Car car)复制粘贴到类Car中

这样一来，就可以在Friend函数中对Car的m_price属性进行访问了，这里进行了打印输出。

• 类做友元

#include 
#include
using namespace std;

//类做友元
class Car;
class Friend {
	
public:
	Friend();

	Car *car;
	void visit();
};

class Car {

	//Friend作为Car的好朋友，可以访问Car中的私有成员
	friend class Friend;
public:
	
	Car();
	string m_brand;

private:
	
	int m_price;
};

//初始化
Car::Car() {

	m_brand = "奔驰-迈巴赫";
	m_price = 1200000;
}

Friend::Friend() {

	//创建车对象
	car = new Car;  //在堆区创建一个对象，用car指向这个创建好的对象
}

void Friend::visit() {

	cout << "Friend类正在访问:" << "汽车品牌: " << car->m_brand << endl;

	cout << "Friend类正在访问:" << "汽车价格:" << car->m_price << endl;
}

void test() {

	Friend fri;
	fri.visit();
}
int main()
{
	test();

	system("pause");
	return 0;
}

这里还是跟上面例子相似，只不过我们采用的是 将Friend这个类作为Car类的友元，也就是Car类的好朋友，这样一来，Friend中的visit方法也就能够访问到Car中的m_price属性了。

具体操作如下：

还是保持Friend中visit函数不变，在类Friend前面加上friend关键字即可。
同时，将friend class Friend复制粘贴到类Car中

这样一来，Friend类中的visit函数就可以对Car的m_price属性进行访问了，这里进行的是打印输出。

• 成员函数做友元

#include
#include
using namespace std;

//成员函数做友元
class Car;
class Friend
{
public:

	Friend();

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

	Car *car;
};

class Car {

	//让visit1函数作为本类的好朋友，可以访问Car中的私有数据
	friend void Friend:: visit1();
public:

	Car();
	string m_brand;

private:

	int m_price;

};

//类外实现初始化
Friend::Friend() {

	car = new Car;  //在堆区创建一个Car对象，用car指向这个创建好的对象
}

Car::Car() {

	m_brand = "奔驰-迈巴赫";
	m_price = 1200000;
}

void Friend ::visit1() {

	cout << "Friend中的visit1函数正在访问:" << endl;
	cout << "汽车品牌: " << car->m_brand << endl;
	cout << "汽车价格: " << car->m_price << endl;
}

void Friend::visit2() {

	cout << "Friend中的visit2函数正在访问: " << endl;
	cout << "汽车品牌: " << car->m_brand << endl;
	//cout << "汽车价格: " << car->m_price << endl;
}

void test122() {

	Friend frie;
	frie.visit1();
	frie.visit2();
}
int main()
{
	test122();

	system("pause");
	return 0;

}

这里我们是将成员函数作为类Car的友元，也就是Car的好朋友，可以看到，将visit1函数作为类Car的友元之后，visit1函数就可以访问到Car中的m_price属性，而visit2函数由于不是Car的友元，故只能访问Car中的公共属性m_brand，结果如上图所示

具体操作如下：

在成员函数visit1前面加上friend关键字，然后将其复制粘贴放到类Car中，注意这里记得加上Friend作用域，也就是 friend void Friend::visit1()加到类Car中，让编译器知道，visit1是类Car的好朋友，这样一来就可访问Car类中的私有数据