友元函数的访问控制 ​

面试考点 ​

友元机制是 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++ 中一种"可控的封装破坏",最常见的用途是运算符重载。友元有三条核心规则:不可传递、不可继承、不受访问说明符影响。面试中要能说清楚这三条规则,并知道友元的适用场景(运算符重载、紧密耦合的协作类)和使用原则(优先用公共接口,友元是最后手段)。