Friend Classes and Functions

In our previous lessons covering classes and structs, we introduced access specifiers which allowed us to declare how accessible the variables and functions of our class are:

• public functions and members are accessible from anywhere
• protected functions and members are accessible only to the same class, or from a child class
• private functions and members are accessible only within the same class

This allowed us to simplify our class interface by hiding away the inner workings of our class. We could use the public access specifier to make only a small number of our functions accessible to the outside world. Creating a smaller public interface in this way makes our classes friendlier to use and easier to maintain.

However, this can be inflexible. There are many cases where we want more granular control.

For example, our class might have some data and methods that are of particular interest to another specific class or function. But we don’t want to make them public for everyone - that’s too heavy-handed and can eliminate the benefits of encapsulation.

Instead, we can solve these problems by having our class befriend the other class, using the friend keyword.

Friend Functions

A class can declare free functions (ie, a function that is not part of another class) as friends using the friend keyword, followed by the function signature. In the following example, MyClass befriends three different functions:

1class MyClass {
2  friend void SomeFunction();
3  friend bool AnotherFunction(int);
4  friend void OneMore(int, float);
5};
6

More generally, the syntax is

1friend return_type function_name(argument_list);
2

Any function our class identifies as a friend will have access to everything in our class, including protected and private members.

Here is a complete example, where our class befriends the void LogCalls(MyClass) function, giving it access to the private Calls variable:

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

1That functor has been called 3 times
2

Friend Properties

Before we discuss some other possibilities of the friend keyword, it’s worth noting some of its properties:

A friend statement can appear anywhere in the class

It doesn’t matter where the friend statement appears within our class. It can come at the start, the end, or anywhere in between - the effect is the same.

A friend statement is not subject to access specifiers

It doesn’t matter if a friend statement appears in a public, protected, or private part of the class - the effect is the same

Befriending is not mutual

If A declares B a friend, that does not give A additional access to B.

For that, B needs to explicitly declare A a friend too.

Befriending is not transitive

If A declares B a friend, and B declares C a friend, that does not give C additional access to A.

For that, A needs to explicitly declare C a friend.

Befriending is not inherited

If Child inherits from Parent, and Parent declares SomeClass a friend, that does not grant SomeClass access to Child.

For that, Child needs to explicitly declare SomeClass a friend.

Friend Classes

Our class can befriend another class, using the friend class keyword:

1class MyClass {
2  friend class Analytics;
3};
4

This gives any member of Analytics access to any member of MyClass:

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

1That functor has been called 3 times
2

Friend Class Functions

Where we want to befriend a class function, the syntax is similar to what we used to befriend a free function. We simply have to add the class name and the scope resolution operator to our friend statement:

1// Forward Declaration
2class MyClass;
3
4class Analytics {
5public:
6  static void LogCalls(MyClass Functor);
7};
8
9class MyClass {
10  friend void Analytics::LogCalls(MyClass);
11};
12

The following code shows a complete example of this. Note, we’ve had to move the definition of Analytics above the definition of MyClass in this example. We’ve then also had to move the definition of Analytics::LogCalls below the definition of MyClass.

This is to ensure everything is appropriately defined before it is used. In real programs, this is rarely an issue, as our classes would be in separate header files:

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

1That functor has been called 3 times
2

Friend Template Classes and Functions

We can befriend class and function templates by declaring template parameters in the normal way

1class MyClass {
2  // Befriending a class template
3  template <typename>
4  friend class Analytics;
5
6  // Befriending a function template
7  template <typename T>
8  friend void LogCalls(T);
9};
10

In this example, every instantiation of the template, including specializations of the template, is befriended.

If we want to befriend just a specific instantiation of a template class or function, we can provide the template parameters within our friend statement. This requires that the templates have already been declared:

1// Forward Declarations
2template <typename T>
3class Analytics;
4
5template <typename T>
6void LogCalls(T);
7
8class MyClass {
9  friend class Analytics<MyClass>; 
10  friend void LogCalls<MyClass>(MyClass); 
11};
12

A complete, working example using both a class template and a function template:

1#include <iostream>
2
3class MyClass {
4  template <typename>
5  friend class Analytics;
6
7  template <typename T>
8  friend void LogCalls(T);
9
10public:
11  void operator()(){ ++Calls; }
12
13private:
14  int Calls{0};
15};
16
17template <typename T>
18class Analytics {
19public:
20  static void LogCalls(T Functor){
21    std::cout << "That functor has been called "
22      << Functor.Calls << " times\n";
23  }
24};
25
26template <typename T>
27void LogCalls(T Functor){
28  std::cout << "That functor has been called "
29    << Functor.Calls << " times";
30}
31
32int main(){
33  MyClass Functor;
34  Functor();
35  Functor();
36  Functor();
37  Analytics<MyClass>::LogCalls(Functor);
38  LogCalls(Functor);
39}
40

1That functor has been called 3 times
2That functor has been called 3 times
3