Friend Classes and Functions in Modern C++

Power, Encapsulation, and Controlled Violations of Access

1. Introduction: Why friend Exists

C++ is built on strong encapsulation. By default, an object’s internals are hidden behind private and protected access specifiers.

Yet real systems often require trusted collaboration between tightly related components.

The friend mechanism exists to solve a precise problem:

Grant explicit, targeted, and non-hierarchical access to otherwise private internals.

Unlike inheritance or public APIs, friend is:

• Explicit

• Non-transitive

• Non-inheritable

• One-directional

Used correctly, it enables clean architecture. Used poorly, it destroys encapsulation.

2. What Is a friend in C++?

A friend is a function or class that is allowed to access private and protected members of another class.

Key properties:

3. Friend Functions

3.1 Basic Syntax

class Secret {
private:
    int value = 42;

    friend void reveal(const Secret&);
};

void reveal(const Secret& s) {
    std::cout << s.value << '\n';
}

Important points:

• reveal is not a member function

• It has full access to private members

• Friendship is granted explicitly inside the class

3.2 Common Use Case: Operator Overloading

This is the most legitimate and common use of friend.

class Vec2 {
private:
    float x, y;

public:
    Vec2(float x, float y) : x(x), y(y) {}

    friend Vec2 operator+(const Vec2& a, const Vec2& b);
};

Vec2 operator+(const Vec2& a, const Vec2& b) {
    return { a.x + b.x, a.y + b.y };
}

Reasons for using friend:

• Operators must be symmetric

• The operator cannot belong to both operands

• Avoids unnecessary getters that weaken encapsulation

3.3 Stream Operators (<<, >>)

Canonical example:

class User {
    std::string name;
    int age;

public:
    friend std::ostream& operator<<(std::ostream&, const User&);
};

std::ostream& operator<<(std::ostream& os, const User& u) {
    return os << u.name << " (" << u.age << ")";
}

This preserves encapsulation, natural syntax, and performance.

4. Friend Classes

4.1 Syntax and Semantics

class Engine;

class Car {
private:
    int horsepower = 300;

    friend class Engine;
};

class Engine {
public:
    void tune(Car& c) {
        c.horsepower += 50;
    }
};

Key observations:

• The entire Engine class gains access

• Friendship is one-directional

• No inheritance relationship exists

4.2 Real-World Use Cases

Friend classes are justified when:

• Two classes are conceptually inseparable

• One class provides infrastructure for another

• Performance prohibits public accessors

Typical examples:

• Iterator and container implementations

• Serializer and domain object

• Memory allocator and object layout

• ORM mapper and entity

5. Friendship Is Not Inheritance

This distinction is fundamental.

If a design implies an is-a relationship, friend is the wrong tool.

6. Modern C++ Design Guidelines for friend

6.1 Prefer Non-Member Functions First

Modern C++ encourages non-member, non-friend functions whenever possible.

Use friend only when:

• Accessors would expose invariants

• Performance matters

• Symmetric operations are required

6.2 Minimize Friendship Scope

Poor practice:

xxxxxxxxxx
friend class Everything;

Better practice:

xxxxxxxxxx
friend void serialize(const Foo&);

Rule: Grant the smallest possible friend.

6.3 friend as an Architectural Boundary

In well-designed systems, friend often marks:

• Internal subsystems

• Trusted infrastructure layers

• Explicit encapsulation boundaries

This pattern appears in:

• The C++ Standard Library

• Compilers and toolchains

• Game engines

• Embedded and real-time systems

7. friend and Modern C++ Features

7.1 Templates

template<typename T>
class Box {
    T value;

    template<typename U>
    friend class Inspector;
};

Function template friendship:

template<typename T>
class Data {
    T value;

    template<typename U>
    friend void inspect(const Data<U>&);
};

This is powerful but must be tightly controlled.

7.2 constexpr

Friends fully participate in compile-time evaluation.

class ConstValue {
    int v;

    friend constexpr int get(const ConstValue& c) {
        return c.v;
    }
};

7.3 Modules (C++20)

Modules do not change friend semantics.

Important notes:

• Friendship does not bypass module visibility rules

• The friend must still be visible within the module interface or implementation

Modules improve encapsulation but do not weaken access control.

8. Common Anti-Patterns

Using friend to avoid proper design Granting friendship to large subsystems Replacing interfaces with friend Treating friend as unrestricted access

9. When friend Is the Right Tool

Use friend when:

• Two entities form a single conceptual unit

• Zero-overhead access is required

• Symmetric non-member operations are needed

• Explicit trust is preferable to inheritance

Avoid friend when:

• A public API is sufficient

• Inheritance models the relationship

• Access can be restricted through interfaces

10. Final Perspective

friend is not a shortcut. It is a precision tool.

In Modern C++:

• It enables zero-cost abstractions

• It supports correct operator design

• It preserves encapsulation with deliberate exceptions

Strong engineers do not avoid friend. They use it deliberately and sparingly.