Inheriting Friend Functions

Friend functions are not inherited by derived classes. This is because the friend relationship is specific to the class where the friend function is declared. Here’s how it works:

Understanding Friend Functions

When you declare a friend function in a class, you’re granting it access to the private and protected members of that specific class. This does not extend to derived classes. Each class must explicitly declare its own friends.

Example

Consider a base class Base and a derived class Derived. If Base declares a friend function, this friend function does not automatically become a friend of Derived.

1#include <iostream>
2
3class Base {
4  friend void showData(Base &b, bool derived);  
5
6 private:
7  int baseData{10};
8};
9
10class Derived : public Base {
11 private:
12  int derivedData{20};
13  // Note: showData is not a friend here.
14};
15
16void showData(Base &b, bool showDerived = false) {
17  std::cout << "\nBase data: " << b.baseData;  
18
19  if (showDerived) {
20    std::cout << "\nDerived data: "
21      << static_cast<Derived &>(b).derivedData;  
22  }
23}
24
25int main() {
26  Base b;
27  Derived d;
28  showData(b, false);
29  showData(d, true); 
30}

1error C2248: 'Derived::derivedData': cannot access private member declared in class 'Derived'

In this example, showData() is a friend of Base and can access its private members. However, it is not a friend of Derived, so it cannot access the private derivedData member.

Making a Friend Function for Derived Classes

If you want a friend function to access members of both base and derived classes, you must declare it as a friend in each class:

1#include <iostream>
2
3class Base {
4  friend void showData(Base &b, bool derived);
5
6 private:
7  int baseData{10};
8};
9
10class Derived : public Base {
11  friend void showData(Base &b, bool derived);  
12
13 private:
14  int derivedData{20};
15};
16
17void showData(Base &b, bool showDerived = false) {
18  std::cout << "\nBase data: " << b.baseData;
19
20  if (showDerived) {
21    std::cout << "\nDerived data: "
22      << static_cast<Derived &>(b).derivedData;
23  }
24}
25
26int main() {
27  Base b;
28  Derived d;
29  showData(b, false);
30  showData(d, true);
31}

1Base data: 10
2Base data: 10
3Derived data: 20

By declaring showData() as a friend in both Base and Derived, it can now access private members of both classes. This approach keeps the encapsulation intact while granting necessary access where needed.