c++ 友元函数和类

一、类内不同权限下声明的友元函数

在 C++ 中，友元函数的权限声明通常位于类的任何访问级别标签下：public、protected 或 private。友元关系的声明不受访问级别的限制，但这种权限声明本身并不改变友元函数的访问级别，而是意味着该任何权限下函数都可以访问类的私有和保护成员。

在 public 区域声明友元函数： 声明在 public 区域意味着友元函数的声明对所有人可见。

class MyClass {
    public:
        friend void friendFunction(MyClass& obj); // 在 public区域声明友元函数
    private:
        int privateVar;
};

在 protected 区域声明友元函数： 声明在 protected 区域仅允许子类和同一包的类可见

class MyClass {
    protected:
        friend void friendFunction(MyClass& obj); // 在 protected 区域声明友元函数
    private:
        int privateVar;
};

在 private 区域声明友元函数： 声明在 private 区域使得友元声明对外部类不可见，只是在内部使用。

class MyClass {
    private:
        friend void friendFunction(MyClass& obj); // 在 private 区域声明友元函数
        int privateVar;
};

虽然友元函数的声明可以位于不同的访问级别中，但这样做不影响友元函数的权限，因为友元函数本质上是独立于类成员的，并且无论其声明位置如何，它都能够访问类的所有成员（包括 private 和 protected 成员）

二、可以声明为友元函数的函数

普通全局函数： 普通的非成员函数可以被声明为友元函数。

class MyClass {
    private:
        int privateVar;

    public:
        friend void globalFriendFunction(MyClass& obj);  // 声明全局函数为友元函数
};

void globalFriendFunction(MyClass& obj) {
    obj.privateVar = 10;
}

成员函数： 另一个类中的成员函数可以被声明为友元函数。

class ClassB;  // 前向声明

class ClassA {
    private:
        int privateVar;

    public:
        friend void ClassB::memberFriendFunction(ClassA& obj);  // 声明ClassB的成员函数为友元函数
};

class ClassB {
    public:
        void memberFriendFunction(ClassA& obj);
};

void ClassB::memberFriendFunction(ClassA& obj) {
    obj.privateVar = 20;
}

函数模板： 模板函数也可以被声明为友元。

template <typename T>
class MyClass {
    private:
        T privateVar;

    public:
        template <typename U>
        friend void templateFriendFunction(MyClass<U>& obj);  // 声明模板函数为友元函数
};

template <typename U>
void templateFriendFunction(MyClass<U>& obj) {
    obj.privateVar = 30;
}

模板类的成员函数： 模板类中的成员函数可以被声明为友元函数。

template <typename T>
class MyClass {
    private:
        T privateVar;

    public:
        template <typename U>
        friend class TemplateFriendClass;  // 声明模板类为友元

        void display() const { std::cout << privateVar << std::endl; }
};

template <typename U>
class TemplateFriendClass {
    public:
        void modify(MyClass<U>& obj) {
            obj.privateVar = 40;
        }
};

内联友元函数： 友元函数还可以被定义为内联友元函数。

class MyClass {
    private:
        int privateVar;

    public:
        friend void inlineFriendFunction(MyClass& obj) {
            obj.privateVar = 50;  // 内联定义友元函数
        }
};

三、友元类

友元类： 一个类可以被声明为另一个类的友元类，从而使得友元类的所有成员函数都能够访问前者的私有和保护成员。

class ClassB;  // 前向声明

class ClassA {
    private:
        int privateVar;

    public:
        ClassA() : privateVar(0) {}

        // 声明 ClassB 为友元类
        friend class ClassB;
};

class ClassB {
    public:
        void modifyClassA(ClassA& obj) {
            obj.privateVar = 42;  // 访问并修改 ClassA 的私有成员
        }
};

友元类模板： 模板类也可以被声明为友元类，从而使得所有模板实例都可以访问声明类的私有和保护成员。

template <typename T>
class MyClass {
    private:
        T privateVar;

    public:
        MyClass() : privateVar(0) {}

        // 声明模板函数为友元
        template <typename U>
        friend void friendFunctionTemplate(MyClass<U>& obj);
};

template <typename U>
void friendFunctionTemplate(MyClass<U>& obj) {
    obj.privateVar = 70;  // 访问并修改 MyClass 的私有成员
}

五、整合

#include <iostream>

// 全局函数友元声明和定义
class MyClass1 {
    private:
        int privateVar;
    public:
        MyClass1() : privateVar(0) {}
        friend void globalFriendFunction(MyClass1& obj);
};

void globalFriendFunction(MyClass1& obj) {
    obj.privateVar = 10;
}

// 成员函数友元声明和定义
class ClassB; // 前向声明

class ClassA {
    private:
        int privateVar;
    public:
        ClassA() : privateVar(0) {}
        friend void ClassB::memberFriendFunction(ClassA& obj);
};

class ClassB {
    public:
        void memberFriendFunction(ClassA& obj);
};

void ClassB::memberFriendFunction(ClassA& obj) {
    obj.privateVar = 20;
}

// 模板函数友元声明和定义
template <typename T>
class MyClass2 {
    private:
        T privateVar;
    public:
        MyClass2() : privateVar(0) {}
        template <typename U>
        friend void templateFriendFunction(MyClass2<U>& obj);
};

template <typename U>
void templateFriendFunction(MyClass2<U>& obj) {
    obj.privateVar = 30;
}

// 内联友元声明和定义
class MyClass3 {
    private:
        int privateVar;
    public:
        MyClass3() : privateVar(0) {}
        friend void inlineFriendFunction(MyClass3& obj) {
            obj.privateVar = 40;
        }
};

// 模板类的成员函数友元声明和定义
template <typename T>
class MyClass4 {
    private:
        T privateVar;
    public:
        MyClass4() : privateVar(0) {}
        template <typename U>
        friend class TemplateFriendClass;

        void display() const {
            std::cout << "Value: " << privateVar << std::endl;
        }
};

template <typename U>
class TemplateFriendClass {
    public:
        void modify(MyClass4<U>& obj) {
            obj.privateVar = 50;
        }
};

int main() {
    MyClass1 myObj1;
    globalFriendFunction(myObj1);

    ClassA myObj2;
    ClassB objB;
    objB.memberFriendFunction(myObj2);

    MyClass2<int> myObj3;
    templateFriendFunction(myObj3);

    MyClass3 myObj4;
    inlineFriendFunction(myObj4);

    MyClass4<int> myObj5;
    TemplateFriendClass<int> tempObj;
    tempObj.modify(myObj5);
    myObj5.display(); // 输出修改后的结果

    return 0;
}