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:

Use Friend Functions When:

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.

Example

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.

When Not to Use Friend Functions

• 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.