Friend Functions in C++ Explained — Access, Use Cases and Pitfalls

#include <iostream>
#include <string>

class BankAccount {
private:
    std::string ownerName;   // private — not accessible outside the class
    double balance;          // private — same
    int accountNumber;

public:
    BankAccount(std::string name, int accNum, double initialBalance)
        : ownerName(name), accountNumber(accNum), balance(initialBalance) {}

    // Declare operator<< as a friend.
    // This gives the FREE FUNCTION access to private members.
    // Note: the declaration lives INSIDE the class, but the function is NOT a member.
    friend std::ostream& operator<<(std::ostream& outputStream, const BankAccount& account);
};

// Definition lives OUTSIDE the class — no BankAccount:: prefix.
// But it can still read ownerName, balance, and accountNumber directly.
std::ostream& operator<<(std::ostream& outputStream, const BankAccount& account) {
    outputStream << "Account #" << account.accountNumber    // direct private access
                 << " | Owner: " << account.ownerName      // direct private access
                 << " | Balance: $" << account.balance;    // direct private access
    return outputStream; // always return the stream to allow chaining (cout << a << b)
}

int main() {
    BankAccount savings("Alice Nguyen", 100423, 4750.00);
    BankAccount checking("Alice Nguyen", 100424, 820.50);

    // operator<< works cleanly — no getters, no public fields
    std::cout << savings << std::endl;
    std::cout << checking << std::endl;

    return 0;
}

#include <iostream>

// Forward declaration needed because CelsiusTemp and FahrenheitTemp reference each other.
class FahrenheitTemp;

class CelsiusTemp {
private:
    double degrees; // stored in Celsius internally

public:
    explicit CelsiusTemp(double deg) : degrees(deg) {}

    // Grant the conversion function access to both classes' private data.
    // We forward-declare FahrenheitTemp above so the compiler knows it exists here.
    friend double convertAndCompare(const CelsiusTemp& c, const FahrenheitTemp& f);
};

class FahrenheitTemp {
private:
    double degrees; // stored in Fahrenheit internally

public:
    explicit FahrenheitTemp(double deg) : degrees(deg) {}

    // Same friend declaration in FahrenheitTemp — BOTH classes must opt in.
    // This is what "friendship is not symmetric" means in practice.
    friend double convertAndCompare(const CelsiusTemp& c, const FahrenheitTemp& f);
};

// The friend function definition — accesses private 'degrees' from BOTH classes.
// No :: prefix, no 'friend' keyword here, just a normal function definition.
double convertAndCompare(const CelsiusTemp& celsius, const FahrenheitTemp& fahrenheit) {
    double celsiusInFahrenheit = (celsius.degrees * 9.0 / 5.0) + 32.0; // direct private access
    double difference = celsiusInFahrenheit - fahrenheit.degrees;       // direct private access
    return difference;
}

int main() {
    CelsiusTemp bodyTemp(37.0);       // normal human body temperature
    FahrenheitTemp roomTemp(72.0);    // comfortable room temperature

    double diff = convertAndCompare(bodyTemp, roomTemp);

    std::cout << "Body temp in Fahrenheit: " << (37.0 * 9.0/5.0 + 32.0) << "F" << std::endl;
    std::cout << "Room temp: 72F" << std::endl;
    std::cout << "Difference: " << diff << " degrees Fahrenheit" << std::endl;

    return 0;
}

#include <iostream>
#include <string>

class Playlist; // forward declaration so Iterator can reference it

// Iterator needs deep access to Playlist internals — friend class is appropriate here.
class PlaylistIterator {
private:
    const Playlist* playlist; // pointer to the playlist we're iterating
    int currentIndex;

public:
    PlaylistIterator(const Playlist* pl, int startIndex)
        : playlist(pl), currentIndex(startIndex) {}

    bool hasNext() const;
    std::string next();
};

class Playlist {
private:
    std::string tracks[5]; // fixed-size internal storage, intentionally private
    int trackCount;

public:
    Playlist() : trackCount(0) {}

    void addTrack(const std::string& title) {
        if (trackCount < 5) {
            tracks[trackCount++] = title;
        }
    }

    PlaylistIterator begin() const {
        return PlaylistIterator(this, 0); // iterator starts at index 0
    }

    // Grant PlaylistIterator access to private 'tracks' array and 'trackCount'.
    // Without this, hasNext() and next() below won't compile.
    friend class PlaylistIterator;
};

// Now we can define PlaylistIterator methods that touch Playlist's private members.
bool PlaylistIterator::hasNext() const {
    return currentIndex < playlist->trackCount; // direct access to private trackCount
}

std::string PlaylistIterator::next() {
    return playlist->tracks[currentIndex++]; // direct access to private tracks array
}

int main() {
    Playlist myPlaylist;
    myPlaylist.addTrack("Echoes of Tomorrow");
    myPlaylist.addTrack("Neon Rain");
    myPlaylist.addTrack("Static Horizon");
    myPlaylist.addTrack("Glass Engine");

    std::cout << "Now playing:" << std::endl;

    PlaylistIterator it = myPlaylist.begin();
    while (it.hasNext()) {
        std::cout << "  -> " << it.next() << std::endl;
    }

    return 0;
}

#include <iostream>
#include <cmath>

// A legitimate use case: two tightly coupled math types that operate on each other's
// internal storage for performance. The dot product must see both vectors' raw arrays.

class Vector3D {
private:
    double components[3]; // x, y, z stored as a raw array — private for good reason

public:
    Vector3D(double x, double y, double z) {
        components[0] = x;
        components[1] = y;
        components[2] = z;
    }

    double magnitude() const {
        return std::sqrt(components[0]*components[0]
                       + components[1]*components[1]
                       + components[2]*components[2]);
    }

    // Friend declaration: dotProduct needs raw array access on TWO Vector3D objects.
    // Using getX(), getY(), getZ() would work but adds three function calls per vector.
    // For hot-path math code, direct array access via friend is a justified optimization.
    friend double dotProduct(const Vector3D& vectorA, const Vector3D& vectorB);
    friend Vector3D crossProduct(const Vector3D& vectorA, const Vector3D& vectorB);
};

double dotProduct(const Vector3D& vectorA, const Vector3D& vectorB) {
    // a.x*b.x + a.y*b.y + a.z*b.z — direct access to private components[] on both
    return vectorA.components[0] * vectorB.components[0]
         + vectorA.components[1] * vectorB.components[1]
         + vectorA.components[2] * vectorB.components[2];
}

Vector3D crossProduct(const Vector3D& vectorA, const Vector3D& vectorB) {
    // Cross product formula — again, direct raw array access on both vectors
    return Vector3D(
        vectorA.components[1] * vectorB.components[2] - vectorA.components[2] * vectorB.components[1],
        vectorA.components[2] * vectorB.components[0] - vectorA.components[0] * vectorB.components[2],
        vectorA.components[0] * vectorB.components[1] - vectorA.components[1] * vectorB.components[0]
    );
}

int main() {
    Vector3D forwardDirection(1.0, 0.0, 0.0);
    Vector3D upDirection(0.0, 1.0, 0.0);

    double dot = dotProduct(forwardDirection, upDirection);
    Vector3D rightDirection = crossProduct(forwardDirection, upDirection);

    std::cout << "Dot product (forward . up): " << dot << std::endl;
    std::cout << "Cross product magnitude (should be 1.0): "
              << rightDirection.magnitude() << std::endl;

    return 0;
}