POINT oder CPoint

der speicherplatzbedarf ist gleich
sizeof(CPoint) == sizeof(POINT)

BigSigi schrieb:

Nochmal zu meiner zur Geschwindigkeit! Wenn ich immer mit den Get... und Set... Methoden arbeite, dann bin ich doch sicher langsamer als bei einer direkten Zuweisung, oder?

Bin heute mal ein bisschen lästig
DANKE im voraus, bye, Sigi

Nein, du bist wahrscheinlich sogar schneller. Weil die Funktionen einen Pointer (this) auf das Objekt übergeben bekommen und du mit dem gleich beide Werte schreibst.
So schreibst du erst das x und dann das y. Kann aber gut sein, dass der Compiler das auch optimiert.

Außerdem würd ich die Get und Set Methoden in die Klassendefinition reinschreiben, dann werden die Funktionen inline und sind garantiert mindestens genauso schnell.

btw, ich find deine Variablennamen hässlich. Welchen Grund gibt es bitte, m_x zu schreiben? Oder CPoint? Wenn du konsequent Objekte klein schreibst und Klassennamen groß, dann brauchst du kein C.

Shlo

BigSigi schrieb:

Meine Klasse CPoint sieht wie folgt aus: ...

Schreeeeckliches Klassendesign, auch die meinsten Operatoren sind falsch überladen...

TomasRiker

Wenn es möglich ist, sollte man konstante Referenzen als Parameter der Operatoren verwenden.
+= und -= sollten ebenfalls CPoint zurückliefern.

DrGreenthumb

TomasRiker schrieb:

Wenn es möglich ist, sollte man konstante Referenzen als Parameter der Operatoren verwenden.

Gibt kein nicht-möglich.

Shlo

noch was: m_x bzw m_y Elemente deiner Klasse solltest du im Public Bereich deklarieren, dann sparst du dir die get bzw set Methoden. Normalerweise macht man das nicht, aber in diesem Fall ist es von Vorteil. Insgesamt würde ich die ganze Klasse inline schreiben.

BigSigi

Ich habs jetzt einwenig abgeändert. Das wichtigste ist das das Ding schnell ist.

class CPoint
{
public:
   long x;
   long y;

   CPoint Distance(const CPoint &p)const{ long cx,cy; return CPoint((((cx=p.x-x)<0)?-cx:cx),
                                                                    (((cy=p.y-y)<0)?-cy:cy));};

   CPoint& operator +=(const CPoint &p){ x+=p.x; y+=p.y; return *this; };
   CPoint& operator -=(const CPoint &p){ x-=p.x; y-=p.y; return *this; };

   CPoint operator =(const CPoint &p){ x=p.x; y=p.y; return *this; };
   CPoint operator +(const CPoint &p)const{ return CPoint(x+p.x,y+p.y ); };
   CPoint operator -(const CPoint &p)const{ return CPoint(x-p.x,y-p.y ); };

   bool operator ==(const CPoint &p)const{ return (x == p.x && y == p.y); };
   bool operator !=(const CPoint &p)const{ return (x != p.x || y != p.y); };

   CPoint(){ x=0;y=0; };
   CPoint(long cx,long cy){ x=cx; y=cy; };
   ~CPoint(){};
};

Bitte nicht schlagen, so schlimm kann´s ja wircklich nicht sein.
CPoint wer ich lassen, denn das C gefällt mir halt, und die "m_" vor jeder "M"embervariable laß ich weg, weils eigendlich häßlich ist.

DANKE für eure Hinweise! Und wenn´s weiter Tipps gibt, nur her damit

Nachtrag:
War wohl etwas übereifrig mit dem Aufrufen per Referenz.(in der hitze des gefechtes)

Shlo

wieder ein paar Sachen die ich unschön finde bzw. falsch sind:

1. binäre Operatoren die in der Klasse überladen sind, sollte mal als konstante Methoden implementieren, Vergleichsoperatoren ebenfalls.
2. im Konstruktor würde ich als Paramter keine Referenzen nehmen (speziell bei generischen Datentypen), denn wer will schon erst die Variablen definieren und dann diese an den Konstruktor übergeben? Bei set bzw. get Klassenmethoden ist es genau so.

Da du die x und y Elemente deiner Klasse im Public-Bereich stehen hast, kannst du die set- get Methoden entfernen, es sieht ziemlich hässlich aus.

BigSigi

Und so wurde aus der Frage struct oder class eine Designsache!
Bin euch dankbar, TSCHAU Sigi

PS: Hab jetzt oben alles ausgebessert

Shlo

BigSigi schrieb:

Und so wurde aus der Frage struct oder class eine Designsache!

Jau, dies ist aber sehr wichtig wenn man mit Klassen arbeitet