Friend Functions and Encapsulation

Friend functions and classes provide a way to extend the accessibility of a class's private and protected members beyond the class itself, which can be useful in certain scenarios.

However, this can also impact the principle of encapsulation, which is a core concept in object-oriented programming.

Encapsulation aims to hide the internal state and implementation details of an object, exposing only what is necessary through a public interface.

By making certain functions or classes friends, you are giving them access to the internals of your class, which can be seen as a breach of this encapsulation principle.

While this might seem like a downside, it has its benefits:

• Controlled Access: Instead of making a member public and exposing it to the entire program, you can provide access to specific functions or classes that truly need it.
• Enhanced Functionality: Sometimes, external functions or classes need to interact closely with the internal state of another class to provide meaningful functionality, such as logging or analytics.

Here's an example to illustrate:

1#include <iostream>
2
3class MyClass {
4  friend void LogCalls(MyClass); 
5
6public:
7  void operator()() { ++Calls; }
8
9private:
10  int Calls{0};
11};
12
13void LogCalls(MyClass Functor) {
14  std::cout << "That functor has been called "
15            << Functor.Calls << " times.\n"; 
16}
17
18int main() {
19  MyClass Functor;
20  Functor();
21  Functor();
22  Functor();
23  LogCalls(Functor);
24}

1That functor has been called 3 times.

In this example, the LogCalls() function needs access to the private Calls member of MyClass. Instead of making Calls public, we declare LogCalls() as a friend, preserving encapsulation for other parts of the program.

Use friend functions and classes judiciously to strike a balance between encapsulation and the need for certain functions to access private data.