当前位置：首页 > news >正文

第25篇友元与运算符重载：面试官问我为什么给friend开了后门，我差点没解释清楚

news 2026/8/16 22:04:38

上篇把虚函数表扒了个底朝天，今天聊一个"争议很大"的话题——友元。

说实话，友元这个特性，C++社区内部意见都不统一。有人觉得它是必要的工具，有人说它是破坏封装的罪人。面试的时候，如果你能讲清楚友元的适用场景和代价，面试官会觉得你不是死记硬背的。

除了友元，运算符重载也是面试高频考点。特别是做机器人开发的，自定义个Vector3、Matrix、Quaternion之类的类型是家常便饭，运算符重载直接用影响使用体验。

友元：封装的一道"合法缺口"

先看个问题。

你写了个传感器类，内部数据是private的：

class Sensor { double value_; int status_; public: Sensor(double v) : value_(v), status_(0) {} double getValue() const { return value_; } };

现在你想写一个函数，打印传感器的完整信息（包括private的status_）。怎么办？

要么加个getter把status_暴露出来，要么……用友元。

class Sensor { double value_; int status_; public: Sensor(double v) : value_(v), status_(0) {} double getValue() const { return value_; } friend void printFullInfo(const Sensor& s); }; void printFullInfo(const Sensor& s) { cout << "Value: " << s.value_ << ", Status: " << s.status_ << endl; // 可以直接访问private成员 }

friend关键字让一个外部函数或类可以访问你的private成员。说白了就是在封装的墙上开了个洞——有时候你需要这个洞。

友元的三种形式

面试可能会让你列举友元的用法，一共三种。

第一种，普通函数做友元，上面已经演示了。

第二种，友元类。A类把B类声明为友元，B的所有成员函数都能访问A的private：

class SensorData { double raw_data_[100]; int data_count_; friend class DataProcessor; // DataProcessor可以访问所有private }; class DataProcessor { public: void process(const SensorData& data) { for (int i = 0; i < data.data_count_; i++) { // 直接访问raw_data_和data_count_ cout << data.raw_data_[i] << " "; } } };

第三种，成员函数做友元。只让另一个类的某个特定函数访问：

class Sensor { double value_; friend void Calibrator::calibrate(Sensor& s); // 只有Calibrator::calibrate能访问private // Calibrator的其他函数不行 };

第三种用得最少，但面试偶尔会考。

友元的争议：为什么有人说它"不好"

讲真，友元确实有争议。

封装的核心思想是"隐藏内部实现，只暴露必要的接口"。友元直接打破了这个原则——你让外部代码绕过了公开接口，直接操作内部数据。

如果项目里友元用多了，代码的可维护性会下降。因为private成员可能被很多地方直接修改，出了bug很难追踪。

但完全不用友元也不现实。有些场景下，友元是最干净的方案。比如运算符重载——

运算符重载：让自定义类型像内置类型一样好用

在机器人开发里，你经常会定义三维向量、四元数、位姿这些类型。如果没有运算符重载，用起来是这样的：

Vector3 a(1, 2, 3); Vector3 b(4, 5, 6); Vector3 c = a.add(b); // 丑 double d = a.dot(b); // 还行

有了运算符重载：

Vector3 c = a + b; // 漂亮 double d = a * b; // 点积

运算符重载的本质就是函数重载，只不过函数名变成了运算符。实现方式是这样的：

class Vector3 { double x_, y_, z_; public: Vector3(double x, double y, double z) : x_(x), y_(y), z_(z) {} Vector3 operator+(const Vector3& other) const { return Vector3(x_ + other.x_, y_ + other.y_, z_ + other.z_); } double operator*(const Vector3& other) const { return x_ * other.x_ + y_ * other.y_ + z_ * other.z_; } };

为什么运算符重载经常需要友元

问题来了。如果你想让运算符的左操作数不是你的类的对象呢？

比如你想支持 2.0 * vector（标量在左边，向量在右边）。如果operator*是成员函数，左操作数必须是Vector3对象，2.0 * vector就不好办了——2.0是double，没有成员函数。

这时候用友元函数来重载：

class Vector3 { double x_, y_, z_; public: Vector3(double x, double y, double z) : x_(x), y_(y), z_(z) {} // 友元函数重载，支持 标量 * 向量 friend Vector3 operator*(double scalar, const Vector3& v) { return Vector3(scalar * v.x_, scalar * v.y_, scalar * v.z_); } // 成员函数重载，支持 向量 * 标量 Vector3 operator*(double scalar) const { return Vector3(x_ * scalar, y_ * scalar, z_ * scalar); } }; Vector3 v(1, 2, 3); Vector3 a = v * 2.0; // 成员函数 Vector3 b = 2.0 * v; // 友元函数

这就是友元在机器人开发中最常见的应用场景——让运算符重载支持对称的操作方式。

面试中的高频考点

面试官考运算符重载，有几个常见的坑。

第一个：运算符重载不能改变运算符的优先级和结合性。+还是加法的优先级，不能因为你重载了就变了。

第二个：不是所有运算符都能重载。::、.、sizeof、?: 这四个不能重载。面试偶尔会问。

第三个：=、()、[]、-> 这四个运算符必须通过成员函数重载，不能用友元。这个考得比较多。

第四个：重载的运算符至少要有一个操作数是自定义类型。你不能重载int + int，那是违法的。

我面试的时候见过一个候选人，把operator=写成了友元函数，面试官直接指出来了。这种基础错误不应该犯。

补充一个运算符重载的实战经验：重载<<运算符让自定义类型可以直接用cout输出，这在调试时特别方便。很多新手调试时只会用GDB或者打日志，其实如果你给传感器数据类型重载了<<，调试时直接cout << sensor_data就能看到完整信息，效率提升很多。写法是用友元函数实现friend ostream& operator<<(ostream& os, const SensorData& data)，在里面把关键字段格式化输出。面试时如果你提到这个习惯，面试官会觉得你是一个注重开发效率的人，有良好的调试工具链意识。另外还有个容易忽略的点：重载==运算符时一定要同时重载!=，否则在某些STL容器和算法里会出问题，C++20之后可以用default来自动生成。