class matrix {
    friend matrix mul(matrix const&, matrix const&);
    friend matrix inv(matrix const&);
    . . .
};

matrix a, b;

. . .

return mul(a, inv(b));

class matrix {
public:
    matrix mul(matrix const&) const;
    matrix inv() const;
    . . .
};

matrix a, b;

. . .

return a.mul(b.inv());

class Parent
{
  friend class Family;
  protected:
    virtual void Answer() = 0;
};

class Child : public Parent
{
  private:
    void Answer() { printf("Child!\n"); }
    int encapsulated;
};

class Family
{
  public:
    void ParentAnswer(Parent *p) { p->Answer(); } /* ok */
    #if 0
      void ChildAnswer(Child *c) { c->Answer(); } /* error! */
      int breakEncapsulation(Child *c) { return c->encapsulated; } /* error again! */
    #endif
};

int test(void)
{
  Child c;
  Family f;
  f.ParentAnswer(&c); /* ok, Child->answer will be called */
  return 0;
}

double x = ...;
Matrix y = .../
auto z = inverse(value);
auto solution = inverse(y) * b;

While we could make a member function to return length, it is better to make it a global friend function. If we do that, we will be able eventually to define the same function to work on built-in arrays and achieve greater uniformity of design. I made size into a member function in STL in an attempt to please the standard committee. I knew that begin, end and size should be global functions but was not willing to risk another fight with the committee. In general, there were many compromises of which I am ashamed. It would have been harder to succeed without making them, but I still get a metallic taste in my mouth when I encounter all the things that I did wrong while knowing full how to do them right.

friend std::size_t size(const fvector_int& x)

friend void some_class::some_method();

class some_class
{
public:
   void print(std::ostream& os) const;
   void read(std::istream& is);
};

std::ostream& operator<<(std::ostream& os, some_class const& obj)
{
   obj.print(os);
   return os;
}

std::istream& operator>>(std::istream& os, some_class& obj)
{
   obj.read(is);
   return is;
}

class some_class
{
public:
    friend std::ostream& operator<<(std::ostream& os, some_class const& obj)
    {
        // реализация print(os);
       return os;
    }

    friend std::istream& operator>>(std::istream& os, some_class& obj)
    {
        // реализация read(is);
        return is;
    }
};

PM>>friend void some_class::some_method();
PM>>

class A;

class B
{
    friend A::A(); // error C2027: use of undefined type 'A'
private:
    B() {}
};

class A
{
    A() {}
    B b;
};

A a;

> throw is a way to put GOTO in your code, the more you see throw or catch , the more your code is full of flaw.

By using your "GOTO" reasoning we can go even further — we can consider harmful even "if" statements. Because at lowest level "if" statement translates into something like:

if(condition) goto label; // jne, brne, etc

So, by using your conclusions: "the more you see if statement, the more your code is full of flaw" — how funny is that?

Moreover, the greatest of us actually claim that there is no syntactic limitations in semantic questions, and goto is useful. Prohibiting it fanatically for all cases is not a good idea.
Alexander Stepanov shows how goto statement can be useful:
http://www.youtube.com/watch?v=mrtaApqAjA8&t=5m38s
http://books.google.com/books?id=CO9ULZGINlsC&lpg=PT209&ots=Ow3EbqSBqA&dq=elements+of+programming+split_linked&hl=en&pg=PT210

E_>Интересует ваше мнение. Друг зло или нет? Как часто вам приходилось им пользоваться?

keyword vector_int
{
    int *first, *last, *last_allocated;
//...
};

friend std::size_t size(const vector_int& x)

class Matrix
{
    vector<Scalar> storage;
    size_t width;
    
    void invariant()
    {
        assert( size(storage) % width == 0  );
    }
// ...
}

Matrix x = ... ;
// ...
x.width = 2;
x.storage.resize(3);

if(condition) goto label; // jne, brne, etc

class foo
{
    friend class foo_traits;
public:
    int bar() const { return bar_; }
private:
    int bar_;
};

class foo_traits
{
    typedef member_order<foo, int, &foo::bar_> foo_bar_order;
};

class ZZZ {
    int bar1;
    int bar2;
    int bar3;
public:
    struct Accessor {
        const int& bar1;
        const int& bar2;
        const int& bar3;
        Accessor( const ZZZ& theThis ) : 
            bar1(theThis.bar1 ), 
            bar2(theThis.bar2 ),  
            bar3(theThis.bar3 ) 
                {}
    };
};

int qqqZZZ( ZZZ& oZzz )
{
    ZZZ::Accessor o( oZzz );
    // o.bar1 = 5; // не скомпилируется!
    return o.bar2;
}

class ZZZ {

class Widget
{
    struct Data
    {
        int foo, bar;
    } data = {0, 1};
public:
    const Data &access() const
    {
        return data;
    }
};
 
int main()
{
    Widget x;
    // ERROR: x.access().bar = 5;
    return x.access().foo;
}

template<typename impl>
class base
{
public:
    void foo() { static_cast<impl&>(*this).bar(); }
};

class impl : public base<impl>
{
    friend class base<impl>;
private:
    void bar() {}
};

class CMyDialog : CDialogImpl<CMyDialog>
{
public:
BOOL Show(HWND Parent);

private:
friend class CDialogImpl<CMyDialog>;
BEGIN_MSG_MAP_EX(CMyDialog)
END_MSG_MAP()
};

class foo
{
private:
    friend void intrusive_ptr_add_ref(foo* obj) {}
    friend void intrusive_ptr_release(foo* obj) {}
};