Where would you use a friend function vs. a static member function?

Question

We make a non-member function a friend of a class when we want it to access that class\'s private members. This gives it the same access rights as a static member function w

Answer 1

Section 11.5 "The C++ Programming Language" by Bjarne Stroustrup states that ordinary member functions get 3 things:

1. access to internals of class
2. are in the scope of the class
3. must be invoked on an instance

friends get only 1.

static functions get 1 and 2.

Answer 2

• One reason to prefer a friend over static member is when the function needs to be written in assembly (or some other language).

  For instance, we can always have an extern "C" friend function declared in our .cpp file

  class Thread;
  extern "C" int ContextSwitch(Thread & a, Thread & b);
  
  class Thread
  {
  public:
      friend int ContextSwitch(Thread & a, Thread & b);
      static int StContextSwitch(Thread & a, Thread & b);
  };
  

  And later defined in assembly:

                  .global ContextSwitch
  
  ContextSwitch:  // ...
                  retq
  

  Technically speaking, we could use a static member function to do this, but defining it in assembly won't be easy due to name mangling (http://en.wikipedia.org/wiki/Name_mangling)

• Another situation is when you need to overload operators. Overloading operators can be done only through friends or non-static members. If the first argument of the operator is not an instance of the same class, then non-static member would also not work; friend would be the only option:

  class Matrix
  {
      friend Matrix operator * (double scaleFactor, Matrix & m);
      // We can't use static member or non-static member to do this
  };
  

Answer 3

Static function can be used in many different ways.

For example as simple factory function:

  class Abstract {
  private:
    // no explicit construction allowed
    Abstract(); 
    ~Abstract();

   public:
     static Abstract* Construct() { return new Abstract; }
     static void Destroy(Abstract* a) { delete a; }
   };

   ...
   A* a_instance = A::Conctruct();
   ...
   A::Destroy(a_instance);

This is very simplified example but I hope it explains what I meant.

Or as thread function working with Your class:

 class A {

 public:
    static void worker(void* p) {
            A* a = dynamic_cast<A*>(p);
            do something wit a;
    }   
 } 

 A a_instance;
 pthread_start(&thread_id, &A::worker, &a_instance);
 .... 

Friend is completely different story and they usage is exactly as described by thebretness

Answer 4

The difference is clearly expressing the intent of the relationship between the class and the function.

You use friend when you want to intentionally indicate a strong coupling and special relationship between two unrelated classes or between a class and a function.

You use static member function when the function is logically a part of the class to which it is a member.

Answer 5

Friend functions (and classes) can access the private and protected members of your class. There's rarely a good case for using a friend function or class. Avoid them in general.

Static functions may only access static data (that is, class-scoped data). They may be called without creating an instance of your class. Static functions are great for circumstances you want all of the instances of your class to behave the same way. You can use them: