友元

友元的两种使用形式

友元函数和友元类。

友元函数

• 使用全局函数作为友元函数
  假如已经设计好计算机类和计算机服务类，现在需要多计算机处理器进行升级，此时可以使用全局函数的友元形式实现。
  代码示例：

Computer.h

#pragma once
#include <string>

class Computer
{
public:
	Computer();

	// 声明外部全局函数作为友元函数
	friend void upgrade(Computer* computer);

	std::string description();

private:
	std::string cpu; //CPU芯片
};

声明全局函数作为友元函数的位置，在类内部public和private下都可以。
Computer.cpp

#include "Computer.h"
#include <sstream>	

Computer::Computer()
{
	cpu = "i7";
}

std::string Computer::description()
{
	std::stringstream  ret;
	ret << "CPU:" << cpu;
	return ret.str();
}

main.cpp

#include <stdio.h>
#include <iostream>
#include <Windows.h>

#include "Computer.h"

void upgrade(Computer* computer) {
	computer->cpu = "i9";  //直接访问对象的私有数据成员！！！，如果不是类的友元函数，则不可以直接访问
}

int main(void) {
	Computer sanxing;
	std::cout << sanxing.description() << std::endl;
	
	upgrade(&sanxing);
    std::cout << "升级后！！！" << std::endl;
	std::cout << sanxing.description() << std::endl;

	system("pause");
	return 0;
}

执行后结果：

• 使用类的成员函数作为友元函数
  示例代码：
  Computer.h

#pragma once
#include <string>
// class ComputerService;
// 仅仅声明ComputerService不够，需要包含头文件
#include "ComputerService.h"

class Computer
{
public:
	Computer();

	// 使用全局函数作为友元函数
	friend void upgrade(Computer* computer);
	// 使用类的成员函数，作为友元函数
	friend void ComputerService::upgrade(Computer* comptuer);
	std::string description();
private:
	std::string cpu; //CPU芯片
};

Computer.cpp

#include "Computer.h"
#include <sstream>	

Computer::Computer()
{
	cpu = "i7";
}

std::string Computer::description()
{
	std::stringstream  ret;
	ret << "CPU:" << cpu;
	return ret.str();
}

ComputerService.h

#pragma once
class Computer;

class ComputerService
{
public:
	void upgrade(Computer* computer);
};

ComputerService.cpp

#include "ComputerService.h"
#include "Computer.h"

void ComputerService::upgrade(Computer* computer) {
	computer->cpu = "i9"; //作为Computer类的友元，因此可以直接访问cpu私有变量
}

main.cpp

#include <stdio.h>
#include <iostream>
#include <Windows.h>

#include "Computer.h"

void upgrade(Computer* computer) {
	computer->cpu = "i9";  //直接访问对象的私有数据成员！！！
}

int main(void) {
	Computer shanxing;
	ComputerService service;

	std::cout << shanxing.description() << std::endl;

	//upgrade(&shanxing);
	service.upgrade(&shanxing);
	std::cout << "升级后结果：" << std::endl;
	std::cout << shanxing.description() << std::endl;

	system("pause");
	return 0;
}

执行结果：

功能上，这两种形式，都是相同，应用场合不同。
一个是，使用普通的全局函数，作为自己的朋友，实现特殊功能。
一个是，使用其他类的成员函数，作为自己的朋友，实现特殊功能。

友元类

友元类的作用：
如果把A类作为B类的友元类，
那么A类的所有成员函数【在A类的成员函数内】，就可以直接访问【使用】B类的私有成员。即，友元类可以直接访问对应类的所有成员！！！
示例代码：
Computer.h

#pragma once
#include <string>

class ComputerService;

class Computer
{
public:
	Computer();
	std::string description();

private:
	std::string cpu; //CPU芯片

	// 友元类
	friend class ComputerService;
};

Computer.cpp

#include "Computer.h"
#include <sstream>	

Computer::Computer()
{
	cpu = "i7";
}

std::string Computer::description()
{
	std::stringstream  ret;
	ret << "CPU:" << cpu;
	return ret.str();
}

ComputerService.h

#pragma once
class Computer;
class ComputerService
{
public:
	void upgrade(Computer* computer);
	void clean(Computer* computer); //计算机清理
	void kill(Computer* computer);  //杀毒
};

ComputerService.cpp

#include "ComputerService.h"
#include "Computer.h"
#include <iostream>

void ComputerService::upgrade(Computer* computer) {
    //因为是ComputerService类是Computer类的友元类，所以可以直接访问私有变量cpu
	computer->cpu = "i9";
}

void ComputerService::clean(Computer* computer)
{
    //因为是ComputerService类是Computer类的友元类，所以可以直接访问私有变量cpu
	std::cout << "正在对电脑执行清理[CPU:" 
			  << computer->cpu << "]..." 
			  << std::endl;
}

void ComputerService::kill(Computer* computer)
{
    //因为是ComputerService类是Computer类的友元类，所以可以直接访问私有变量cpu
	std::cout << "正在对电脑执行杀毒[CPU:"
		<< computer->cpu << "]..."
		<< std::endl;
}

main.cpp

#include <stdio.h>
#include <iostream>
#include <Windows.h>

#include "Computer.h"

int main(void) {
	Computer shanxing;
	ComputerService service;

	std::cout << shanxing.description() << std::endl;

	//upgrade(&shanxing);
	service.upgrade(&shanxing);
	std::cout << "升级后结果：" << std::endl;
	service.clean(&shanxing);
	service.kill(&shanxing);

	std::cout << shanxing.description() << std::endl;

	system("pause");
	return 0;
}

执行结果：

使用注意

友元类，和友元函数，使用friend关键字进行声明即可，与访问权限无关，所以，可以放在private/pulic/protected任意区域内。