Element-, Freund- oder globale Funktionen

     

Außer bei virtuellen Funktionen, die immer Elementfunktionen sein müssen, ist die Entscheidung oft nicht leicht.  

Im Zweifelsfall: Benutze OO-Stil Elementfunktionen.

Aber:

    class bruch
    { int zaehler;
      int nenner; 
      public:
      bruch (int z = 0, int n = 1);
      int zae() { return zaehler;}
      int nen() { return nenner;}
      bruch operator* (const bruch& b);
    };
    ...
    bruch viertel(1,4);
    bruch achtel(1,8);
    bruch result = viertel * achtel; // OK
    result = result * 5; // OK
    result = 2 * achtel; // FEHLER !

Der linke (implizite) Operand muß vom Typ bruch sein.

Also: Nicht-Element-Funktion:

    bruch operator* ( const bruch& b1,
                       const bruch& b2)
    { return bruch(b1.zae() * b2.zae(),
                   b1.nen() * b2.nen());
    }

So funktioniert auch result = 2 * achtel.

Sollte operator* Freund der Klasse sein?

In unserem Fall: nein, da Zugriffsfunktionen (inline) auf die nicht-öffentlichen Datenelemente existieren.

Aber häufig ist es nötig:

    class string
    { ...
      ostream& operator<<(ostream& o);
    };
    ...
    string s;
    s << cout;

Das ist legal, entspricht aber nicht den Konventionen!

Globale Freund-Funktion.