C++-友元

一、友元

C++是面向对象的，目的之一：封装

封装：
优点之一，就是安全。
缺点：在某些特殊的场合，不是很方便。

友元使用前提：
某个类需要实现某种功能，但是这个类自身，因为各种原因，无法自己实现。
需要借助于“外力”才能实现。

1.友元函数：

①使用全局函数作为友元函数

需求：
计算机和计算机的升级

Computer.h

定义Computer类，使用全局函数upgrade作为Computer类的友元函数

#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()
{
	this->cpu = "i7";
}

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

main.cpp

定义upgrade全局函数，访问Computer类的私有数据成员

#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

定义Computer类，使用ComputerService类的upgrade函数作为Computer类的友元函数

#pragma once
#include <string>

// class ComputerService;
// 仅仅声明ComputerService不够，需要包含头文件，因为用到了其方法
#include "ComputerService.h"


class Computer
{
public:
	Computer();

	// 使用类的成员函数，作为友元函数
	friend void ComputerService::upgrade(Computer* comptuer);

	std::string description();

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

Computer.cpp

不变

ComputerService.h

定义ComputerService类，含upgrade数据成员

#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;
	
	//友元函数访问Computer类
	service.upgrade(&shanxing);

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

	system("pause");
	return 0;
}

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

2.友元类：

• 为什么要使用友元类

一个独立的咨询师， 给其他企业做服务时，这个咨询师作为企业的“友元函数”即可。

一个大型的咨询服务公司，比如IBM（IT事务）, 普华永道（会计事务），给其他企业做服务时，使用友元函数就不是很方便了，因为需要设计很多友元函数，不方便。

解决方案：使用“友元类”

• 友元类的作用

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

Computer.h
eg：
有一个Computer类，它具有一个私有成员cpu
friend class ComputerService–>声明了ComputerService类为Computer类的友元类。这意味着ComputerService类的成员函数可以访问Computer类的私有成员cpu

#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";	//ComputerService类的成员函数可以访问Computer类的私有成员cpu!
}

void ComputerService::clean(Computer* computer)
{
	std::cout << "正在对电脑执行清理[CPU:" 
			  << computer->cpu << "]..." 
			  << std::endl;//ComputerService类的成员函数可以访问Computer类的私有成员cpu!
}

void ComputerService::kill(Computer* computer)
{
	std::cout << "正在对电脑执行杀毒[CPU:"
		<< computer->cpu << "]..."
		<< std::endl;//ComputerService类的成员函数可以访问Computer类的私有成员cpu!
}

main.cpp

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

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

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

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

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

	system("pause");
	return 0;
}

3.使用注意

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

• 友元类的访问权限不会被继承。即使子类继承了父类的友元类关系，子类的友元类仍然不能访问父类的私有成员。例如：

假设我们有一个基类Base和一个派生类Derived，并且Base类中有一个友元类FriendClass，我们可以看到友元关系不会传递给Derived类：

class Base {
private:
    int privateData;

    friend class FriendClass;

public:
    Base(int data) : privateData(data) {}
};


class FriendClass {
public:
    void modifyPrivateData(Base& obj, int newData) {
        obj.privateData = newData; // 可以访问私有成员
    }
};


class Derived : public Base {
public:
    Derived(int data) : Base(data) {}
};


int main() {
    FriendClass friendObj;
    Base baseObj(42);
    Derived derivedObj(23);

    friendObj.modifyPrivateData(baseObj, 99);    // 正确，Base类的友元类可以访问私有成员
    friendObj.modifyPrivateData(derivedObj, 88); // 错误，Derived类的友元类不能访问私有成员

    return 0;
}