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

说实话，友元这个特性，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来自动生成。

给正在准备面试的你一点建议

友元和运算符重载，面试核心考的就两件事。

一是友元的三种形式和适用场景，特别是"为什么运算符重载经常用友元"这个问题，能答上来的候选人不多。

二是运算符重载的规则，哪些必须成员函数、哪些不能重载、不能改变优先级这些细节。

在机器人开发里，运算符重载用得非常多。Eigen库之所以好用，就是因为矩阵运算写起来跟数学公式一样自然。如果你自己写过Vector3、Quaternion的运算符重载，面试的时候提一嘴，很加分。

---

如果这篇文章对你有帮助，欢迎点赞、在看、转发三连。 你的支持是我持续更新的最大动力。

「机器人软件开发面试·从入门到精通」连载系列 

上一篇：第24篇 虚函数表——面试深挖时的杀手锏

下一篇预告：第26篇 模板函数——写通用算法的利器

有任何问题欢迎评论区留言，我会尽量回复。