Declaring Multiple Friends

In C++, you can declare multiple classes or functions as friends of a class. Each friend declaration must be on a separate line within the class definition.

This approach allows you to provide specific access to various classes and functions.

Here's how to declare multiple friend functions within a class:

1#include <iostream>
2
3class MyClass {
4  friend void functionOne(MyClass &obj);  
5  friend void functionTwo(MyClass &obj);  
6
7 private:
8  int value{10};
9};
10
11void functionOne(MyClass &obj) {
12  std::cout << "Value from functionOne: "
13    << obj.value << "\n";
14}
15
16void functionTwo(MyClass &obj) {
17  std::cout << "Value from functionTwo: "
18    << obj.value << "\n";
19}
20
21int main() {
22  MyClass obj;
23  functionOne(obj);
24  functionTwo(obj);
25}

1Value from functionOne: 10
2Value from functionTwo: 10

Here's how to declare multiple friend classes within a class:

1#include <iostream>
2class FriendClassOne;
3class FriendClassTwo;
4
5class MyClass {
6  friend class FriendClassOne;  
7  friend class FriendClassTwo;  
8
9 private:
10  int value{20};
11};
12
13class FriendClassOne {
14 public:
15  void showValue(MyClass &obj) {
16    std::cout << "Value from FriendClassOne: "
17      << obj.value << "\n";
18  }
19};
20
21class FriendClassTwo {
22 public:
23  void showValue(MyClass &obj) {
24    std::cout << "Value from FriendClassTwo: "
25      << obj.value << "\n";
26  }
27};
28
29int main() {
30  MyClass obj;
31  FriendClassOne f1;
32  FriendClassTwo f2;
33
34  f1.showValue(obj);
35  f2.showValue(obj);
36}

1Value from FriendClassOne: 20
2Value from FriendClassTwo: 20

• Specific Access: You can grant access to multiple classes or functions without exposing private members to the entire program.
• Modularity: This maintains modularity by allowing only specific functions or classes to interact with the private data.

• Readability: While declaring multiple friends can be useful, ensure it does not clutter the class definition, making it harder to read.
• Design Choice: Overusing friend declarations might indicate a need to reconsider the design. Always assess if there are alternative design patterns that could achieve the same goal without exposing private members.

Befriending multiple classes or functions provides flexibility in controlling access to a class's private and protected members. This technique should be used judiciously to maintain clean and maintainable code.