Bei den static_casts habe ich ein Beispiel gefudnen das die static_casts auf Zeiger gültig sind wenn die Zeiger von verwandten Klassen stammen, ist der cast dann nicht gleichbedeutend mit einem reinterpret_cast?

class CBase {};
class CDerived: public CBase {};
CBase * a = new CBase;
CDerived * b = static_cast<CDerived*>(a);

Bei den reinterpret_cast wird das Bitmuster ja einfach anders Interpretiert, aber warum funktioniert eigentlich folgendes nicht

int=reinterpret_cast<int>(float);

Die Anweisung wäre ja eigentlich Sonnenklar, ich will das das int das Bitmußter des float übernimmt. Aber wieso muß ich es so Kompliziert machen?

int=static_cast<int>(*(reinterpret_cast<int*>(&float)));

Hat das irgendeinen einen tieferen Sinn?

Dann noch eine Frage zu Cast Operatoren, wenn ich folgendes mache:

class bar;

class foo
{
    operator bar()
    {};
};

Gehe ich dann richtig ind er annahme das diese beiden Ausdrücke exakt gleichwertig sind und beide diesen operator aufrufen? (ich gehe davon aus das es keinen passenden= Operator gibt der lhs ein bar und rhs ein foo nimtm und das kein Konstruktor in bar für ein foo existiert)

bar=foo;
bar=static_cast<bar>(foo);

Und zum Schluß noch die Frage, was ist der Unetrschied zwischen diesen beiden Cast operatoren

operator D3DCOLORVALUE ();
operator D3DCOLORVALUE& ();

Ich werd hier nicht schlau draus welchen Sinn das & hier genau machen soll.

Xebov schrieb:

Bei den static_casts habe ich ein Beispiel gefudnen das die static_casts auf Zeiger gültig sind wenn die Zeiger von verwandten Klassen stammen, ist der cast dann nicht gleichbedeutend mit einem reinterpret_cast?

Nein. Es ist im Standard nicht garantiert, dass der Zeiger auf CDerived der gleiche ist, wie der Zeiger auf CBase . Also a und b können verschiedene Werte enthalten in deinem Beispiel. Ein reinterpret_cast kümmert sich nicht weiter darum, interpretiert den Wert einfach um, was unter Umständen zu undefiniertem Verhalten führt. Ein static_cast dagegen kann bei einfacher Vererbung (keine Mehrfachvererbung) dies zur Kompilezeit feststellen und den Zeiger somit richtig umbiegen lassen, also wird kein undefiniertes Verhalten ausgelöst. Bei Mehrfachvererbung bekommst du bei einem static_cast allerdings einen Kompilerfehler, da auch der static_cast nicht mehr ausreicht und nur noch ein dynamic_cast dir helfen kann:

class BaseLeft { };
class BaseRight { };
class Derived
  : public BaseLeft
  , public BaseRight
{
};

// ...

Derived d;
BaseRight* br = &d;

Derived* p = 0;

p = static_cast<Derived*>(br); // Kompilerfehler
p = dynamic_cast<Derived*>(br); // Funktioniert
p = reinterpret_cast<Derived*>(br); // Funktioniert, aber grosse Chancen für undefiniertes Verhalten!

Xebov schrieb:

aber warum funktioniert eigentlich folgendes nicht

int=reinterpret_cast<int>(float);

Die Anweisung wäre ja eigentlich Sonnenklar, ich will das das int das Bitmußter des float übernimmt.

Ich denke, dass es eben nicht so Sonnenklar ist. In 99,99% der Fälle meinen die Leute wahrscheinlich eher das hier:

float f = 34.8f;
int i = static_cast<int>(f);

Ich denke, dass die Verwechslungsgefahr viel zu hoch ist, deshalb hat man es verboten.

Xebov schrieb:

Aber wieso muß ich es so Kompliziert machen?

Du machst es auch viel zu kompliziert, das geht deutlich einfacher:

float f = 34.8f;
int i = *reinterpret_cast<int*>(&f);

Xebov schrieb:

Gehe ich dann richtig ind er annahme das diese beiden Ausdrücke exakt gleichwertig sind und beide diesen operator aufrufen? (ich gehe davon aus das es keinen passenden= Operator gibt der lhs ein bar und rhs ein foo nimtm und das kein Konstruktor in bar für ein foo existiert)

Soweit mir bekannt ist, ja. Es könnte sein, dass im nächsten Standard es einen kleinen Unterschied gibt. Dort wird es wahrscheinlich explizite Konvertierungsoperatoren haben. Wenn der Operator also als explizit definiert ist, dann wird wohl nur die static_cast Variante funktionieren.

Xebov schrieb:

Und zum Schluß noch die Frage, was ist der Unetrschied zwischen diesen beiden Cast operatoren

operator D3DCOLORVALUE ();
operator D3DCOLORVALUE& ();

Ich werd hier nicht schlau draus welchen Sinn das & hier genau machen soll.

Kurzes Beispiel sollte hier wohl helfen:

#include <iostream>

class Foo
{
private:
	int m_i;

public:
	Foo(int i)
		: m_i(i)
	{
	}

	operator int&()
	{
		return m_i;
	}

	int get_i() const
	{
		return m_i;
	}
};

int main()
{
	Foo f(10);

	std::cout << f.get_i() << std::endl;

	int& i = f;
	i = 20;

	std::cout << f.get_i() << std::endl;

	return 0;
}

Die Ausgabe ist:

10
20

Grüssli