I'm currently getting through the http://www.cplusplus.com tutorial and I came across this section here: http://www.cplusplus.com/doc/tutorial/inheritance.html that deals with the subject of friend functions and friend classes in C++.
My question is, when When is it prudent to use friendship when creating a program?
The only clue I got was in an example inside of the article that demonstrated a friend function that 'duplicated' an object.
There are some really good rules of thumb for this in Marshall Cline's C++ FAQ Lite.
The whole thing is good but see, in particular, "Do friends violate encapsulation?" for examples of the right way to use them and when it's best to split classes and declare them friends.
Friend functions exist in order to present free functions as a contiguous part of the class interface. There are a few places where free functions are part of a class interface. Example: Suppose you have an arbitrary-precision class BigNum. Here are some obvious candidates for friend functions:
// binary operators where BigNum isn't the left-hand operand
BigNum operator+ (int, BigNum);
BigNum operator- (int, BigNum);
// stream operators
std::ostream &operator<< (std::ostream &os, const BigNum &num);
std::istream &operator>> (std::istream &is, BigNum &num);
Now, given those two examples, in many cases the binary operators don't need to be friends (e.g. I can implement int + BigNum by delegating to BigNum + int, which is a member function and thus already has full access). But it all depends on what your needs are for performance, and what you are willing to expose through the class's public member functions.
One good application for friend classes is the Memento design pattern.
As friends generally violate the data-hiding mechanisms, they have to be used only when really needed. If your design relies heavily on friends, it's probably wrong in some way.
An example of when you can't do without friends is overriding the << and >> stream operators. Also, friend classes are often used in the implementation of some design patterns - "Iterator" comes to mind.
I only used friend methods and properties for use within the class itself for clone itself or assigning another object to itself. That was largely superseded we refactored the design to implement of the Memento Design pattern in our design.
The Memento is created by the same mechanisms used to save and load the object. i.e. the Memento creates a stream, the object writes to it, and the memento can be passed to any other object of the same class to make it an exact duplicate of the object creating the memento.
Sometimes there are cases when objects need to work really close together in which case I simplify their interaction by aggregating them behind another object. Variables that would be "friend" variables and only visible to the other objects are private to the class doing the aggregating.