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?

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é