C++中为其他类成员函数声明友元的实用场景疑问

你提到的这种场景确实容易让人困惑——看起来X::foo(int)没接收Y对象参数，好像没法用到友元权限，但实际上友元的核心是赋予访问Y私有成员的权限，而不是强制函数必须接收Y对象。下面是几个常见的实用场景：

1. 访问Y的静态私有成员 #

如果Y包含静态私有变量或静态私有成员函数，X::foo(int)作为友元可以直接访问这些静态成员，完全不需要Y的实例。这类场景常用于控制静态状态的修改，或者调用只有友元能触发的静态逻辑：

class Y {
private:
    static int internal_counter;
    static void reset_counter() { internal_counter = 0; }
    // 声明X的foo函数为友元
    friend void X::foo(int);
};

int Y::internal_counter = 0;

class X {
public:
    void foo(int step) {
        // 直接修改Y的静态私有变量
        Y::internal_counter += step;
        // 调用Y的静态私有函数
        if (Y::internal_counter > 100) {
            Y::reset_counter();
        }
    }
};

2. 在函数内部创建并操作Y的实例 #

如果Y的构造函数是私有的（比如单例模式、工厂模式的设计），只有友元函数能直接创建Y的对象。X::foo(int)可以在函数内部构造Y的实例，然后访问其私有成员：

class Y {
private:
    int value;
    // 私有构造函数，外部无法直接创建Y
    Y(int v) : value(v) {}
    void update_value(int v) { value = v; }
    friend void X::foo(int);
};

class X {
public:
    void foo(int init_val) {
        // 友元权限允许直接调用私有构造函数
        Y local_y(init_val);
        // 访问并修改Y的私有成员
        local_y.update_value(init_val * 2);
        // 也可以动态分配
        Y* y_ptr = new Y(init_val + 10);
        delete y_ptr;
    }
};

3. 操作全局/外部持有的Y对象 #

如果程序中存在全局的Y实例，或者X::foo(int)能通过其他渠道（比如全局指针、外部引用）获取到Y的对象，友元权限就能让它直接访问该对象的私有成员：

// 全局Y实例
Y global_y;

class Y {
private:
    int status;
    friend void X::foo(int);
};

class X {
public:
    void foo(int new_status) {
        // 直接修改全局Y对象的私有成员
        global_y.status = new_status;
    }
};

4. 工厂类的辅助逻辑 #

当X是负责创建和管理Y实例的工厂类时，X::foo(int)可以作为工厂的一个方法，利用友元权限初始化Y的私有内部状态，而不需要给Y暴露公共的 setter 方法，保持Y的封装性：

class Y {
private:
    int config;
    // 私有构造，只有工厂能创建
    Y() = default;
    friend void X::create_configured_y(int);
};

class X {
public:
    void create_configured_y(int config_val) {
        Y* y = new Y();
        // 直接初始化Y的私有配置
        y->config = config_val;
        // 后续可以把y返回给外部，或者自己管理
    }
};

简单来说，友元权限是"通行证"——只要函数有这个通行证，不管它是自己造Y对象、用全局的Y对象，还是访问静态成员，都能合法操作Y的私有部分，这就是这种声明方式的核心价值。

内容的提问来源于stack exchange，提问作者Simon