Beispiel:

class complex: {
  public:
    complex(double r, double i) { re =r; im = i; }
    double real() { return re; };                     // <= neu
    double imag() { return im; };                     // <= neu
  private:
    doube re, im;
  };

  ostream &operator<<(ostream& o, const complex& c) {
    return o << c.real() << " " << c.imag();          // <= neu: real() +
imag()
  }

ODER

class complex: {
 friend ostream &operator<<(ostream& o, const complex& c) {
    return o << c.re << " " << c.im;          
imag()
  public:
    complex(double r, double i) { re =r; im = i; }
    double real() { return re; };                     // <= neu
    double imag() { return im; };                     // <= neu
  private:
    doube re, im;
  };

Bitte Vorteile und Nachteile enumerieren!

Danke Carmen

}

Der Ausgabeoperator muss eine globale Funktion (und keine Methode) sein, sonst könnte man nicht "cout << c;" schreiben.

Der Ausgabeoperator oben funktioniert aber nicht!!
Weil der Ausgabeoperator eine globale Funktion ist, darf er nicht auf die privaten Datenelemente (re, im) zugreifen.

Lösung 1: Man deklariert in der Klasse den Ausgabeoperator als "friend"
dann darf er auf die privaten Datenelemente (re, im) zugreifen

Lösung 2: Man gibt der Klasse Zugriffsfunktionen wie "real()" oder "imag()"
also

class Test
{
  int value;
public:
  Test(int v=0) : value(v) {}
  void print(ostream&) const;
};

ostream& operator<<(ostream& out,const test& data)
{
  data.print(out);
  return out;
}

void Test::print(ostream out)
{
  out<<"Klasse Test: "<<value<<endl;
}

PS Ich versuche jetzt ein Smilie einzufügen(Ob es klappt sehen wir gleich)

(und außerdem kannst du auf diese Weise auch eine Vererbungshierarchie handhaben - du mußt nur die print()-Methode virtuell deklarieren und jede von "Test" abgeleitete Klasse kann selbst entscheiden, wie sie ausgegeben werden will)