operator =



  • gibt es eine moeglich keit den operator= in beide richtungen zu ueberladen?

    momentan bin ich soweit:

    class TBigEn16 { 
            public: 
            Byte Data[2]; 
    
            void operator=(Word Value) 
            { 
                    Data[1]=*(Byte*)&Value; 
                    Data[0]=*((Byte*)(&Value)+1); 
            } 
            void operator=(TBigEn16 Value) 
            { 
                    Data[0]=Value.Data[0]; 
                    Data[1]=Value.Data[1]; 
            } 
    };
    

    damit kann ich einem TBigEn16 ein Word wert zuweisen und einem TBigEn16 einen TBigEn16 zuweisen ... gibt es auch eine moeglickeit einem Word wert einen TBigEn16 zuzuweisen?



  • operator Word() {
    // Hier Code, um nen Word zurückzugeben
    }



  • const bitte!

    Ansonsten, würde ich Konvertierungs-Konstruktoren schreiben, anstelle von Zuweisungsoperatoren. Außerdem sollte ein op= die folgende Deklaration haben:

    T& operator=(const T&);
    


  • interpreter schrieb:

    operator Word() {
    // Hier Code, um nen Word zurückzugeben
    }

    Sowas würd ich mir verdammt gut überlegen. Diese Konvertierungen schlagen immer dann zu, wenn man es am wenigsten erwartet und machen dann aus nem Syntaxfehler nen kompilierbaren Mist.



  • Shlo schrieb:

    const bitte!

    Ansonsten, würde ich Konvertierungs-Konstruktoren schreiben, anstelle von Zuweisungsoperatoren. Außerdem sollte ein op= die folgende Deklaration haben:

    T& operator=(const T&);
    

    was sollte man bei einem operator= denn zurueck geben?

    edit:

    Jester schrieb:

    interpreter schrieb:

    operator Word() {
    // Hier Code, um nen Word zurückzugeben
    }

    Sowas würd ich mir verdammt gut überlegen. Diese Konvertierungen schlagen immer dann zu, wenn man es am wenigsten erwartet und machen dann aus nem Syntaxfehler nen kompilierbaren Mist.

    was meinst du mit kompilierbaren Mist? bzw. wie sollte man es anders/richtig machen
    ich habs mal getestet und es scheint gut zu laufen ...



  • mutzel schrieb:

    was sollte man bei einem operator= denn zurueck geben?

    Das veränderte Objekt.

    Klasse &Klasse::operator= (int neu)
    {
    	Member=neu;
    	return *this;
    }
    

    Du kannst auch einen globalen operator definieren.



  • randa schrieb:

    Du kannst auch einen globalen operator definieren.

    nen globalen zuweisungsoperator? hab ich noch nie gemacht und mein gefühl sagt sogar, das ginge nicht. muß das mal testen, wenn ich wieder am compiler bin.



  • volkard schrieb:

    randa schrieb:

    Du kannst auch einen globalen operator definieren.

    nen globalen zuweisungsoperator? hab ich noch nie gemacht und mein gefühl sagt sogar, das ginge nicht. muß das mal testen, wenn ich wieder am compiler bin.

    Brauchst du nicht: Es geht nicht.



  • mutzel schrieb:

    was meinst du mit kompilierbaren Mist? bzw. wie sollte man es anders/richtig machen

    Mit kompilierbarem Mist meine ich Ausdrücke, die eigentlich keinen Sinn machen, aber auf Grund einer nicht erwünschten impliziten Konvertierung trotzdem gehen.

    Zum Beispiel eine Stringklasse, die automatisch nach char * konvertiert. Das ist enorm praktisch, weil man sich das ständige .c_str() sparen kann.

    Bis man irgendwann aus versehen mal sowas wie delete myString; baut und das Programm irgendwann später verabschiedet. Natürlich ist das ein Programmierfehler den man vermeiden kann (es gibt auch weniger offensichtliche Fälle). Aber ohne die implizite Konvertierung hätte mich der Compiler mit der Nasse draufgestoßen. Das ist auch der Grund warum std::string eine solche Konvertierung nicht besitzt.

    Ich sage ja auch nicht, daß sowas grundsätzlich nicht gemacht werden sollte, man sollte es sich nur gut überlegen. Der Code wird im ersten Moment schön kurz, richtig einfach zu lesen und zu schreiben, aber um so mehr Konvertierungen man einführt, umso mehr Quatsch kann man schreiben.

    ein Container, der implizit nach int konvertiert (Größenangabe) läßt sich so prima mit einem Auto vergleichen, das implizit in seine Geschwindigkeit konvertiert. Nur: Wie aussagekräftig ist dieser Vergleich?



  • nen globalen zuweisungsoperator? hab ich noch nie gemacht und mein gefühl sagt sogar, das ginge nicht. muß das mal testen, wenn ich wieder am compiler bin.

    operator= muss ein Member sein, das gilt aber nicht für operator+= und co.



  • volkard schrieb:

    nen globalen zuweisungsoperator? hab ich noch nie gemacht und mein gefühl sagt sogar, das ginge nicht. muß das mal testen, wenn ich wieder am compiler bin.

    Oh, sorry, ich vergaß. Stimmt, operator= müssen Member sein. Andere Operatoren können global sein.



  • randa schrieb:

    Oh, sorry, ich vergaß. Stimmt, operator= müssen Member sein. Andere Operatoren können global sein.

    Nein, können nicht. op=, (), [], -> und der Konvertierungsoperator müssen non-static sein.


Log in to reply