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.

Lg freeG

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

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

vielen dank für die hilfe!

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

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!
}

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.