友元函数的访问控制
面试考点
友元机制是 C++ 中一种"有意打破封装"的设计。面试官通过这道题考察你对访问控制体系的理解,以及你是否知道友元的三条核心规则:不可传递、不可继承、不受访问说明符影响。
核心概念
friend 声明允许一个函数或类访问另一个类的 private 和 protected 成员。友元不是类的成员,它是一种单向的访问授权。
cpp
class Box {
int width_; // private
friend void print_width(const Box& b); // 授予访问权
};
// 友元函数可以访问 private 成员
void print_width(const Box& b) {
std::cout << b.width_ << std::endl;
}基本示例
cpp
#include <iostream>
#include <string>
// ============================
// 示例1:友元函数
// ============================
class Account {
std::string owner_;
double balance_;
public:
Account(const std::string& owner, double balance)
: owner_(owner), balance_(balance) {}
// 声明友元函数:可以访问 private 成员
friend void transfer(Account& from, Account& to, double amount);
void print() const {
std::cout << owner_ << ": " << balance_ << "元" << std::endl;
}
};
// 友元函数定义:不是 Account 的成员函数
void transfer(Account& from, Account& to, double amount) {
// 可以直接访问 private 成员
if (from.balance_ >= amount) {
from.balance_ -= amount;
to.balance_ += amount;
std::cout << "转账 " << amount << " 元成功" << std::endl;
}
}
void friend_function_demo() {
Account a("张三", 1000);
Account b("李四", 500);
transfer(a, b, 300);
a.print();
b.print();
}
// ============================
// 示例2:友元类
// ============================
class Engine {
int horsepower_;
int temperature_;
// 声明 Mechanic 为友元类
// Mechanic 的所有成员函数都能访问 Engine 的 private 成员
friend class Mechanic;
public:
Engine(int hp) : horsepower_(hp), temperature_(90) {}
};
class Mechanic {
public:
void diagnose(const Engine& e) {
// 可以访问 Engine 的 private 成员
std::cout << "马力: " << e.horsepower_ << std::endl;
std::cout << "温度: " << e.temperature_ << std::endl;
}
void tune(Engine& e, int new_hp) {
e.horsepower_ = new_hp; // 可以修改 private 成员
std::cout << "调整马力到 " << new_hp << std::endl;
}
};
void friend_class_demo() {
Engine e(200);
Mechanic m;
m.diagnose(e);
m.tune(e, 250);
m.diagnose(e);
}
// ============================
// 示例3:运算符重载(最常见的友元用法)
// ============================
class Vector2D {
double x_, y_;
public:
Vector2D(double x, double y) : x_(x), y_(y) {}
// 友元运算符重载:让 << 能访问 private 成员
friend std::ostream& operator<<(std::ostream& os, const Vector2D& v);
// 友元加法运算符
friend Vector2D operator+(const Vector2D& a, const Vector2D& b);
};
std::ostream& operator<<(std::ostream& os, const Vector2D& v) {
os << "(" << v.x_ << ", " << v.y_ << ")";
return os;
}
Vector2D operator+(const Vector2D& a, const Vector2D& b) {
return Vector2D(a.x_ + b.x_, a.y_ + b.y_);
}
void operator_demo() {
Vector2D v1(1.0, 2.0);
Vector2D v2(3.0, 4.0);
Vector2D v3 = v1 + v2;
std::cout << v1 << " + " << v2 << " = " << v3 << std::endl;
}
// ============================
// 示例4:友元的三条规则
// ============================
class A {
int secret_ = 42;
friend class B; // B 是 A 的友元
};
class B {
int data_ = 10;
// friend class C; // 如果取消注释,C 是 B 的友元
public:
void access_a(const A& a) {
std::cout << "B 访问 A 的 secret: " << a.secret_ << std::endl;
}
};
class C : public B {
public:
void try_access_a(const A& a) {
// std::cout << a.secret_; // 编译错误!友元不可继承
// C 继承了 B,但不继承 B 对 A 的友元关系
std::cout << "C 不能访问 A 的 private 成员" << std::endl;
}
};
// ============================
// 示例5:友元声明位置不受 access specifier 影响
// ============================
class MyClass {
private:
int x_ = 1;
// friend 声明放在 private 区域——这不影响友元关系
// friend 声明不受 public/private/protected 影响
friend void peek(const MyClass& m);
public:
int y_ = 2;
};
void peek(const MyClass& m) {
std::cout << "x_ = " << m.x_ << ", y_ = " << m.y_ << std::endl;
}
int main() {
std::cout << "=== 友元函数 ===" << std::endl;
friend_function_demo();
std::cout << "\n=== 友元类 ===" << std::endl;
friend_class_demo();
std::cout << "\n=== 运算符重载 ===" << std::endl;
operator_demo();
std::cout << "\n=== 友元访问 ===" << std::endl;
MyClass m;
peek(m);
return 0;
}友元的三条核心规则
| 规则 | 含义 | 示例 |
|---|---|---|
| 不可传递 | A 是 B 的友元,B 是 C 的友元,A 不是 C 的友元 | "朋友的朋友不是你的朋友" |
| 不可继承 | A 是 B 的友元,C 继承 A,C 不是 B 的友元 | "你朋友的孩子不是你的朋友" |
| 不受访问说明符影响 | friend 声明放在 private/public 区域效果一样 | 位置只影响代码风格 |
常见问题
友元破坏了封装吗?
从技术上看是的。但友元是一种"可控的封装破坏"——类自己决定谁可以访问它的私有成员。这和直接把成员设为 public 不同,友元是定向授权。
什么时候该用友元?
最常见的场景是运算符重载(如 operator<<、operator+),它们需要访问类的内部状态但不适合做成员函数。另外还有测试代码、紧密耦合的协作类。
友元函数和成员函数有什么区别?
友元函数不属于类,没有 this 指针,不能通过对象用点运算符调用。成员函数属于类,有隐式的 this 指针。
适用场景
- 运算符重载(
<<、>>、+、==等) - 紧密协作的类(如迭代器和容器)
- 工厂类需要访问目标类的私有构造函数
- 单元测试中访问私有成员
注意事项
- 友元是单向的(A 声明 B 为友元,B 能访问 A,但 A 不能访问 B)
- 过多使用友元会降低代码的可维护性
- 友元函数声明放在 private 或 public 区域效果一样
- 模板类的友元声明需要特别注意语法
- 优先考虑提供公共接口,友元是最后手段
总结
友元机制允许指定的函数或类访问另一个类的 private/protected 成员。它是 C++ 中一种"可控的封装破坏",最常见的用途是运算符重载。友元有三条核心规则:不可传递、不可继承、不受访问说明符影响。面试中要能说清楚这三条规则,并知道友元的适用场景(运算符重载、紧密耦合的协作类)和使用原则(优先用公共接口,友元是最后手段)。