Overloaded Friend Functions

When a friend function is overloaded, each version of the function must be declared as a friend within the class. This ensures that each overloaded variant has the necessary access to the class's private and protected members.

Example

Consider a class Example with overloaded friend functions:

1#include <iostream>
2
3class Example {
4  friend void display(const Example &obj);
5  friend void display(
6    const Example &obj, int extra);
7
8 private:
9  int value{5};
10};
11
12void display(const Example &obj) {
13  std::cout << "Value: "
14    << obj.value << "\n";  
15}
16
17void display(const Example &obj, int extra) {
18  std::cout << "Value: "
19    << obj.value + extra << "\n";  
20}
21
22int main() {
23  Example ex;
24  display(ex);
25  display(ex, 10);
26}

1Value: 5
2Value: 15

In this example, both display() functions are declared as friends of Example. Each function can access the private member value.

Overloading and Ambiguity

When you overload friend functions, you must ensure that their signatures are distinct enough to avoid ambiguity. The compiler uses the number and types of parameters to differentiate between overloaded functions.

Operator Overloading

Friend functions are often used to overload operators. Here's an example of overloading the + operator for a Vector class:

1#include <iostream>
2
3class Vector {
4  friend Vector operator+(
5    const Vector &v1, const Vector &v2);
6
7  friend std::ostream &operator<<(
8    std::ostream &os, const Vector &v);
9
10 public:
11  Vector(int x, int y) : x{x}, y{y} {}
12
13 private:
14  int x, y;
15};
16
17Vector operator+(
18  const Vector &v1, const Vector &v2) {
19  return Vector(v1.x + v2.x, v1.y + v2.y);  
20}
21
22std::ostream &operator<<(
23  std::ostream &os, const Vector &v) {
24  os << "Vector(" << v.x << ", " << v.y << ")";
25  return os;
26}
27
28int main() {
29  Vector v1(1, 2);
30  Vector v2(3, 4);
31  Vector v3 = v1 + v2;
32
33  std::cout << v3;
34}

1Vector(4, 6)

In this example, the + operator is overloaded using a friend function, allowing it to access the private members of the Vector class.

Conclusion

Overloading friend functions is straightforward, but each overloaded variant must be explicitly declared as a friend. This ensures that all versions have the necessary access to the class's private and protected members.

Overloading is particularly useful in scenarios like operator overloading, where different versions of a function need to handle various types or numbers of parameters.