friend function definition in a class can't call another friend function declared in a class

Summary

The issue at hand is related to friend function definitions in C++ and how they interact with each other within the scope of a class. Specifically, the problem arises when one friend function attempts to call another friend function that is declared within the same class, resulting in a compiler error stating that the called function was not declared in the current scope.

Root Cause

The root cause of this issue can be attributed to the following key points:

Friend function declarations are essentially treated as if they were declared outside the class definition in the enclosing scope.
Name lookups in friend function definitions do not follow the same logic as the declarations themselves; instead, they perform lookups as if the function was defined in the scope where it is being called.
The compiler’s behavior is consistent with the C++ standard, which dictates how friend functions are declared, defined, and interact with each other.

Why This Happens in Real Systems

This issue can occur in real-world systems when:

Developers attempt to define complex relationships between friend functions within a class.
The class design requires friend functions to interact with each other in a specific manner.
The programmer is not aware of the nuances of friend function declarations and definitions in C++.

Real-World Impact

The impact of this issue can be significant, leading to:

Compiler errors that may be difficult to diagnose, especially for junior developers.
Code redesign to work around the limitations imposed by the C++ standard.
Performance implications if the workaround involves additional function calls or indirect access to class members.

Example or Code

class Thing {
public:
    Thing(int i) : i(i) {}
    friend Thing example();
    friend Thing stuff() {
        return example(); // error: 'example' was not declared in this scope
    }
private:
    int i;
};

Thing example() {
    return Thing(0);
}

How Senior Engineers Fix It

Senior engineers can address this issue by:

Declaring friend functions outside the class definition to ensure they are visible to other friend functions.
Using forward declarations to make the friend functions visible to each other.
Rethinking the class design to avoid complex interactions between friend functions.

Why Juniors Miss It

Junior developers may miss this issue due to:

Lack of understanding of the C++ standard and how friend functions are declared, defined, and interact with each other.
Insufficient experience with complex class designs and friend function relationships.
Overlooking the nuances of name lookups in friend function definitions.

friend function definition in a class can’t call another friend function declared in a class