Operator überlagern

martin_zi

Hallo

Welche möglichkeiten habe ich bei C++ operatoren zu überlagern ?
Ich habe zwar einiges gelesen komme aber irgendwie nicht ganz
damit klar.

Beipiel ich will einer Klasse dem << operator überlagern
damit ich mit cout leicht etwas auf die console schreiben kann.
Aber wie mache ich das ?

Für + mache ich das so:

class MyClass 
  private:
     int zahl;
  public:
    int GetZahl()
    {
       return zahl;
    };
    MyClass(int z)
    {
       zahl = z;
    };
    MyClass operator+(MyClass myClass)
    {
       return MyClass(zahl+ myClass.GetZahl());
    };
};

Wie arbeite ich mit dem << operator ? was gebe ich da zurück ?

Noch was kann ich den operator auch so überlagern dass ich z.b
sowas machen kann ?

MyClass myClass(4);
int x = 5;
int y = x+ myClass;

mfg
Martin

Braunstein

Hallo,

Die Signator des operator<< sollte so aussehen

ostream& operator<<(ostream& out, const MyClass& value)

Der Operator wird dann als freie Funktion angelegt.

Für dein Additionsproblem gibt es 2 Möglichkeiten.
1. Du erzeugst die einen Konvertierungsoperator zu int, so dass bei dieser Operation implizit konvertiert werden kann.
Die Lösung mag ich nicht sonderlich, da solche Konvertierungsoperatoren dir schwer zu findene Fehler produzieren können.
2. Du schreibst dir einen operator+ als freie Funktion.

int operator+(int lhs, const MyClass& rhs)

martin_zi

Hi

Zuerstmal zum ersten:

class MyClass
  private:
     int zahl;
  public:
    int GetZahl()
    {
       return zahl;
    };
    MyClass(int z)
    {
       zahl = z;
    };
    MyClass operator+(MyClass myClass)
    {
       return MyClass(zahl+ myClass.GetZahl());
    };
    ostream& operator<<(ostream& out, const MyClass& value)
    {
        out << r;
        return out;
    };

Wenn ich meine Klasse erweiter .. dann erhalte ich aber folgende Fehlermeldung.
std::ostream& MyClass::operator<<(std::ostream&, const MyClass&)' must take exactly one argument

Was für mich heißt das ich ein Argument zuvile habe...
Ich kann damit irgendwie nicht viel anfangen...
auch bei dem operator+ habe ich in den meisten Beispielen:
Hätte ich was in der Art

MyClass operator+(const MyClass & l, const MyClass & r);

Stehen was der compiler mit der gleichen Fehlemeldung verweigert ...

Was mach ich den falsch ??

mfg
Martin

Braunstein

Ich hatte oben schon geschrieben, das das freie Funktionen sein müssen. D.h. du mußt die Deklaration außerhalb der Klasse machen.

class MyClass
{
  private:
     int zahl;
  public:
...
};

ostream& operator<<(ostream& out, const MyClass& value)
{
    out << r;
    return out;
};

Konrad Rudolph

martin_zi schrieb:

Welche möglichkeiten habe ich bei C++ operatoren zu überlagern ?

Gar keine. "Überlagern" kann man Operatoren nicht, sondern nur überladen.

martin_zi

Hi

@Braunstein:
Achso war das gemeint ok hab ich wohl schlecht gelesen ... thx.

@Konrad Rudolph:

Konrad Rudolph schrieb:

Gar keine. "Überlagern" kann man Operatoren nicht, sondern nur überladen.

Im ernst gut das du das sagst mit dem Begriff "überladen" findet man mehr Infos
und Beispiele

thx

mfg
Martin

Basingstoke

statt:

int operator+(int lhs, const MyClass& rhs)

eher:

operator int()
{
    return zahl;
}

Konrad Rudolph

Basingstoke schrieb:

statt:

int operator+(int lhs, const MyClass& rhs)

eher:

operator int()
{
    return zahl;
}

Ah. Und wenn Du z.B. eine Klasse für komplexe Zahlen schreiben willst? 'MyClass' ist doch nur nen Beispiel.

martin_zi

Hi

Das gibts auch noch Flexibel ...

operator int()
{
    return zahl;
}

Danke für die Info!

mfg
Martin

Basingstoke

@Konrad Rudolph
in etwa so:http://www.wer-weiss-was.de/theme158/article825802.html

CStoll

Ich denke mal, daß Konrad die complex<> kannte. Der Punkt, auf den er (vermutlich) hinauswollte, war: Die Lösung mit dem überladenen operator+ ist vielseitiger einsetzbar als eine Umwandlung nach int (komplexe Zahlen kannst du z.B. nicht sinnvoll in int's umwandeln - also mußt du für die Rechnung den int in eine komplexe Zahl umwandeln).

Konrad Rudolph

Basingstoke schrieb:

@Konrad Rudolph
in etwa so:http://www.wer-weiss-was.de/theme158/article825802.html

Ja, Danke, ich weiß, wie man komplexe Zahlen definiert und dass die c++stdlib bereits eine Implementierung enthält.

Worauf ich hinaus wollte: In einer solchen Klasse nützt Dir 'operator int' allein nicht, da musst Du auch den op+ überladen, um eine sinnvolle Addition hinzubekommen, denn folgende beiden Codes sind eben *nicht* dasselbe.

int i = 1;
complex c(0, 1);

i + c; // == (1, 1)
i + int(c) // == 1

martin_zi

Hallo nochmal.

Ich hab nochmal eine Frage.
Ich habe bemerkt das bei meine Beispiel zwar:

MyClass myClass1;
MyClass myClass2;
MyClass myClass3 = myClass1 + myClass2;

Möglich ist. Ok der operator+ liefert ja auf MyClass zurück.

Aber das z.B.:

MyClass myClass1;
MyClass myClass2;
MyClass myClass3;
MyClass myClass4 = myClass1 + myClass2 + myClass3 ;

funktioniert nicht. Wenn ich Klammern setzte geht es aber ohne nicht.
Was kann ich machen das es auch mit 3 fnktioniert ?

mfg
Martin

Konrad Rudolph

martin_zi schrieb:

funktioniert nicht. Wenn ich Klammern setzte geht es aber ohne nicht.

Hmm? Wie sieht denn Deine Signatur aus? Die Signatur sollte eigentlich immer folgendermaßen aussehen:

T operator +(T const&, T const&);

Genaugenommen sollte der operator+ immer so implementiert sein, es sei denn, gute Gründe sprechen dagegen:

T operator +(T const& lhs, T const& rhs)
{
    T ret = lhs;        // lhs wird kopiert (copycon)
    return ret += rhs;  // Addition (operator +=)
}

martin_zi

Hi

Ich habe es so wie in meinem Beispiel am anfang:

class MyClass
  private:
     int zahl;
  public:
    int GetZahl()
    {
       return zahl;
    };
    MyClass(int z)
    {
       zahl = z;
    };
    MyClass operator+(MyClass myClass)
    {
       return MyClass(zahl+ myClass.GetZahl());
    };
};

geht das so nicht ?

mfg
Martin

martin_zi

Hey

Sorry geht doch ...
War noch was anderes ...
Tja bei der Hitze ...

mfg
Martin