hätte gern Tips zur Klasse

JnZn558

class CTest {
   int num;
public:
   CTest() {};
   CTest(const int num) { num = this->num; };

   bool operator==(const CTest& obj) {return (this->num == obj.num); };

   // wenn die untere zeile integriert ist, wird die 2. ctor nicht mehr aufgerufen
   bool operator==(const int& num) {return (this->num == num); };
};

// main.cpp
CTest test(10);
cout << (test == 20) << endl; // hier wird die 2. ctor aufgerufen

meine frage ist, ob ich lieber folgende operator integriere soll oder nicht, weil ohne den auch funktioniert, aber eben nur immer die 2. ctor aufruft.

bool operator==(const int& num) {return (this->num == num); };

drakon

Spielt keine Rolle. Ich persönlich würde den ctor bevorzugen, ansonsten ist das nur unnötiger Aufwand. Wenn du das aber nicht implizit erlauben willst, kannst du den ctor auch explicit machen. Dann muss man die Umwandlung selbst programmieren.

btw:
Im ctor würde ich die Initialisierungsliste benutzen.

Nexus

Ich würde nur einen Gleichheitsoperator, dafür einen globalen implementieren:

bool operator== (const CTest& Left, const CTest& Right)
{
    return Left.GetNum() == Right.GetNum(); 
    // erfordert Getter (brauchst du den nicht ohnehin?)
    // sonst evtl. mit friend
}

Sobald du nämlich beginnst, Operatoren für unterschiedliche Typen zu schreiben, geht die Memberfunktions-Version nicht mehr kommutativ. Also funktioniert a == b , nicht aber b == a .

Zudem solltest du für deinen Konstruktor besser die Initialisierungsliste verwenden:

CTest::CTest(int num)
: num(num)
{

}

Auch das const als Parameter macht nicht viel Sinn, da sowieso eine Kopie erstellt wird. Dem Aufrufer kann es eigentlich egal sein, ob diese Kopie von der Funktion verändert wird oder nicht.

JnZn558

danke sehr für tipps, werde se mal ausprobieren

pumuckl

zu deiner Frage: Ich würd den operator erstmal weglassen, ohne gehts auch. Der Operator würde nur das Interface unnötig vergrößern, und der Vorteil ist eher eine Mikro-Optimierung, die der Compiler evtl. sogar von selbst hinbekommt.

Dann solltest du dir unbedingt nochmal deinen Konstruktor anschauen. Der tut nämlich nicht was du gewollt hast. In dem Zusammenhang schau im Tutorial/Buch deiner Wahl mal nach "Initialisierungsliste".

Dann würde ich den operator zu einer freien Funktion machen. Damit kann dann auch das erste Argument bei Bedarf von einem int in ein CTest umgewandelt werden. Siehe auch hier: http://magazin.c-plusplus.net/artikel/�berladung von Operatoren in CPlusPlus (Teil 1)

Dann gibts noch ne Sache: const int als Parameter ist nicht unbedingt gebräuchlich. Da der int eh eine Kopie ist, kannst du das const weglassen. const int& als Parameter ist ebenso unüblich, weil eine Referenz ähnlich teuer ist wie eine ganz normale Kopie eines int. Allgemein werden bei "kleinen" Typen (alle eingebauten Typen und kleine PODs) eher Kopien als const Referenzen übergeben.

Nexus

Ach ja, noch was:
Wenn du den operator== anbietest, solltest du auch einen operator!= implementieren, damit keine unangenehmen Überraschungen auftreten. Diese beiden Operatoren implizieren sich quasi.