#ifndef FOO_H
#define FOO_H
#include <iostream>

class Foo {
public:
	Foo (int pA, int pB)
		: a(pA), b(pB) { }

	void anzeigen () {
		std::cout << "a: " << this->a << std::endl;
		std::cout << "b: " << this->b << std::endl;		
	}

	Foo& zuweisen(Foo f) {  // Funktioniert mit Referenz und ohne als Rückgabe
		this->a = f.a;
		this->b = f.b;
		return *this;
	}

private:
	int a;
	int b;
};

#endif
[code="cpp"]

Hallo, wo genau liegt der unterschied zwischen einer normalen Rückgabe und einer als Referenz?

Beim einen wird kopiert, beim anderen eine Referenz zurück gegeben. Weißt du, was Referenzen sind? Falls ja, beantwortet sich die Frage doch von alleine. Falls nein, dann solltest du das vielleicht erst einmal lernen, denn dadurch würde sich, wie gesagt, die Frage von selbst beantworten.

Wo sind die Gefahren?

Klingt mir stark nach Hausaufgabe. Trotzdem der Hinweis: Eine Referenz muss sich auf irgendwas beziehen. Bezieht sie sich auf ein funktionslokales Objekt, dann würde dies nach Beenden der Funktion (aka nach der Rückgabe) bekannterweise nicht mehr existieren. Mit sehr unangenehmen Konsequenzen, wenn man sich dennoch darauf bezieht.

Entschuldigung wenn ich nerve, aber ich habe das leider immer noch nicht so ganz verstanden. Eine Referenz (so habe ich es gelernt) ist ja ein Alias-Name für etwas also z.B sowas :

int a = 10;
	int& b = a;
	b = 20;			// => a = 20

Referenzen als Parameter habe ich auch schon verstanden (mit Auswirkung auf was Original und keine Kopie). Aber leider hakt es bei der Rückgabe .

*this ist ja das Objekt, für das die Methode aufgerufen wurde, also wird ein Alias-Name auf das aktuelle Objekt zurück gegeben? Ich verstehe meinen eigenen Satz nicht

int number = 10;
int* const pseudo_reference = &number; // Bedenke: int* const != const int* == int const*
*pseudo_reference = 5; // (number == 5) == true
int other_number;
pseudo_reference = &other_number; // nicht möglich, da Zeiger konstant
// das eine ist ein konstanter Zeiger (der nicht mehr geändert werden kann), das andere sind änderbare Zeiger auf konstante Objekte

Referenzen haben die selbe Semantik, nur eine schönere Syntax, da keine * und & benötigt werden. Du kannst ihnen nur bei ihrer Definition zuweisen, worauf sie verweisen. Wenn das Objekt, auf das sie zeigen zerstört wird, wird die Referenz/der Zeiger unweigerlich ungültig (auch wenn er/sie selbst noch existiert), aber nutzlos, da du ihn nicht ändern kannst. Deshalb sollte man solche Situationen vermeiden.

So, in diesem Lichte kannst du jetzt noch mal versuchen, dir die Rückgabe einer Referenz zu erklären und warum das u.U. zu undefiniertem Verhalten führen kann.

return *this;

also immer?

(Bevor ich darüber aufgeklärt werde: Nein, ich meinte nicht bei was krankhaftem wie

delete this;
return *this;//klappt bei mir

oder

reinterpret_cast<Foo*>(main)->zuweisen(reinterpret_cast<Foo*>(main));//klappt bei mir

)