Where (and Whether) to Declare a C++ friend Function

When Friendship Is Justified

• Symmetric operators requiring equal access to both operands. Examples: operator==, arithmetic operators when implemented as non-members for symmetry. If access to internals is unavoidable, use a hidden friend (declare inside the class, define inline) to enable ADL while keeping the function non-member.
• Formatting/streaming operators. operator<<(std::ostream&, const T&) is commonly a hidden friend that reads private state for presentation.
• Tightly coupled helpers that are part of a class’s invariants. E.g., a validator that must see representation details and cannot be reasonably expressed via the public API without leaking implementation.

Prefer These Alternatives First

• Public const observers (read-only accessors) and implement non-member operations using those observers instead of friend.
• Member operators when one operand must be the class itself (e.g., assignment, subscript). Follow our operator-overloading guidelines (return by reference where expected, minimal surprise, no gratuitous overloads).
• Non-member non-friend when the operation can be expressed via the public interface-keeps encapsulation intact.

Modern Pitfalls to Avoid

• Broad friendship: Do not grant friend class X; unless every member truly needs access. Prefer a specific friend function.
• Legacy types/APIs: Avoid COM-style BSTR or raw ownership channels in interface code. Use RAII types like std::string, std::u16string, and smart pointers. Keep operator code exception-safe and noexcept where appropriate.
• Testing shortcuts: Resist making tests friend; prefer behavior-level tests or narrow observers. If you must, isolate test-only friends behind compile-time switches.

Patterns and Examples

1) Hidden friend for streaming (recommended)

Define the operator inside the class body (as a friend) but not as a member; this preserves symmetry and enables ADL without polluting the global namespace.

#include <ostream>
class Point {
  int x_ = 0, y_ = 0;

public:
  Point(int x, int y) : x_{x}, y_{y} {}

  // Hidden friend: non-member, but declared here for access + ADL.
  friend std::ostream& operator<<(std::ostream& os, const Point& p) {
    return os << '(' << p.x_ << ", " << p.y_ << ')';
  }
};

2) Non-member, non-friend using public observers (preferred when possible)

Expose a narrow observer and implement the operator without friendship.

#include <compare>

class Money {
  long long cents_ = 0; // invariant: always integral cents
public:
  explicit Money(long long cents) : cents_{cents} {}
  long long cents() const noexcept { return cents_; } // narrow observer
};

// No friend needed:
inline Money operator+(const Money& a, const Money& b) {
  return Money{a.cents() + b.cents()};
}

inline bool operator==(const Money& a, const Money& b) noexcept {
  return a.cents() == b.cents();
}

inline std::strong_ordering operator<=>(const Money& a, const Money& b) noexcept {
  return a.cents() <=> b.cents();
}

3) Member vs. friend for assignment-like operators

Operators that conceptually modify the left operand (=, [], (), ->) should be members. Return by reference where expected.

class Buffer {
  // ...
public:
  Buffer& operator=(const Buffer&) = default;     // return by reference
  Buffer& operator+=(const Buffer& rhs) { /* ... */ return *this; }
};

4) Avoid blanket class friendship

Prefer a single narrow friend function instead of friend class.

class Token {
  int kind_;
  int value_;
public:
  // Narrow friend: only the parser's exact function needs access.
  friend bool parse_token_stream(class Parser& p, Token& out);
};

Checklist Before Adding a friend

• Can I implement this operation using public const observers?
• Is symmetry required (non-member) and internals unavoidable (friend)?
• Is the friend declaration as narrow and local as possible (hidden friend)?
• Does this comply with our
  1. Overloadable Operator Scope and
  2. Operator Overloading Guidelines
  (semantic correctness, minimal surprise, noexcept/strong guarantees where appropriate)?
• Am I avoiding legacy constructs (e.g., BSTR) and favoring RAII/smart pointers?

FAQ

Where do I put the declaration? Inside the class that grants access. For hidden friends, define the function inline there as well. Otherwise, declare inside, define in the same namespace as the class so ADL finds it.

Does access specifier matter? No-friend ignores public/protected/private placement. We place friends with related API (usually near observers) for discoverability.

Friend Function - Quiz