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;
    }
};

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;
}

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;

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());

> 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

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)

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