Friend Functions & Classes

Friend member function of another class

• You can friend a **specific** member function: friend void Other::peek(const My&);
• Requires careful declaration order / forward declarations.
• Narrower than friending the whole class — better for encapsulation.

Forward declarations and friend

• Often you forward-declare a class before friending it: class Auditor; class Account { friend class Auditor; ...};
• Circular friendships need careful header structure.

class Doctor; // forward declaration

class Patient {
    int id;
    friend class Doctor;
public:
    Patient(int i) : id(i) {}
};

Friendship and encapsulation trade-off

• Every friend is an exception to data hiding.
• Document why friendship exists.
• If many friends appear, the class may need a better public interface or to split responsibilities.
• Operators and tightly coupled containers/nodes are the most accepted friend uses.

Friend function — print private data

#include <iostream>
using namespace std;

class Secret {
private:
    int code;
public:
    Secret(int c) : code(c) {}
    friend void reveal(const Secret& s);
};

void reveal(const Secret& s) {
    cout << "code = " << s.code << "\n";
}

int main() {
    Secret s(42);
    reveal(s);
    return 0;
}

Friend class — Doctor / Patient

#include <iostream>
#include <string>
using namespace std;

class Patient {
    string name;
    int hr;
public:
    Patient(string n, int h) : name(n), hr(h) {}
    friend class Doctor;
};

class Doctor {
public:
    void report(const Patient& p) {
        cout << p.name << ": " << p.hr << " bpm\n";
    }
};

int main() {
    Patient p("Neha", 78);
    Doctor().report(p);
    return 0;
}

Friendship is not mutual

#include <iostream>
using namespace std;

class A {
private:
    int x = 1;
public:
    friend class B; // B may access A
};

class B {
private:
    int y = 2;
public:
    void showA(const A& a) { cout << a.x << "\n"; } // OK
    // A cannot access y unless B also declares friend class A;
};

int main() {
    A a; B b;
    b.showA(a);
    return 0;
}

operator<< as friend

#include <iostream>
using namespace std;

class Point {
    int x, y;
public:
    Point(int a, int b) : x(a), y(b) {}
    friend ostream& operator<<(ostream& os, const Point& p);
};

ostream& operator<<(ostream& os, const Point& p) {
    return os << "(" << p.x << "," << p.y << ")";
}

int main() {
    Point p(2, 3);
    cout << p << "\n";
    return 0;
}

Compare — getter vs friend

#include <iostream>
using namespace std;

class Temp {
private:
    int c = 25;
public:
    int getC() const { return c; }
    friend void showFriend(const Temp& t);
};

void showFriend(const Temp& t) { cout << t.c << "\n"; }
void showGetter(const Temp& t) { cout << t.getC() << "\n"; }

int main() {
    Temp t;
    showFriend(t);
    showGetter(t);
    return 0;
}

Binary friend operator+

#include <iostream>
using namespace std;

class Vec2 {
    int x, y;
public:
    Vec2(int a, int b) : x(a), y(b) {}
    friend Vec2 operator+(const Vec2& a, const Vec2& b);
    void show() const { cout << x << "," << y << "\n"; }
};

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

int main() {
    Vec2 u(1, 2), v(3, 4);
    Vec2 w = u + v;
    w.show(); // 4,6
    return 0;
}