Concepts of friend function

📖 Theory

The auditor's problem

The college sends an auditor to verify the canteen's books. The till's cash is private, exactly as it should be.

But the auditor is not a member function of CanteenTill: audits must stay outside the class they inspect, or the inspection means nothing.

So the question: how does an outside function read cash without making cash public for the whole world? C++ answers with a keyword that sounds friendly and behaves like a signed gate pass: friend.

📖 Theory

The gate pass

The owner writes a note and pins it inside the office: "The auditor Mr. Desai may open the cash drawer."

Note three things: the owner issued the pass (not the auditor demanding one), the pass names one person (not all visitors), and Mr. Desai still works outside the canteen: the pass does not make him staff.

That is a friend declaration: access granted by the class, to a named outsider, who stays an outsider.

📖 Theory

Friend function, formally

A friend function is a non-member function that a class authorizes to access its private and protected members.

• Declared inside the class with the friend keyword.
• Defined outside like a normal function: no ClassName:: prefix, no friend keyword at the definition.
• Not called with the dot operator: it takes the object as a parameter and reaches inside it.

The declaration may sit in the public or private section; its position changes nothing.

⌨️ Practical

The audit gate pass in code

#include <iostream>
using namespace std;

class CanteenTill {
private:
    double cash;
public:
    CanteenTill(double opening) { cash = opening; }

    // the gate pass: audit() may read private members
    friend void audit(CanteenTill t);
};

// defined outside: no CanteenTill::, no friend keyword here
void audit(CanteenTill t) {
    cout << "Audited balance: " << t.cash << endl;  // legal: friend
}

int main() {
    CanteenTill till(500.0);
    audit(till);          // ordinary call, NOT till.audit()
    return 0;
}

💭 Think first

Member or not?

The declaration friend void audit(CanteenTill t); sits INSIDE the class body. Before tapping: is audit() a member function of CanteenTill? And how would main() call it: audit(till) or till.audit()?

🧩 Quiz

audit() is a friend of CanteenTill. StaffTill is derived from CanteenTill. Can audit() access StaffTill's own private members?

1. No: friendship is not inherited by derived classes
2. Yes: friends of the base are friends of every child
3. Yes, but only the protected members
4. Only if StaffTill is in the same file

⚠️ Watch out

Handle with care

Every friend function is a small hole drilled through encapsulation. Exams expect you to say so: "friend functions should be used sparingly because they bypass data hiding."

Also be precise in definitions: friendship is granted by the class in its own body. A function cannot declare itself a friend from outside, otherwise private would mean nothing.

📖 Theory

When a friend is the right tool

The honest use case: an operation that needs the private data of two different classes at once, like comparing a CanteenTill's cash with a BankRecord's entry. Neither class is the natural home for that function, so both declare it a friend. Operator overloading also leans on friends (letting cout << till read private members). One function, two gate passes: perfectly legal.

✅ Summary

Key takeaways

• A friend function is a NON-member granted access to private/protected members.
• Declared inside the class with friend; defined outside with no :: and no friend keyword.
• Called like an ordinary function with the object as a parameter, never with the dot.
• Friendship is granted by the class; it is not inherited, not mutual, not transitive.
• Use sparingly: each friend bypasses data hiding.
• Classic use: one function needing privates of two classes; operator overloading.
• Memory hook: a gate pass, not a staff badge.