Operatoren in Klassen verwenden

m0rph3uz

wie kann ich eine Funktion schreiben, die mir mit hilfe des << operators ein Element in meiner Klasse ausgibt?

hab schon mal mit anderen operatoren programmiert und da ist alles halbwegs zu verstehen!
könnte das so in die richtung ausshen?:

const char * operator << (const Myclass& element);

elise

ausgeben heißt für mich, in den stream "reinschieben"..

dann würde ich folgendes machen: extractor und inserter

ostream &  operator<< (ostream &stream, const Test &t){
    stream<<t.vari1<<" ";
    stream<< t.vari2<<" ";
    return stream;
}

istream & operator>> (istream & stream, Test  &t){
    cout<<"Variable 1: ";
    stream >>t.vari1;
    cout<<"Variable 2: ";
    stream >>t.vari2;
    return stream;
}

später befreunde sie mit deiner klasse Test.

m0rph3uz

danke vorerst!

aber wäre es da nicht überflüssig das objekt zu übergeben?
da es ja eine methode der klasse ist!

m0rph3uz

jetzt hätt ich noch eine frage:

ich hab eine Funktion geschrieben, mit der ich integer zahlen zu meinem element zuzählen kann:

elem1 = elem2 + 5;

die funktion wird so weit ich weis von elem2 aufgerufen und ich gebe das ergebnis als returnwert ... den rest macht der standard copy konstruktor.

wie funktioniert das jetzt, wenn ich zu einer integer ein element dazuzählen will?:

elem1 = 5 + elem2;

da müsste die funktion doch von 5 aufgerufen werden??
meine funktion sieht so aus:

const myclass& operator + (int Zahl);

und wie geht das, wenn ich mehrere elemente zusammenzählen will:

elem1 = elem2 + 5 + elem3;

elise

die stream << überladung ist keine methode der klasse.

üblicherweise macht man sie außerhalb und befreundet sie nur.

Bashar

Der Insertion-Operator kann nur auf 2 Arten implementiert werden, entweder als freie Funktion mit einem ostream als erstem Argument, oder als Memberfunktion in der Klasse ostream. Da ostream eine Klasse der Standardbibliothek ist, fällt letzteres offensichtlich aus. Der Grund liegt darin, dass das ja nur syntaktisch ein Operator ist, semantisch aber eine Funktion, der Compiler kann stream << data also nur in eine dieser 2 Formen umschreiben:

// Interne Umformung von stream << data:
// a) wenn es eine Memberfunktion ist
stream.operator<<(data)
// b) als freie Funktion
operator<<(stream, data)

Eine Zwischenmöglichkeit, sieht so aus:

class MyClass {
  ...
  void print(ostream&) const;
};
ostream& operator<<(ostream& os, MyClass const& obj) {
  obj.print(os);
  return os;
}

Dann kann man print auch virtuell machen, wenn das gewünscht ist. friend-Funktionen gehören aber eigentlich genauso zur Klasse wie Memberfunktionen, also sollte man diese Umformung nicht zwanghaft durchführen.

Bashar

m0rph3uz schrieb:

const myclass& operator + (int Zahl);

operator+ sollte als freie Funktion implementiert werden. Am besten mit Hilfe des operator+=, welcher eine Memberfunktion sein sollte (oder muß?):

class MyClass {
  ...
  MyClass& operator+=(MyClass const& rhs) {
    ...
    return *this;
  }
};
MyClass operator+(MyClass const& lhs, MyClass const& rhs) {
  MyClass temp(lhs);
  temp += rhs;
  return temp;
}

EDIT: Wenn du ints aufaddieren willst, gilt ähnliches. Ausserdem wär ein Umwandlungskonstruktor (der int als Argument annimmt) nicht falsch.