Ich habe jetzt schon an verschiedenen Orten (unter anderem in der MSDN) gelesen, dass man, wenn man einen Pointer zu void* konvertieren will, dynamic_cast verwenden soll. Doch ich habe bisher noch nirgends gelesen, wieso?

Und noch ein zweite ähnliche Frage einfach in die verkehrte Richtung. Gibt es eigentlich eine Möglichkeit eine Art von dynamic_cast auf einen void-Zeiger anzuwenden. Siehe Codebeispiel, Teil 2.

// Teil 1:
CBase* pBase = new CBase();
void* pVoid = pBase; // Geht ohne Probs
// vorgeschlagen wird aber:
// void* pVoid = dynamic_cast<void*>(pBase);

// Teil 2:
pBase = dynamic_cast<CBase*>(pVoid); // Ergibt einen Fehler.
// Gibt es nicht sowas trotzdem? Also, dass man einen void-Zeiger
// auf den Typ prüfen kann?

Danke für die Hilfe.

Grüssli

sollte man verwenden, wenn man es braucht, persönlich habe ich es noch nie benötigt. für gewöhnliche zwecke ist die implizite konvertierung nach void* genau das richtige, zumal dynamic_cast<void*> einen zeiger auf einen polymorphen typ benötigt. betrachten wir z.b.

struct Base1 { virtual ~Base1() {} };
struct Base2 { virtual ~Base2() {} };
struct Derived : Base1,Base2 {};
void foo()
{
    Base2* p = new Derived();
    void* q = dynamic_cast<void*>(p);
    Base2* r = static_cast<Base2*>(q); // ups
}

hast du mal ein paar links zu orten, die dynamic_cast vorschlagen?

Ich habe jetzt schon an verschiedenen Orten (unter anderem in der MSDN) gelesen, dass man, wenn man einen Pointer zu void* konvertieren will, dynamic_cast verwenden soll.

Ich nicht.
(Hint: Ein Link zum Nachlesen wäre hilfreich)

Und noch ein zweite ähnliche Frage einfach in die verkehrte Richtung. Gibt es eigentlich eine Möglichkeit eine Art von dynamic_cast auf einen void-Zeiger anzuwenden.

Nein.

Zu langsam

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

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.

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

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

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
}

Grüssli

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.

Grüssli

bei void* must du immer reinterpret_cast nehmen.

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