Operator überlagern



  • 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



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


  • martin_zi schrieb:

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

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



  • 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



  • statt:

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

    eher:

    operator int()
    {
        return zahl;
    }
    


  • 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.



  • Hi

    Das gibts auch noch 😃 Flexibel ...

    operator int()
    {
        return zahl;
    }
    

    Danke für die Info! 🙂

    mfg
    Martin





  • 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).



  • 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
    


  • 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



  • 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 +=)
    }
    


  • 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



  • Hey

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

    mfg
    Martin


Anmelden zum Antworten