2 Objekte miteinander vergleichen

brainwave81

ok ich habe die variante hier genommen:

class Point { 
bool equal(Point const& obj) const { 
    if(x == obj.x && y == obj.y) return true; 
    return false; 
}

jetzt eine andere sache..wieso wird hier das objekt als referenz übernommen?

danke leute!

Vellas

Du brauchst darauf nur lesend zugreifen und ein Objekt kann man an eine Funktion eigentlich schneller als Referenz übergeben statt das ganze Objekt zu kopieren.

brainwave81

ah ja, aslo muss man das nicht unbedingt so machen, ausser das es const sein sollte..

Vellas

Mit dem const zeigst du das du die Referenz nicht veränderst. Außerdem kannst du so auch ein konstantes Point Objekt an die Funktion übergeben, was sonst nicht funktionieren würde (und das ist wohl das wichtigste dabei). Wenn man Objekte nicht verändern muss, ist es in der Regel gut den Parameter als konstante Referenz anzugeben.
Und falls du mit deiner Aussage meinst das man keine Referenz benutzen muss, solltest du es tun. Es bringt eigentlich nichts ein Objekt zu kopieren wenn man es nur lesend verwendet.

brainwave81

bringt eigentlich nichts ein Objekt zu kopieren wenn man es nur lesend verwendet.

da hast du recht..danke jetzt weiss ich bescheid..

Dommel

camper schrieb:

also als memberfunktion:
bool operator==(const Point& rhs) const
{
     return x == p_2.x && y == p_2.y;
}
oder als freie funktion (das ist - schon aus symmetriegründen - im allgemeinen vorzuziehen)
class Point  
{
// ....
    friend bool operator==(const Point& lhs, const Point& rhs)
    {
        return lhs.x == rhs.x && lhs.y == rhs.y;
    }

was ist denn der vorteil der zweiten Variante?? Oder findest du sie einfach nur schöner??

brainwave81

wie gesagt, wollte ich noch keine überladene operatoren anwenden..

Dommel

ist ja auch nur ne frage an camper... einfach aus Interesse

Ben04

Dommel schrieb:

was ist denn der vorteil der zweiten Variante?? Oder findest du sie einfach nur schöner??

Man sollte eigentlich immer die zweite wählen denn:

class Foo{
public:
  Foo(){}
  Foo(int){}

  bool operator==(const Foo&){}
};

int main(){
  Foo a,b;
  a == b; // geht
  a == 2; // geht
  // 2 == a; geht nicht
}

Dommel

stimmt, mit der anderen Variante würde das wohl gehen...

Implementiert man den Operator dann innerhalb oder außerhalb der Klassendeklaration??

edit: Würde das den wirklich nicht gehen. Es wird doch für die 2 ein temporäres Objekt erzeugt und von dem könnte man doch den Operator aufrufen, oder?

LordJaxom

Da er kein Mitglied der Klasse ist natürlich ausserhalb. Innerhalb kannst Du ihn nur friend deklarieren um auf private Member der Objekte zuzugreifen.

Ben04

Oder auch als firend + inline in der Klasse.

class Foo{
public:
  friend void operator==(const Foo&, const Foo&){ /*...*/ }
};

Bei trivialen Vergleichen wie hier bevorzuge ich die Variante.

Würde das den wirklich nicht gehen. Es wird doch für die 2 ein temporäres Objekt erzeugt und von dem könnte man doch den Operator aufrufen, oder?

Das temporäre Objekt wird im Zuge eines impliciten Casts erzeugt. Die Regeln wann das passiert sind recht komplex allerdings sind sie hier nicht wichtig da sie sich nur auf Argumente beziehen. Allerdings ist "a" in "a == b" im Falle eines Member "=="-Operator kein Argument und folglich kann auch kein temporäres Objekt durch einen impliciten Cast erzeugt werden.