Friend Functions vs. Public Members

Friend functions offer a way to grant specific access to private or protected members of a class without making those members public. Here's when to use friend functions over public members:

1. Controlled Access: If only a specific function or class needs access to a member, using a friend function can prevent unnecessary exposure of internal data.
2. Logical Grouping: If a function logically operates on the private data of a class but doesn't naturally belong as a member function, making it a friend can be more appropriate.
3. Operator Overloading: When overloading operators that should be non-member functions (like operator<<), friend functions can access the private data needed for the operation.

Consider a BankAccount class where we want to allow a transferFunds function to access private balance data:

1#include <iostream>
2
3class BankAccount {
4  friend void transferFunds(
5    BankAccount &from,
6    BankAccount &to,
7    double amount
8  );
9
10public:
11  BankAccount(double balance)
12    : balance{balance} {}
13
14  void displayBalance() const {
15    std::cout << "Balance: " << balance << "\n";
16  }
17
18private:
19  double balance;
20};
21
22void transferFunds(
23  BankAccount &from,
24  BankAccount &to,
25  double amount
26) {
27  if (from.balance >= amount) {
28    from.balance -= amount; 
29    to.balance += amount; 
30  }
31}
32
33int main() {
34  BankAccount account1{100.0};
35  BankAccount account2{50.0};
36
37  transferFunds(account1, account2, 30.0);
38
39  account1.displayBalance(); // Balance: 70
40  account2.displayBalance(); // Balance: 80
41}

1Balance: 70
2Balance: 80

In this example, transferFunds is a friend function that transfers money between two accounts.

Making balance public would expose it unnecessarily, while the friend function provides the needed access without compromising encapsulation.

• If the data needs to be accessible in many places, consider if it should be public or protected.
• Overuse of friend declarations can make your code harder to understand and maintain.

Friend functions offer a balance between encapsulation and accessibility, but use them only when it makes logical and structural sense.