Зачем нужны дружественные функции

#include <iostream>
 
using namespace std;
 
class SomeClass
{
  private:
    int itsVal;
    friend void SetVal(int value, SomeClass &theClass) {theClass.itsVal = value;}
    friend void GetVal(SomeClass &theClass) {cout << theClass.itsVal << "\n";}
  public:
    SomeClass(): itsVal(96) {}
    void Show() const {cout << itsVal << "\n";}
};
 
 
int main()
{
  SomeClass theClass;
  theClass.Show();
  SetVal(12, theClass);
  GetVal(theClass);
  return 0;
}

void SomeClass::SetVal(int value) {itsVal = value;}

int x = 1;

int x = 1F;

const short* x;

short* const x;

template <class proptype> class property:virtual public Object
        {
            protected:
                boost::shared_ptr<proptype> _value;
                
            public:
 
                property():_value((proptype*)(new proptype()))
                {}
 
                operator proptype()
                {
                    return *_value;
                }
 
                void operator =(proptype data)
                {
                    *_value = data;
                }
 
                void operator =(boost::shared_ptr<proptype> data)
                {
                    *_value = *data;                    
                }
 
                proptype * operator->() const
                {
                    return _value.get();
                }
 
                string ToString() 
                {
                    return boost::lexical_cast<string>(*_value);
                }
 
                ~property()
                {
                    _value.reset();
                }
        };

#include <iostream>
 
using namespace std;
 
class B; 
class A
{
  private:
    int itsVal;
    friend void SetVal(A &, B &, int);
  public:
    A(): itsVal(12) {}
    void Show() const {cout << itsVal << "\n";}
};
 
class B
{
private:
    int itsVal;
    friend void SetVal(A &, B &, int);
  public:
    B(): itsVal(35) {}
    void Show() const {cout << itsVal << "\n";}
};
 
void SetVal(A &a, B &b, int value)
{
  a.itsVal = value;
  b.itsVal = value;
}
 
int main()
{
  A a;
  B b;
  a.Show();
  b.Show();
  SetVal(a, b, 99);
  a.Show();
  b.Show();
  return 0;
}

#define private friend class Descendant; private // приписываем friend class Descendant во все классы
#include <Ancestor.hpp>
#undef private
...
 
Descendant *h = new Descendant();
int x = h->m_value; // m_value в прошлой жизни - private из Ancestor

class a{
public:
    a():a1(2){};~a(){};
    int s() { d = 45;};
private:
    template <typename T> friend int get(T&);
    int a1;
    double d;
};
 
class b{
public:
    b():a1(6){};~b(){};
    int s() {};//{ a1 = 35; return a1; }
    void f(){ int p = 4 + 6; }
private:
    template <typename T> friend int get(T&);
    float b6;
    int a1;
};
 
template <typename T> int get(T&u){
    return u.a1;
}
 
int main(int argc, _TCHAR* argv[])
{
    a k1;b k2;
    do{
        printf( "> " );
        memset( cmd, 0, L_SERVER_CMD );
        scanf( "%s", cmd, sizeof(cmd) );
        if( !strcmp( cmd, "t" ) ){
            printf("\n %d %d\n",get(k1),get(k2));
        }
    }while( strcmp( cmd, "0" ) && strcmp( cmd, "exit" ) );
    return 0;
}

template <typename T> friend int get(T&);

memset( cmd, 0, L_SERVER_CMD );
        scanf( "%s", cmd, sizeof(cmd) );