void* p = dynamic_cast<void*>(Pointer);

akari

Hallo

dynamic_cast mit void* zu benutzten ist Unsinn, denn void* ist ein typloser Pointer. Und dynamic_cast ist ja gerade dazuda, den Typ des Ursprungs zu überprüfen.

bei void* must du immer reinterpret_cast nehmen. Und natürlich hast du dann auch keine Tpy-Überprüfung. Deshalb must du dir in C++ immer gut überlegen, ob du void* verwenden willst.

bis bald
akari

camper

der einzige sinnvolle einsatzzweck scheint mir zu sein, zu testen, ob zwei pointer in das gleiche 'most-derived'-objekt zeigen:

template<typename T,typename U>
bool same_object(T* t, U* u) { return dynamic_cast<const void*>(t) == dynamic_cast<const void*>(u); }

das ist letztlich nicht besonders nützlich.

Dravere

Ok link ... hmmm *sucht* ...
http://msdn2.microsoft.com/en-us/library/cby9kycs.aspx

Da steht dann auch:

MSDN schrieb:

If type-id is void*, a run-time check is made to determine the actual type of expression. The result is a pointer to the complete object pointed to by expression.

Allerdings versteht ich das nicht so recht. void* ist ja eben Typenlos. Wieso wird dann ein run-time check auf "the expression" gemacht, wofür? Und das Resultat sei dann ein vollständiger Pointer auf das Objekt. Ist es ohne dynamic_cast denn kein vollständiger Pointer oder wie? ^^

Grüssli

LordJaxom

Da steht aber nirgendwo, dass man dynamic_cast für cast-to-void* nehmen sollte. Dort ist lediglich beschrieben was camper mit seinem Beispiel schon gezeigt hat, nämlich dass ein dynamic_cast<void*> einen Zeiger auf ein vollständiges Objekt des (Laufzeit-)Typs von expression liefert. Anders ausgedrückt eben das "most-derived" Objekt.

Dravere

*MSDN-Artikel nochmals durchliest* ... mist da stand wirklich nichts von dem. Aber es stand in verschiedenen Tutorials und mindestens zwei Artikel. Aber meint ihr ich würde diese Seiten noch finden? ^^
Und vergesst es, die History beim Browser hilft auch nicht:
1. Ich hab sie abgeschaltet
2. Wenn sie angeschaltet wäre, wären da viel zu viele Links

Aber egal, ich glaube jetzt einfach, dass es nicht sehr nützlich ist. Erstens sehe ich selber dahinter nicht sehr viel Sinn. Zweitens wurde von verschiedenen Personen was dazu gesagt, von welchen ich (womöglich falschen) glauben habe, dass sie eine Ahnung von C++ haben.

Allerdings, da wir gerade beim Thema sind. Was ist dieses most-derived Zeugs? Wo ist der Unterschied im Nutzen, zwischen diesen folgenden zweien?

// Den code von Camper
template<typename T,typename U>
bool same_object_camper(T* t, U* u) { return dynamic_cast<const void*>(t) == dynamic_cast<const void*>(u); }

// Meinem Code
bool same_object_dravere(const void* t, const void* u) const { return t == u; };

Grüssli

camper

Dravere schrieb:

Allerdings, da wir gerade beim Thema sind. Was ist dieses most-derived Zeugs? Wo ist der Unterschied im Nutzen, zwischen diesen folgenden zweien?

// Den code von Camper
template<typename T,typename U>
bool same_object_camper(T* t, U* u) { return dynamic_cast<const void*>(t) == dynamic_cast<const void*>(u); }

// Meinem Code
bool same_object_dravere(const void* t, const void* u) const { return t == u; };

struct Base1 { virtual ~Base1() {} };
struct Base2 { virtual ~Base2() {} };
struct Derived : Base1,Base2 {};

void foo()
{
    Derived d;
    Base1* b1 = &d;
    Base2* b2 = &d;
    same_object_camper(b1,b2); // true
    same_object_dravere(b1,b2); // false
}

Dravere

toll, die eine Funktion ergibt true und die andere false. Das hab ich mir schon gedacht, so blöd bin ich auch nicht ^^
Aber wo ist der Unterschied in der Mechanik, der Funktion. Wieso ergibt es beim einen true und beim anderen false. Werden denn nicht die Adresse verglichen, wenn man zwei void-Zeiger vergleicht? Was dann, wenn es typenlose Zeiger sind?

Grüssli

Dravere schrieb:

toll, die eine Funktion ergibt true und die andere false. Das hab ich mir schon gedacht, so blöd bin ich auch nicht ^^
Aber wo ist der Unterschied in der Mechanik, der Funktion. Wieso ergibt es beim einen true und beim anderen false. Werden denn nicht die Adresse verglichen, wenn man zwei void-Zeiger vergleicht? Was dann, wenn es typenlose Zeiger sind?

b1 und b2 zeigen halt auf den Base1- bzw. den Base2-Anteil von d, das ist nicht die gleiche Adresse, sondern eben eine unterschiedliche. Die dynamic_cast-Variante jedoch ergibt void-Pointer mit der Adresse von d (also auf den am weitesten abgeleiteten Typ des Objektes), was die gleiche Adresse ist.

Dravere

Achso *nicht dumm ist, aber anscheinend auch nicht all zu klug, hätte man ja auch selber rausfinden können* ^^ ... dankeschön.

Grüssli

groovemaster

akari schrieb:

bei void* must du immer reinterpret_cast nehmen.

Naja, für void* nimmt man idR static_cast.

void* p = dynamic_cast&lt;void*&gt;(Pointer);

void* p = dynamic_cast<void*>(Pointer);