C++是面向对象的,目的之一:封装
封装:
优点之一,就是安全。
缺点:在某些特殊的场合,不是很方便。
友元使用前提:
某个类需要实现某种功能,但是这个类自身,因为各种原因,无法自己实现。
需要借助于“外力”才能实现。
需求:
计算机和计算机的升级
Computer.h
定义Computer类,使用全局函数upgrade作为Computer类的友元函数
#pragma once
#include
class Computer
{
public:
Computer();
// 使用全局函数作为友元函数,可以访问私有成员了
friend void upgrade(Computer* computer);
std::string description();
private:
std::string cpu; //CPU芯片
};
Computer.cpp
#include "Computer.h"
#include
Computer::Computer()
{
this->cpu = "i7";
}
std::string Computer::description()
{
std::stringstream ret;
ret << "CPU:" << cpu;
return ret.str();
}
main.cpp
定义upgrade全局函数,访问Computer类的私有数据成员
#include
#include
#include
#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
// 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
#include
#include
#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;
}
功能上,这两种形式,都是相同,应用场合不同。
一个是,使用普通的全局函数,作为自己的朋友,实现特殊功能。
一个是,使用其他类的成员函数,作为自己的朋友,实现特殊功能。
一个独立的咨询师, 给其他企业做服务时,这个咨询师作为企业的“友元函数”即可。
一个大型的咨询服务公司,比如IBM(IT事务), 普华永道(会计事务),给其他企业做服务时,使用友元函数就不是很方便了,因为需要设计很多友元函数,不方便。
解决方案:使用“友元类”
如果把A类作为B类的友元类,
那么A类的所有成员函数【在A类的成员函数内】,就可以直接访问【使用】B类的私有成员。
即,友元类可以直接访问对应类的所有成员!!!
Computer.h
eg:
有一个Computer类,它具有一个私有成员cpu
friend class ComputerService–>声明了ComputerService类为Computer类的友元类。这意味着ComputerService类的成员函数可以访问Computer类的私有成员cpu
#pragma once
#include
class ComputerService;
class Computer
{
public:
Computer();
std::string description();
private:
std::string cpu; //CPU芯片
// 友元类
friend class ComputerService;
};
Computer.cpp
#include "Computer.h"
#include
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
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
#include
#include
#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;
}
友元类,和友元函数,使用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;
}