Announcement

**Jochen Reichenberg** · 15.12.2003, 18:50

@ingUR,

nein, da muß ich wiedersprechen. Der Code meiner Vergleichsfunktion wird niemals aufgerufen. Statt dessen wird der Standard-Zeigervergleich aufgerufen, der, wie Ulrich schon gepostet hat, auch nicht überladbar ist. Wie ich das mir dann auch gerade zusammengereimt hatte (im Posting danach, aber da hatte ich Ulrichs Posting noch nicht gesehen).

@Sebastian,

so habe ich es (vorübergehend) auch gelöst. Sogar der Methodenname ist identisch.

Aber trotzdem muß das mit einem überladenen Operator auch hinzubekommen sein.

Grüße Joche

**Ulrich Gerhardt** · 15.12.2003, 20:04

@Jochen: Wenn es überhaupt mit Zeiger1 ==
Zeiger2 geht (ich bezweifle es), dann muss es wohl
ein globaler Operator mit zwei Zeigern als
Parameter sein.
Aber was hast du denn
dagegen, *Zeiger1 == *Zeiger2 zu schreiben? Du willst
doch schließlich die
Objekte vergleichen und nicht die Zeigerwerte.
Uli.

**Uwe Richtsteig** · 15.12.2003, 21:00

<pre>
Dein Einwand kann ich nicht nachvollziehen, da u.a. Code den Einstieg und die Abarbeitung Deiner Vergleichsfunktion zeigt.

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

void Vergleich(void);

TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
Vergleich();
}
//---------------------------------------------------------------------------

struct KM // Kalibriermittel
{
int Id;
KM();
KM(KM *ckm);
~KM();
bool operator== (const KM* km) const;
};

KM::KM(void){};
KM::~KM(void){};

bool KM:

perator == (const KM* km) const
{
ShowMessage("Vergleich in op-Methode mit " + FormatFloat("this->Id = 0", this->Id) + " und " +FormatFloat("km->Id = 0", km->Id));
if (this->Id == km->Id)
{
ShowMessage("Vergleichsergebnis WAHR");
return true;
}
else
{
ShowMessage("Vergleichsergebnis FALSCH");
return false;
}
}

void Vergleich()
{
KM mykm1;
KM mykm2;

mykm1.Id=0;
mykm2.Id=0;

for (int i=0; i< 4000; mykm1.Id=i, i+=1000)
{
for (int j=0; j< 4000; mykm2.Id=j, j+=1000)
{
if (mykm1 == &mykm2)
ShowMessage("gleich");
else
ShowMessage("ungleich");
}
}
}</pre>

Wenn ich jedoch etwas falsch verstanden haben sollte, so bitte ich dies in jedem Fall meinem Anfängerstatus zuzuschreiben.

Gruß,
Uw

**Jochen Reichenberg** · 15.12.2003, 21:18

@Ulrich,

nein global geht auch nicht

. Mittlerweile vermute ich fast, daß die Versuche mit Referenzen nicht funktioniert haben, weil der Kopierkonstruktur 'schlechter Stil' ist (fehlendes const und keine Verwendung von Ref.). Ich fürchte, daß bei einem Vergleich *Zeiger == *Zeiger zwei temporäre Objekte erzeugt werden. Ich werde das morgen noch mal angehen. Sollten aber tatsächlich zwei temporäre Objekte erzeugt werden, bleibe ich bei Sebastians Lösungsvorschlag, weil es einfach schneller und Ressourcen schonender ist.

@Uwe,

der Unterschied ist, daß ich mit Zeigern operiere. Ich erzeuge die Objekte mit KM* pKM = new KM();. Deswegen funtkioniert Dein Beispiel nicht, weil es nur einen Zeiger verwendet, ich aber nur 2 Zeiger habe. Anscheinend habe ich heute mal wieder einen ganz schlechten Tag (zuviel Raven Shield gestern??). Wie Ulrich schon vollkommen richtig festgestellt hat ist es (sinnvollerweise) nicht möglich den Vergleichsoperator Zeiger == Zeiger zu überschreiben. Deshalb wurde auch mein Code nie aufgerufen, was aber prima war, denn sonst hätten die diversen Aufrufe von if (pKM) delete pKM; im Destruktor auch nicht mehr funktionieren können.

Grüße Joche

**Ulrich Gerhardt** · 15.12.2003, 22:43

Ich fürchte, daß bei einem Vergleich *Zeiger == *Zeiger zwei temporäre Objekte erzeugt werden. 
Nicht, wenn du die Parameter von
"operator ==" als Referenzen definierst.
(Außer du hast "operator *" überladen oder ähnliche Schweinereien getrieben. :-))
 Uli

**Uwe Richtsteig** · 15.12.2003, 22:43

Dann bleibt wohl nur die Abfrage if(*a == *b)

mit

bool operator== (const KM &km) const;

und

if (this->Id == km.Id)

Gruß!

<pre>
//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

void Vergleich(void);

TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
Vergleich();
}
//---------------------------------------------------------------------------

struct KM // Kalibriermittel
{
int Id;
KM();
KM(KM *ckm);
~KM();
bool operator== (const KM &km) const;
};

KM::KM(void){};
KM::~KM(void){};

bool KM:

perator == (const KM &km) const
{
ShowMessage("Vergleich in op-Methode mit " + FormatFloat("this->Id = 0", this->Id) + " und " +FormatFloat("km->Id = 0", km.Id));
if (this->Id == km.Id)
{
ShowMessage("Vergleichsergebnis WAHR");
return true;
}
else
{
ShowMessage("Vergleichsergebnis FALSCH");
return false;
}
}

void Vergleich()
{
KM *mykm1 = new KM;
KM *mykm2 = new KM;

mykm1->Id=0;
mykm2->Id=0;

for (int i=0; i< 4000; mykm1->Id=i, i+=1000)
for (int j=0; j< 4000; mykm2->Id=j, j+=1000)
{
if (*mykm1 == *mykm2)
ShowMessage("gleich");
else
ShowMessage("ungleich");
}
}</pre&gt

**Sebastian Starzyczny** · 16.12.2003, 10:32

so einfach geht das, und alle haben so lange diskutiert. Wenn ich noch im 1. Semester wäre, hätte ichs auch noch gewusst, da hat man noch sowas im Blut haben müssen um die Prüfung zu bestehen :-

**Jochen Reichenberg** · 16.12.2003, 10:35

@Ulrich: Du hast recht, ich habe sowohl die Vergleichsfunktion, als auch den Kopier-Konstruktor auf const Referenz umgestellt. Es werden keine temporären Objekte erzeugt. (Nein ich habe keine 'Schweinereien' gemacht. Nur fast.

).

@Uwe: Dem kann ich nichts mehr hinzufügen.

Auf jeden Fall funktioniert es jetzt, nachdem ich den Vergleichsoperator mit Referenz erzeugt habe und den Vergleich mit *Zeiger == *Zeiger durchführe.

Vielen Dank an Alle!

Grüße Joche

**Jochen Reichenberg** · 16.12.2003, 10:37

@Sebastian: Ja wenn ich denn sowas mal studiert hätte. Hab' das Programmieren vor ein paar Jahren Hobby-mäßig begonnen und mir das alles 'nur' angelesen.

Grüße Joche

**Ulrich Gerhardt** · 16.12.2003, 12:01

Hi Jochen, 
einen hab ich noch. :-) Du kannst die Implementation noch verkürzen:<pre>
bool KM:

perator== (const KM& km) const
{
return Id == km.Id;
}
</pre>
Das finde ich verständlicher als deine if-Konstruktion. Ist aber wohl Geschmackssache.
Ciao, Uli

**Jochen Reichenberg** · 16.12.2003, 12:09

Hallo Ulrich,

die komplette Vergleichszeile sieht so aus:
<PRE>
if (this->Id == km.Id
&& this->TypId == km.TypId
&& this->LiefNr == km.LiefNr
&& this->LiefName == km.LiefName
&& this->Typ == km.Typ
&& this->SNr == km.SNr
&& this->Preis == km.Preis
&& this->EOId == km.EOId
&& this->dtAnschaffung.Val == km.dtAnschaffung.Val
&& this->dtLetztePruef.Val == km.dtLetztePruef.Val
&& this->dtNaechstePruef.Val == km.dtNaechstePruef.Val
&& this->PruefIntervall == km.PruefIntervall
&& this->Sollmass == km.Sollmass
&& this->Toleranz == km.Toleranz
&& this->Einheit == km.Einheit
&& this->Verschrottet == km.Verschrottet
&& this->Reparatur == km.Reparatur)
</PRE>
Deshalb die if-Bedingung, obwohl es auch ohne geht...

Grüße Joche

**Ulrich Gerhardt** · 16.12.2003, 12:36

Ändert nix am Prinzip. Dann wird's halt<pre>
return Id == km.Id
&& TypId == km.TypId
&& LiefNr == km.LiefNr
&& LiefName == km.LiefName
&& Typ == km.Typ
&& SNr == km.SNr
&& Preis == km.Preis
&& EOId == km.EOId
&& dtAnschaffung.Val == km.dtAnschaffung.Val
&& dtLetztePruef.Val == km.dtLetztePruef.Val
&& dtNaechstePruef.Val == km.dtNaechstePruef.Val
&& PruefIntervall == km.PruefIntervall
&& Sollmass == km.Sollmass
&& Toleranz == km.Toleranz
&& Einheit == km.Einheit
&& Verschrottet == km.Verschrottet
&& Reparatur == km.Reparatur;
</pre>
Aber wie gesagt -- ist Geschmackssache. :-

**Jochen Reichenberg** · 16.12.2003, 13:02

Hallo Ulrich,

ich bin eigentlich auch ein Verfechter von 'Je kürzer, desto besser'. Normalerweise habe ich auch die this-> nicht mit drin (weil ja explizit vorgegeben). Aber auf Grund der Probleme hatte ich die ganz ausführliche Version gewählt. :´)
Hab's jetzt aber geändert. Die this-> sind auch raus.

Grüße Joche

**Ulrich Gerhardt** · 16.12.2003, 14:23

ich bin eigentlich auch ein Verfechter von 'Je kürzer, desto besser' 
Ich nicht immer. Aber hier finde ich die kürzere Version zugleich lesbarer. (Ist ja nicht immer der Fall. :-))
 Aber ich merke schon: ich entwickle mich zum Stildiktator -- sehr bedenklich. :-)
 
Uli

**Sebastian Starzyczny** · 16.12.2003, 14:52

zu dem this operator noch eine Bemerkung: der kommt meistens daher, dass die Leute zu faul zum schreiben sind und die Codevervollständigung dazu nutzen sich alle Eigenschaften und Methoden anzuzeigen

Announcement

operator == überladen

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment