ich hab mal gehört, das man Operatoren in der Klasse implementieren soll und andere wiederrum über diese außerhalb einer Klasse.

Also z. B.:

operator += //soll in der Klasse implementiert sein,

operator + //soll außerhalb der Klasse implementiert werden, jedoch intern auf den operator += der Klasse zugreifen.

operator == //soll außerhalb der Klasse implementiert werden.

Jetzt meine Frage: warum sollte man es so machen, wo liegen die Gründe dafür und welche Vorteile/Nachteile bringt es mit sich?

Danke euch vielmals im voraus.

Viele liebe Grüße

const A operator+( const A&, int);
const A operator+( int, const A&);

A x;
A y;

y = x + 5;
y = 5 + x;

Das geht mit einem Member nicht.

Gibt es irgendwo lesestoff darüber? denn das was ihr hier sagt, ist mir leider noch zu waage.

nix wage.

nachdenken:

operator==(int, Klasse)
operator+(int, Klasse)

wie willst du diese beiden als member implementieren?
Es geht nicht.

mal davon abgesehen dass man nur was man unbedingt muss als member machen sollte

33 typedef struct D3DXVECTOR2
 34 {
 35 #ifdef __cplusplus
 36     D3DXVECTOR2();
 37     D3DXVECTOR2(CONST FLOAT *pf);
 38     D3DXVECTOR2(FLOAT fx, FLOAT fy);
 39 
 40     operator FLOAT* ();
 41     operator CONST FLOAT* () const;
 42 
 43     D3DXVECTOR2& operator += (CONST D3DXVECTOR2&);
 44     D3DXVECTOR2& operator -= (CONST D3DXVECTOR2&);
 45     D3DXVECTOR2& operator *= (FLOAT);
 46     D3DXVECTOR2& operator /= (FLOAT);
 47 
 48     D3DXVECTOR2 operator + () const;
 49     D3DXVECTOR2 operator - () const;
 50 
 51     D3DXVECTOR2 operator + (CONST D3DXVECTOR2&) const;
 52     D3DXVECTOR2 operator - (CONST D3DXVECTOR2&) const;
 53     D3DXVECTOR2 operator * (FLOAT) const;
 54     D3DXVECTOR2 operator / (FLOAT) const;
 55 
 56     friend D3DXVECTOR2 operator * (FLOAT, CONST D3DXVECTOR2&);
 57 
 58     BOOL operator == (CONST D3DXVECTOR2&) const;
 59     BOOL operator != (CONST D3DXVECTOR2&) const;
 60 #endif /* __cplusplus */
 61     FLOAT x, y;
 62 } D3DXVECTOR2, *LPD3DXVECTOR2;
 63

Zeile 43-59

Viele liebe Grüße

p.s.: Euer Spamschutz ist scheisse, beantwortet man die Frage richtig, kommt die Meldung, das kein Thema ausgewählt wurde.

Das Stichwort ist Symmetrie bei Operatoren. Wenn du Symmetrie brauchst, musst du sie außerhalb der Klasse implementieren.

Gibt es irgendwo lesestoff darüber?

Ja hier: boost.operators

Komisch, hier werden aber haufenweise Operatoren in der Klasse implementiert:

33 typedef struct D3DXVECTOR2
 34 {
 35 #ifdef __cplusplus 
 36     ...

Das ist ja auch DirectX-Geraffel - bekanntermaßen von Anfängern geschrieben - das sieht man schon an dem 'typedef struct' und dann #ifdef __cplusplus - das sagt doch schon alles!
und was ist überhaupt

CONST

??

@ 7H3 N4C3R
Was kann man unter "Symmetrie der Operatoren" verstehen?

Du schreibst z.B.

Klasse = int + Klasse

Damit du das mit Member-Operatoren implementieren kannst, müsstest du int um einen +-Operator für "Klasse" erweitern. Zum einen ist int keine Klasse, geht also garnicht, zum anderen hat int mit "Klasse" rein garnix zu tun.

Also wird im selben Header wie "Klasse" und im selben Namespace wie "Klasse" ein freier +-Operator geschrieben, der einen int als erstes Argument übernimmt. Mit einer Implementierung als Member müsste das erste Argument immer "Klasse" sein.

Jetzt meine Frage: warum sollte man es so machen, wo liegen die Gründe dafür und welche Vorteile/Nachteile bringt es mit sich?

Der Hauptgrund ist die impilizite Konvertierung des ertsen Arguments. Sagen wir du hast zwei Typen, Foo und Bar. Foo ist implizit in Bar konvertierbar (d.h. du hast einen Castoperator in Foo oder einen nicht-expliziten Konstruktor in Bar der ein Foo annimmt oder Foo abgeleitet von Bar).
Die operatoren von Bar sollten dann wie von dir genannt implementiert werden (f hat diese operatoren NCIHT implementiert):

Bar b;
Foo f;

b += f; //ok, ruft Bar::operator+=(Bar) auf, f wird konvertiert.
if (b == f) //ok, ruft operator==(Bar, Bar) auf oder Bar::operator==(Bar) , f konvertiert
  return b + f; //operator+(Bar, Bar) bzw. Bar::operator+(Bar) mit Konvertierung
if(f == b) //geht nur mit operator+(Bar,Bar), da das erste Argument konvertiert werden muss!
  return f + b; //dito, Bar::operator+(Bar) könnte nicht aufgerufen werden, da das this-Argument nicht konvertiert werden kann