Vergleichsoperator überladen

Wikinger75

Hey Leute, ich hab versucht den vergleichsoperator zu überladen, aber er meint nur das hier:
Also erstmal code^^

// Definition in der Klasse
bool operator ==(const Quadrat* Q);

// In der cpp Datei.
bool Quadrat::operator ==(const Quadrat* Q)
{
     Quadrat tmp(*this);
     if (tmp.a == Q.a && tmp.A == Q.A) {return true;}
     else {return false;}
     return false;
}

Er behauptet auch das es die Variablen a & A nicht gibt, warum?

Mfg Wikinger75!

Nexus

Du solltest Vergleichsoperatoren besser global machen, damit beide Argumente gleichwertig behandelt werden können.

bool operator== (const Quadrat& Left, const Quadrat& Right);

Wie du siehst, habe ich hier auch Const-Referenzen genommen anstatt Const-Pointer, du willst schliesslich die Objekte direkt vergleichen und nicht deren Zeiger.

Es gibt übrigens seit Kurzem einen sehr guten Artikel über Operatorüberladung in C++. Hier wäre der Link dazu.

volkard

// Definition in der Klasse
bool operator ==(const Quadrat& Q);//hier referenz übergene, damit if(x==y) geht und nicht x==&y

// In der cpp Datei.
bool Quadrat::operator ==(const Quadrat& Q)
{
     Quadrat& tmp(*this);//mit dem & ist tmp nur ein anderer name von *this und kostenlos
     if (tmp.a == Q.a && tmp.A == Q.A) {return true;}
     else {return false;}
     return false;
}

Wikinger75

Perfekt Danke Leute

Nexus

Hey, noch was: Dieses Konstrukt hat ziemlich viel Redundanz drin, unter anderem Code, der gar nie erreicht wird.

if (tmp.a == Q.a && tmp.A == Q.A) {return true;} 
     else {return false;} 
     return false;

Das wäre wohl passender:

return tmp.a == Q.a && tmp.A == Q.A;

Skym0sh0

dein code klappt nicht weil du mit einem pointer auf member zugreifst wie bei einem normalen objekt

richtig wäre:

bool Quadrat::operator ==(const Quadrat* Q)
{
     Quadrat tmp(*this);
     if (tmp.a == Q->a && tmp.A == Q->A)
            return true;
     else 
            return false;
}

unskilled

Skym0sh0 schrieb:

richtig wäre:

bool Quadrat::operator ==(const Quadrat* Q)
{
     Quadrat tmp(*this);
     if (tmp.a == Q->a && tmp.A == Q->A)
            return true;
     else 
            return false;
}

Ne, wär es nicht (das return true und false ist unnötig, die Kopie macht keinen Sinn)...

Wenn man es schon so machen würde, wäre das richtig:

Nexus schrieb:

return tmp.a == Q.a && tmp.A == Q.A;

mit dann nat. dieser Deklaration:

bool Quadrat::operator ==(const Quadrat &Q);

Aber wie gesagt - der Artikel über Operatoren-Überladung ist echt gut - den könntest du mal lesen, dann wüsstest du auch, dass man den Operator global macht etc ^^

bb

Wikinger75

Danke werd ich machen, aber ich hab ein Buch und da steht das es dem Programmierer frei Überlassen ist, aber ich sehe kein unterschied ,das linke objekt muss ja immmer eins von typ Quadrat sein in diesem fall, aber hier wird Q mit Q verglichen ,also sind beide objekt ein quadrat und somit geht es immer.