Friend function - practical use?

Question

Possible Duplicate:
When should you use 'friend' in C++?

There is a detailed explanation here, but I would like to know what is the practical use of Friend function.

How I can decide when I should go with a friend function rather than a member function?

Answer 1

In most cases, friend declarations are a code-smell since it breaks encapsulation.

Developers often use friend for a quick-fix to a problem. However a good starting design or some refactoring (more often more than less) exclude the necessity for it.

EDIT:

Even in @Darhuuk's example, a friend declaration is not needed. You can have getters for the specific fields you want to print.

Answer 2

You would use a friend when the function needs to be a non-member, but also needs access to class members.

Common examples where you need a non-member function are:

• An API that requires non-member functions; for example, boost::intrusive_ptr requires that you implement intrusive_add_ref() and intrusive_release() as non-member functions.
• Overloading a binary operator where your type need to be the right-hand operand; for example operator<<(ostream&, my_type const &).
• Overloading a binary operator where you want the left-hand side to be convertible to your type; for example, if your class is constructible from int, then 5 + my_type will work if you define a non-member operator+(my_type const&, my_type const&);, but not if you define a member my_type::operator+(my_type const &) const;.

Whether any of these needs to be friends depends on whether they can do their job using the class's public interface; for example, you could add a public print(ostream&) member that operator<< could use, and a public operator+= member that operator+ could use.

As an example of implementing operator+ in terms of operator+=:

my_type & my_type::operator+=(my_type const & rhs)
{
    // do addition here
    return *this;
}

// The first operand is passed by value, giving a modifiable copy
my_type operator+(my_type lhs, my_type const & rhs)
{
    return lhs += rhs;
}

Answer 3

The simplest use case would probably be when overloading the stream output operator for a custom class.

For example, take a look at the following code (shamelessly copied from here). In this case the use of friend allows the non-class method to access the private fields of class, thus preventing the need to code several get methods (which otherwise you might not even want to create).

#include <iostream>
#include <cstring>
using namespace std;
class MyClass {
  // now private
  char name[80];
  int areacode;
  int prefix;
  int num;
public:
  MyClass(char *n, int a, int p, int nm)
  {
    strcpy(name, n);
    areacode = a;
    prefix = p;
    num = nm;
  }
  friend ostream &operator<<(ostream &stream, MyClass o);
};

ostream &operator<<(ostream &stream, MyClass o)
{
  stream << o.name << " ";
  stream << "(" << o.areacode << ") ";
  stream << o.prefix << "-" << o.num << "\n";

  return stream;
}

int main() {
  MyClass a("T", 1, 5, 1);
  MyClass b("A", 3, 5, 5);
  MyClass c("T", 2, 5, 9);

  cout << a << b << c;

  return 0;
}