C++ 友元类
友元类的基本概念
在C++面向对象编程中，封装是一个核心概念，它通常通过访问控制符（public、protected、private）来实现。然而，有时我们需要让特定的类或函数访问另一个类的私有成员，这就是友元（Friend）机制存在的意义。
友元类是指被授予访问另一个类的非公有（private和protected）成员的权限的类。简单来说，如果类A将类B声明为其友元，那么类B的成员函数就可以访问类A的所有成员（包括私有成员）。
友元关系不是相互的：如果类B是类A的友元，并不意味着类A自动成为类B的友元。
友元关系也不能被继承：如果类C继承自类B，而类B是类A的友元，类C并不自动成为类A的友元。
友元类的语法
在C++中，要将一个类声明为另一个类的友元，需要在被访问类中使用friend关键字声明。语法如下：
class ClassA {
private:
int privateData;
public:
ClassA() : privateData(10) {}
// 声明ClassB为友元类
friend class ClassB;
};
class ClassB {
public:
void accessPrivateData(ClassA& a) {
// 由于ClassB是ClassA的友元，可以访问ClassA的私有成员
cout << "ClassA's privateData: " << a.privateData << endl;
}
};
友元类的工作原理
让我们通过一个完整的示例来理解友元类是如何工作的：
#include <iostream>
using namespace std;
class BankAccount {
private:
double balance;
string accountNumber;
public:
BankAccount(string accNum, double initialBalance) :
accountNumber(accNum), balance(initialBalance) {}
// 声明AuditSystem为友元类
friend class AuditSystem;
void deposit(double amount) {
balance += amount;
cout << "Deposited: $" << amount << endl;
}
void displayPublicInfo() {
cout << "Account: " << accountNumber << endl;
cout << "Current Balance: $" << balance << endl;
}
};
class AuditSystem {
public:
void auditAccount(BankAccount& account) {
// 作为友元类，可以访问BankAccount的私有成员
cout << "\n--- AUDIT REPORT ---" << endl;
cout << "Account Number: " << account.accountNumber << endl;
cout << "Balance: $" << account.balance << endl;
// 执行审计逻辑
if (account.balance < 0) {
cout << "WARNING: Negative Balance Detected!" << endl;
}
cout << "-------------------\n" << endl;
}
};
int main() {
BankAccount myAccount("AC123456789", 1000.0);
myAccount.displayPublicInfo();
myAccount.deposit(500.0);
myAccount.displayPublicInfo();
// 进行账户审计
AuditSystem auditor;
auditor.auditAccount(myAccount);
return 0;
}
输出结果：
Account: AC123456789
Current Balance: $1000
Deposited: $500
Account: AC123456789
Current Balance: $1500
--- AUDIT REPORT ---
Account Number: AC123456789
Balance: $1500
-------------------
在这个例子中，AuditSystem类被声明为BankAccount类的友元，因此它可以访问BankAccount对象的私有成员（如balance和accountNumber）。这种设计允许审计系统查看账户的详细信息，而不需要通过公共接口来访问。
友元类的实际应用场景
1. 设计模式中的应用
友元类在一些设计模式中非常有用，特别是在需要紧密协作的类之间：
#include <iostream>
using namespace std;
// 前向声明
class Subject;
// 观察者类
class Observer {
public:
void update(Subject* subject);
};
// 被观察的主体类
class Subject {
private:
int state;
Observer* observer;
public:
Subject() : state(0), observer(nullptr) {}
void setObserver(Observer* o) {
observer = o;
}
void setState(int s) {
state = s;
notifyObserver();
}
int getState() const {
return state;
}
private:
void notifyObserver() {
if (observer != nullptr) {
observer->update(this);
}
}
// 将Observer类声明为友元，使其能访问私有成员
friend class Observer;
};
void Observer::update(Subject* subject) {
// 由于Observer是Subject的友元，可以直接访问state
cout << "State changed to: " << subject->state << endl;
}
int main() {
Subject subject;
Observer observer;
subject.setObserver(&observer);
subject.setState(5); // 输出: "State changed to: 5"
return 0;
}
2. 迭代器实现
友元类经常用于容器与迭代器的实现中，迭代器需要访问容器的内部结构：
#include <iostream>
using namespace std;
// 简单的自定义链表实现
template<typename T>
class SimpleList {
private:
struct Node {
T data;
Node* next;
Node(const T& value) : data(value), next(nullptr) {}
};
Node* head;
public:
SimpleList() : head(nullptr) {}
void add(const T& value) {
Node* newNode = new Node(value);
if (!head) {
head = newNode;
} else {
Node* current = head;
while (current->next) {
current = current->next;
}
current->next = newNode;
}
}
// 声明迭代器类为友元
friend class Iterator;
// 迭代器类定义
class Iterator {
private:
Node* current;
public:
Iterator(Node* start) : current(start) {}
T& operator*() {
return current->data;
}
Iterator& operator++() {
if (current) {
current = current->next;
}
return *this;
}
bool operator!=(const Iterator& other) const {
return current != other.current;
}
};
Iterator begin() {
return Iterator(head);
}
Iterator end() {
return Iterator(nullptr);
}
~SimpleList() {
while (head) {
Node* temp = head;
head = head->next;
delete temp;
}
}
};
int main() {
SimpleList<int> myList;
myList.add(10);
myList.add(20);
myList.add(30);
// 使用迭代器遍历链表
cout << "List elements: ";
for (auto it = myList.begin(); it != myList.end(); ++it) {
cout << *it << " ";
}
cout << endl;
return 0;
}
输出结果：
List elements: 10 20 30
在这个例子中，Iterator类被声明为SimpleList类的友元，因此它可以访问SimpleList的私有成员结构，特别是链表节点。
友元类的优缺点
优点
- 提高灵活性：允许特定类访问另一个类的私有成员，使得某些特殊场景的实现更加简洁
- 增强合作：使紧密协作的类能够高效地共享信息
- 提升性能：某些情况下，可以避免通过公共接口访问数据的开销
缺点
- 破坏封装：友元机制本质上是对类封装的一种"特许破坏"
- 增加耦合：使类之间产生强耦合，可能增加代码维护难度
- 降低可扩展性：友元关系不能被继承，可能限制代码的灵活扩展
过度使用友元会导致代码难以维护和理解。友元应该作为特殊情况处理，而不是常规设计手段。
友元类与友元函数的区别
友元类使整个类的所有成员函数都成为友元，而友元函数只授予特定函数 访问权限：
class Example {
private:
int privateData;
public:
Example() : privateData(100) {}
// 声明一个友元函数
friend void displayData(const Example& obj);
// 声明一个友元类
friend class Inspector;
};
// 友元函数实现
void displayData(const Example& obj) {
cout << "Private data: " << obj.privateData << endl;
}
// 友元类实现
class Inspector {
public:
void inspect(const Example& obj) {
cout << "Inspecting private data: " << obj.privateData << endl;
}
};
友元类的最佳实践
- 谨慎使用：只在确实需要时才使用友元关系
- 最小化授权：如果只需要一两个函数访问，使用友元函数而不是友元类
- 明确文档：在代码中明确注释说明为什么需要建立友元关系
- 封装文件：将相互友元的类放在同一个头文件中，便于维护
- 考虑替代方案：在使用友元前，考虑是否可以通过改变设计来避免使用友元
总结
友元类是C++面向对象编程中一个特殊但有用的特性，它允许一个类访问另一个类的私有成员。虽然友元关系在某种程度上违背了封装原则，但在特定场景下，如迭代器、观察者模式等实现中，友元类提供了简洁高效的解决方案。
作为一名初学者，理解友元机制对于全面掌握C++的面向对象编程非常重要，但同样重要的是知道何时使用它们以及何时避免使用它们。友元应被视为一种特殊工具，在确实必要时才拿出来使用。
练习题
-
创建一个
Rectangle类和一个RectangleCalculator友元类，后者能够访问Rectangle的私有长度和宽度属性计算面积和周长。 -
实现一个简单的
Stack类和一个StackDebugger友元类，后者可以访问栈的内部状态进行调试。 -
创建两个类
Engine和Car，将Car设为Engine的友元，实现Car可以访问并控制Engine的内部状态。 -
思考题：在什么情况下，使用友元类比使用公共接口方法更合适？在什么情况下应该避免使用友元？
当你尝试解决这些练习时，始终问自己："这种情况下使用友元是否必要？是否有其他更好的设计方式？"这将帮助你培养良好的面向对象设计习惯。