ich habe eine Schnittstelle, bei der eine ID mittels unsigned int übermittelt wird. Auf meiner Seite der Schnittstelle habe ich (im nachhinein)
eine Klasse NodeID_t gebaut, die diese ID kapselt. Wie weit kann ich die Typen kompatibel machen?

Habe schon folgede Dinge überschrieben:

class NodeID_t
{
public:
	NodeID_t();
	NodeID_t(unsigned int id);
	NodeID_t(const NodeID_t& rs);
	bool operator==(const NodeID_t& rs) const;
	bool operator==(const unsigned int rs) const;
	bool operator!=(const NodeID_t& rs) const;
	bool operator!=(const unsigned int rs) const;
	NodeID_t& operator=(const NodeID_t& rs);
	NodeID_t& operator=(unsigned int rs);
	operator unsigned int () const;

	friend bool operator==(const unsigned int& ls, const NodeID_t& rs);
	friend bool operator!=(const unsigned int& ls, const NodeID_t& rs);

Trotzdem bekomme ich noch Fehlermeldungen, wenn eine Methode eine NodeID_t verlangt und ich ein unsigned int übergebe.
Kann man das auch noch umgehen?

Grüße
Timo

Ist der Parameter eine const-Referenz oder ein call by value?

Eine const Referenz.

Pellaeon schrieb:

An sich würde ich aber eher zu einem expliziten Cast raten. Das ein int automatisch zu deiner Klasse werden kann, kann dir auch auf die Füße fallen.

Die int Sachen habe ich auch implementiert, nur nicht mit angegeben in meinem vorrangegangenen Post. Wie gesagt es war alles schon mit unsigned int implementiert. Ein cast würde so um die 500 Änderungen nach sich ziehen, da bin ich zu faul. Die Umwandlung in eine eigne Klasse hat auch mehr ideelle Gründe:-)

Pellaeon schrieb:

Normalerweise macht man bei sowas den Konstruktor "explicit"

Das hat scheinbar nicht gewirkt:-(

Ciao
Timo

Habe folgende Methoden überschrieben:

class NodeID_t
{
public:
	NodeID_t();
	NodeID_t(const NodeID_t& rs);
	explicit NodeID_t(const unsigned int& id);
	NodeID_t(unsigned int rs);
	explicit NodeID_t(const int& rs);
	NodeID_t(int rs);
	bool operator==(const NodeID_t& rs) const;
	bool operator==(const unsigned int rs) const;
	bool operator==(const int rs) const;
	friend bool operator==(const unsigned int& ls, const NodeID_t& rs);
	friend bool operator==(const int& ls, const NodeID_t& rs);
	bool operator!=(const NodeID_t& rs) const;
	bool operator!=(const unsigned int rs) const;
	bool operator!=(const int rs) const;
	friend bool operator!=(const unsigned int& ls, const NodeID_t& rs);
	friend bool operator!=(const int& ls, const NodeID_t& rs);
	NodeID_t& operator=(const NodeID_t& rs);
	NodeID_t& operator=(unsigned int rs);
	NodeID_t& operator=(int rs);
	operator unsigned int () const;
	operator int () const;
};

Und das const bei Parameter von skalaren Typen (z.B. const unsigned int ) ist auch eher unüblich und nicht wirklich nötig, da das Argument sowieso kopiert wird. Was bezweckst du eigentlich mit Konstruktoren für int und const int& ? Das führt zu Mehrdeutigkeiten beim Aufruf.

Ich oute mich hiermit als Anfänger!

Ciao
Timo

Und wie schon drüber erwähnt: "const int&" macht auch nicht wirklich Sinn. EInfach nur "int" reicht (generell bei den Grundtypen, also auch bei float und unsigned usw.)

Es macht nicht nur keinen Sinn, sondern sollte auch wie erwähnt zu Mehrdeutigkeiten führen. Mich wundert, dass das scheinbar geklappt hat. Wurde der Konstruktor überhaupt jemals aufgerufen?

Wurde der Konstruktor überhaupt jemals aufgerufen?

Scheinbar nicht. Wie schon geschrieben, ich habe einfach alles überschrieben, was mir einfiel, bis alle Kompilerfehler weg waren. Vieles davon ist sicher überflüssig. Aber was, das wißt nur ihr.

Danke an alle, die mir helfen!

Ciao
Timo

Wieso machst du eigentlich vom selben Operator (==, !=) gewisse Überladungen global und gewisse als Member? Ich würde die einheitlich global machen. Oder wenn du es schon so machst, kannst du das friend weglassen, indem du bei den globalen Operatoren auf die Member-Operatoren zugreifst.

Jetzt hab ich es gemerkt Das sollten die Umkehrfunktionen sein, also wenn NodeID_t nicht rechts steht beim Vergleich. Hab jetzt aber gesehen, dass ich sie falschrum definiert habe.
Das mit dem nicht friend, hab ich übernommen.

Ciao
Timo