UND operator ( operator&(...) )

[BorisDieKlinge]

ich möchte den &- Operator (nicht Referenz) überladen, das folgendes möglich ist?

Foo A,B,C;

A= B & C;

A&= B;

wobei der r und l Parameter imm vom gleine typ sein muss.

sind ref. und UND operation syntakisch anderes beim überladen?

[rüdiger]

klar. Der Address-Operator ist Unär, während der Binäre-Und-Operator Binär ist.

Kannst du aber in jeder Referenz nachschlagen

[BorisDieKlinge]

habe schon gegoogled, aber der UND operator ist nich groß beschrieben:

unär:

A operator& (const A &Scr){...}

binär: 

[cpp]void operator (const lA &oScr, const rA &oScr){...}

??

A a,b,c;

a= a & b; //Binär? zuweisung operator?

wie kann ich dann den unären verwenden?

@rüdfiger: Gibt den UND operator überahupt unär? Wobei der Adressoeprator Prädif unär ist , und mein beispiel Postfix unär.

[rüdiger]

natürlich gibt es den UND-Operator nicht unär, sondern nur binär. (unär wäre der UND-Operator ja quasi ein NOP a&a==a)

[BorisDieKlinge]

ok danke. muss ich den binären UND operator global machen, auch dann wenn ich nur die Typen der eigen Klasse verunde?

Oh man das mit dem binär/unär ist mir bischen unklar:

class foo{

  //A  
  foo& foo: operator&( const foo &Scr){...}
  //B 
  void operator &(const foo &lScr,const foo &rScr){...}

};

Welcher der Operatior ins unär und welche binär?

[rüdiger]

du solltest ihn als Funktion (also außerhalb deiner Klasse) und nicht als Methode implementieren, wenn du das meinst. Siehe auch GotW

[BorisDieKlinge]

was ist GotW? Global ist immer so unschön...

[SideWinder]

1. Global ist hier schön
2. http://www.gotw.ca/ dort gibts einen schönen Artikel darüber warum das so sein soll.

MfG SideWinder

[CStoll]

Nein, du kannst ihn auch als Klassenmember überladen, wenn du darauf bestehst (aber ich empfehle dir mal, die Antworten zu deinen früheren Fragen genauer durchzulesen - das haben wir dir alles schon mehrfach erklärt ;)). Binäre Operatoren definierst du entweder als globale Funktion mit zwei Parametern (in der Reihenfolge linker und rechter Operand oder als Methode mit einem Parameter (linker Operand ist *this, rechter Operand der übergebene Parameter), unäre Operatoren global mit einem Parameter oder als parameterlose Methode - da die unterschiedliche Parameterlisten haben, können sie sich gar nicht in die Quere kommen.

(einzige Besonderheit sind Inkrement und Dekrement - weil es davon zwei unäre Versionen gibt, bekommt der Postfix-Operator noch einen dummy-int-Parameter zur Unterscheidung)

[BorisDieKlinge]

hast der globale Binär Operator einen rückgabe wert? muss ja oder ? das ergenbis?

[rüdiger]

BorisDieKlinge schrieb:

hast der globale Binär Operator einen rückgabe wert? muss ja oder ? das ergenbis?

Meinst du das ernst?

[BorisDieKlinge]

ja ich weis ne waage frage... peinlich.

Meine Anahme:

foo A{

 foo& operator=(const foo &Scr){...}

};

foo& operator& (const foo l&, const &r){...}

wenn ich nun:

foo a,b,c;

a= b & c;

mache, wird für "b&c" der globale UND operator verwendet, und das temporäre obejket dessen rügabe mit =operatoren zugewiesen!

[CStoll]

BorisDieKlinge schrieb:

hast der globale Binär Operator einen rückgabe wert? muss ja oder ? das ergenbis?

Sollte er zumindest, wenn du ihn nutzen willst (btw ist es besser, wenn er sein Ergebnis per Wert (oder zumindest als const-Referenz) zurückgibt)

[BorisDieKlinge]

ok habe den operator global, aller ding kommt dann fehlermeldung

1. multithread error LNK2005: "class CRouteOptions & __cdecl operator&(class CRouteOptions const &,class CRouteOptions const &)" (??I@YAAAVCRouteOptions@@ABV0@0@Z) already defined in multithread.obj

2. multithread fatal error LNK1169: one or more multiply defined symbols found

Code (Vereinfacht);

class CRouteOptions{

CRouteOptions(..);
CRouteOptions(const CRouteOptions &oScr);
CRouteOptions& CRouteOptions::operator=(const CRouteOptions &oScr);
.
.
.
};
//Global
CRouteOptions& operator& (const CRouteOptions &lScr, const CRouteOptions &rScr){
}

[rüdiger]

Lern doch bitte mal die Grundlagen von C++...

Setz entweder ein inline davor oder pack die Implementierung in eine Code-Datei.

[CStoll]

Da hast du Probleme mit der ODR (One Definition Rule) Entweder du kennzeichnest den operator als inline oder du lagerst die Definition in eine eigene CPP-Datei aus (in den Header gehört dann nur der Prototyp).

PS: Auch wenn man sich normalerweise nicht selbst zitieren sollte:

CStoll schrieb:

(btw ist es besser, wenn er sein Ergebnis per Wert (oder zumindest als const-Referenz) zurückgibt)

[BorisDieKlinge]

danke