Warum muss man += extra überladen?

class foo{
public:
	int i;
};

foo& operator+(foo& f1, const foo& f2){
	f1.i+=f2.i;
	return f1;
}

int main(int argc, char** argv) {

	foo f1,f2;
	f1.i=8;
	f2.i=1;
	f1=f1+f2;
	f1+=f2;

	std::cout<<f1.i;

	return 0;
}

Wenn man + überläd müsste += doch automatisch überladen sein. x+=y ist doch nur die Kurzschreibweise für x=x+y. Warum muss man += trotzdem nochmal überladen?

asc

überlader schrieb:

Wenn man + überläd müsste += doch automatisch überladen sein. x+=y ist doch nur die Kurzschreibweise für x=x+y. Warum muss man += trotzdem nochmal überladen?

Nein, das ist ein Trugschluß (es wird zwar in anderen Sprachen teilweise so gemacht aber nicht in C++), und hat auch mit effizienz zu tun. Zudem solltest du wenn anders rum denken: + läßt sich auch durch += umsetzen...

Zudem ist dein + falsch überschrieben. + sollte das Objekt nicht ändern, += schon. Zudem sollte + ein Objekt zurückgeben, += eine Referenz.
Regel: Orientiere dich an int (Es ist intuitiver wenn sich deine Operatoren so verhalten wie man es von int gewohnt ist).

Und:

int a = 1;
int b = 2;
int c = a + b;

Ändert weder a noch b.

class Foo
{
  private:
    int a;
  public:
    Foo(int a=0)
    : a(a)
    {}

    Foo& operator+=(Foo const & rhs)
    {
      this->a += rhs.a;
      return *this;
    }
};

Foo operator+(const Foo& lhs, const Foo& rhs)
{
    Foo returnValue(lhs); // Kopie anlegen
    returnValue += rhs;   // operator += auf Kopie anwenden
    return returnValue;   // Kopie zurückliefern
}

+ arbeitet mit Temporären Objekten, += nicht.

cu André

danke