C++核心编程友元的应用

1.友元

1.什么是友元

在C++中，友元（friend）是一种允许一个类或函数访问另一个类的非公有（private 或 protected）成员的机制。这种机制打破了类的封装性，因此在使用时需要谨慎。然而，在某些情况下，友元提供了一种方便的方式来实现特定的功能，如操作符重载、输入输出流操作等。

友元可以是另一个类、类的成员函数、或者全局函数。当一个类或函数被声明为另一个类的友元时，它就可以访问那个类的所有私有和保护成员。

2.全局函数做友元

全局函数（非类成员函数）也可以被声明为类的友元。这样做允许全局函数访问类的私有（private）和保护（protected）成员。

#include <iostream>class MyClass {// 声明全局函数 friendFunc 为友元friend void friendFunc(MyClass& obj);private:int secretValue;public:MyClass(int value) : secretValue(value) {}
};// 全局函数，它可以访问 MyClass 的私有成员
void friendFunc(MyClass& obj) {std::cout << "Secret value: " << obj.secretValue << std::endl;
}int main() {MyClass myObj(42);friendFunc(myObj);  // 输出: Secret value: 42return 0;
}

在这个例子中，friendFunc 是一个全局函数，它被声明为 MyClass 的友元。因此，friendFunc 可以访问 MyClass 的私有成员 secretValue。在 main 函数中，我们创建了一个 MyClass 对象 myObj，并将其传递给 friendFunc，后者成功输出了 secretValue 的值。

2.类做友元

在C++中，一个类也可以被声明为另一个类的友元。当一个类被声明为另一个类的友元时，这个友元类可以访问另一个类的私有（private）和保护（protected）成员。这种机制在某些情况下可能很有用，特别是当两个类需要紧密协作，并且一个类需要直接访问另一个类的内部数据时。

#include <iostream>class MyClass {// 声明另一个类（例如 MyFriendClass）为友元friend class MyFriendClass;private:int secretValue;public:MyClass(int value) : secretValue(value) {}// 提供一个公共函数以显示secretValue的值（仅用于比较）void displaySecretValue() const {std::cout << "Secret value: " << secretValue << std::endl;}
};// 友元类 MyFriendClass
class MyFriendClass {
public:// MyFriendClass 可以访问 MyClass 的私有成员void printSecret(const MyClass& obj) {std::cout << "MyFriendClass sees: " << obj.secretValue << std::endl;}
};int main() {MyClass myObj(42);MyFriendClass friendObj;// 通过 MyClass 的公共函数显示 secretValuemyObj.displaySecretValue(); // 输出: Secret value: 42// 通过 MyFriendClass 访问 MyClass 的私有成员friendObj.printSecret(myObj); // 输出: MyFriendClass sees: 42return 0;
}

在这个例子中，MyFriendClass 被声明为 MyClass 的友元。因此，MyFriendClass 中的成员函数 printSecret 可以访问 MyClass 对象的 secretValue 成员，即使它是私有的。注意，友元关系不是双向的；即 MyClass 不是 MyFriendClass 的友元，除非另外声明。

使用类作为友元时要特别小心，因为它破坏了封装性，并可能导致代码难以维护和理解。在可能的情况下，最好使用公共接口和受保护的成员来实现类之间的协作。然而，在某些情况下，类作为友元可能是实现特定功能所必需的。

3.成员函数做友元

在C++中，成员函数本身并不直接作为另一个类的友元，因为成员函数是类的一部分，它总是能够访问其所在类的所有成员（包括私有和保护成员）。然而，你可以将一个类的成员函数声明为另一个类的友元，但实际上是将这个成员函数所属的整个类声明为友元。

但如果你想让另一个类的成员函数能够访问当前类的私有或保护成员，你应该做的是将该成员函数所在的整个类声明为当前类的友元。

#include <iostream>class MyClass {// 声明另一个类（例如 OtherClass）为友元friend class OtherClass;private:int secretValue;public:MyClass(int value) : secretValue(value) {}// 提供一个公共函数以显示secretValue的值（仅用于比较）void displaySecretValue() const {std::cout << "Secret value: " << secretValue << std::endl;}
};class OtherClass {
public:// 这个成员函数可以访问 MyClass 的私有成员void printSecret(const MyClass& obj) {std::cout << "OtherClass sees: " << obj.secretValue << std::endl;}
};int main() {MyClass myObj(42);OtherClass friendObj;// 通过 MyClass 的公共函数显示 secretValuemyObj.displaySecretValue(); // 输出: Secret value: 42// 通过 OtherClass 的成员函数访问 MyClass 的私有成员friendObj.printSecret(myObj); // 输出: OtherClass sees: 42return 0;
}

在这个例子中，OtherClass 被声明为 MyClass 的友元，这意味着 OtherClass 的所有成员函数（不仅仅是 printSecret）都可以访问 MyClass 的私有成员。然而，在实际编程中，通常最好只将真正需要访问私有成员的成员函数所在的类声明为友元，以保持封装的完整性。

//
// Created by 86189 on 2024/6/6.
//
#include "iostream"
using namespace std;class myClassFriend;
class myClass{
public:myClass();void visit();myClassFriend *myClassfriend;
};
class myClassFriend{friend void  myClass::visit();;
public:myClassFriend();
public:string name;
private:string sex;
};myClassFriend::myClassFriend() {name = "张三";sex = "男";
}myClass::myClass() {myClassfriend = new myClassFriend;
}void myClass::visit() {cout << myClassfriend->name << endl;cout << myClassfriend->sex << endl;
}int main() {myClass myclass;myclass.visit();delete myclass.myClassfriend;return 0;
}

只通过成员函数访问另一个类的私有成员。