frage zu this



  • hallo,

    habe folgenden code:

    String& String::operator=(const String &s)
    {
    	return (*this);
    }
    

    das ist jetzt relativ witzlos.....ich weiss.

    mir gehts aber auch nur um das this.

    warum braucht man hier das sternchen? Bei normalen zeigern sagen wir ja mit dem sternchen das wir den wert aus der speicheraddresse auslesen wollen.

    z.B.:

    int i=5;
    
    int *ip;
    
    ip=&i;
    
    cout<<*ip;      //gibt 5 aus
    

    warum können wir dann nicht einfach nur this schreiben anstatt *this?

    ist das hier also was ganz anderes? Dann wird das vermutlich mit arrays und c-strings genauso sein,oder?

    tut mir wirklich sehr leid das ich so blöd fragen stelle, aber ich raffe es einfach nicht. und meine bücher und google bringen mich irgendwie auch nicht weiter.



  • Weil this ein Zeiger ist, der Rückgabetyp deiner Funktion aber eine Referenz desselben Typen.



  • this beinhaltet nur die adresse von deinem objekt, *this ist das objekt selbst



  • Du hast ja als Rückgabetyp eine Referenz auf String und nicht eine Referenz auf nen Zeiger auf String. Daher dereferenzierst du deinen this Zeiger der auf den String zeigt, nun haste den String selber und auf den verweist dann deine Referenz.

    Lg freeG



  • Referenzen werden mit lvalues initialisiert.



  • Nein.
    Referenzen können auch mit Rvalues initialisiert werden, nur binden sie dann das Rvalue nicht direkt und müssen konstant sein. Eventuell wird ein temporäres Objekt erzeugt, das aber selbst nicht konstant sein muss, und auf das die Referenz zeigt - Das ist aber von der Implementierung abhängig.

    Beispiel:

    int i = 42;
    int& ri = i; //OK, Lvalue-Ausdruck auf rechter Seite
    const int& cri = 42; //OK! Rechte Seite ist ein Rvalue: Ein temporäres Objekt vom Typ const int (!) wird erzeugt.
    
    struct Foo {
      Foo& get () { return this; }
      void bar () { }
    };
    
    Foo& foo = Foo(); //Falsch, nur konstante Referenzen können mit einem Rvalue initialisiert werden
    Foo const& cfoo = Foo(); //OK! Rechte Seite ist ein Rvalue: Ein temporäres Objekt vom Typ Foo (!) wird erzeugt.
    Foo& funny_foo = Foo().get(); //OK, da das temporäre Objekt ja nicht konstant ist
    funny_foo.bar(); //Falsch! Das temporäre Objekt ist schon wieder zerstört, da der volle Ausdruck, in dem
    //es erzeugt wurde (s.o.) bereits vorbei ist.
    cfoo.bar(); //OK! Eine konstante Referenz wurde mit dem temporären Objekt initialisiert
    //Das bewirkt, dass das temporäre am Leben bleibt.
    

    Aber das hat sowieso nichts mit der Frage des OPs zu tun. Nur zum Spaß könnte er auch schreiben:

    struct String {
       void fun () {
          String*const& fun = this;
       }
    }
    


  • Hier noch ne kleine Anmerkung, die vll den TE interessieren könnte, damit er auch weiß warum man rvalues und objekte von anderen typen nur an const referenzen binden kann.

    double d = 3.45;
    int const& rd = d;    // Ok, es wird ein temporäres int Objekt erstellt, auf das dann die Referenz verweist also wird daraus:
    
    int temp = d;
    int const& rd = temp; // Wäre es jedoch eine nicht konstante Referenz, könnte sie nun den Wert des Objekts auf das sie zeigt ändern, allerdings
                          //ist das ja nur das Temp-Objekt und Programmierer können denken, das eigentliche Objekt würde geändert werden, was ja nicht der Fall ist,
                          //daher is es nur für const Referenzen erlaubt.
    

    Lg freeG



  • super klasse!

    vielen dank für die hilfe!

    bin echt begeistert von diesem forum! soviel hilfe auf einmal! echt top!



  • Zu der ganzen Referenzbindungsgeschichte noch folgendes:

    http://herbsutter.com/2008/01/01/gotw-88-a-candidate-for-the-most-important-const/

    Frage: hat einer ne Ahnung welches der vielen möglichen #defines und compilerflags beim MSVC die Warnung ausschaltet, wenn die Extension für "reference-to-non-const-boun-to-temporary" zuschlägt?

    int foo()
    {
      return 5;
    }
    
    int main()
    {
      int const& ri = foo(); //OK
      int & ri2 = foo(); //kein Standard-C++, aber MSVC-Extension!
    }
    


  • pumuckl schrieb:

    Frage: hat einer ne Ahnung welches der vielen möglichen #defines und compilerflags beim MSVC die Warnung ausschaltet, wenn die Extension für "reference-to-non-const-boun-to-temporary" zuschlägt?

    Ich würde es mal mit #pragma warning versuchen.


Log in to reply