ich will die Operatoren operator+=(int zahl) und operator+(int zahl) überladen ich habe an das gedacht, ist das richtig oder wie sollte es besser heißen?

class vector3
   {
    public:
    vector3& operator+=(const vector3 &t)
	{ 
		return this->operator+(t);
	};
	vector3& operator+(const vector3 &t)
	{
		x+=t.x;
		y+=t.y;
		z+=t.z;
		return *this;
	};
    private:
         float x,y,z;
};

mfg

ich will die Operatoren operator+=(int zahl) und operator+(int zahl) überladen ich habe an das gedacht, ist das richtig oder wie sollte es besser heißen?

Es ist sinnvoller den operator+= vollständig zu implementieren und den operator+ davon herzuleiten (Damit += tatsächlich seine Performancevorteile ausspielen kann). Den operator+ würde ich zudem aus der Klasse ziehen.

Zudem sollte der operator+ immer eine Kopie zurückgeben und niemals das eigentliche Objekt manipulieren.

class vector3
{
  public:
    vector3& operator+=(const vector3& rhs);
    {
      x+=t.x;
      y+=t.y;
      z+=t.z;
      return *this;
    }

  private:
    float x,y,z;
};

vector3 operator+(const vector3 &lhs, const vector3 &rhs)
{
  vector3 v = ths;
  v += rhs;
  return v;
}

cu André

greetz, Swordfish

O.K vielen Dank. Warum ist es besser auserhalb der Klasse zu haben?

Es gibt mehrere Gründe dafür. Für mich sind zwei Dinge entscheidend:

1. Keine Beeinträchtigung des Objektzustandes
Da in dem Beispiel der Operator+ nicht den Zustand der verwendeten Objekte beeinflusst, ist es auch nicht nötig ihn als Member zu definieren (Hierzu hat glaube ich Herb Sutter mal etwas sehr gutes geschrieben, weiß aber leider nicht mehr welches Buch von Ihm oder welcher Artikel).

2. Andere Argumenttypen auf linker Seite ermöglichen.
Nehmen wir einfach mal an das du noch einen operator* schreiben willst, wo du mittels eines int-Wertes eine Multiplikation durchführen willst. Wenn du den Operator in der Klasse definierst ist nur folgendes realisierbar:
vector1 = vector2 * 12;

Mit Außerhalb der Klasse definierten Operatoren kannst du aber sowohl das linke als auch das rechte Argument anpassen und z.B. einmal einen Operator mit den Parametern (int, const vector&) und einmal (const vector&, int) ermöglichen:
vector1 = vector2 * 12;
vector1 = 12 * vector2;

cu André