万物可运算——运算符重载（一）

友元

友元的两种使用形式
1.友元函数       2.友元类
  
  
友元函数：
①使用全局函数作为友元函数

Computer.h

#pragma once
#include <string>

class Computer
{
public:
	Computer();

	// 使用全局函数作为友元函数
	friend void upgrade(Computer* computer);

	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();
}

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;
	std::cout << shanxing.description() << std::endl;
	
	upgrade(&shanxing);

	std::cout << shanxing.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";
}

main.cpp

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

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

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

	std::cout << shanxing.description() << std::endl;
	
	service.upgrade(&shanxing);

	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) {
	computer->cpu = "i9";
}

void ComputerService::clean(Computer* computer)
{
	std::cout << "正在对电脑执行清理[CPU:" 
			  << computer->cpu << "]..." 
			  << std::endl;
}

void ComputerService::kill(Computer* computer)
{
	std::cout << "正在对电脑执行杀毒[CPU:"
		<< computer->cpu << "]..."
		<< std::endl;
}

main.cpp

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

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

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

	std::cout << shanxing.description() << std::endl;
	 
	service.upgrade(&shanxing);
	service.clean(&shanxing);
	service.kill(&shanxing);

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

	system("pause");
	return 0;
}

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