reinterpret_cast ?

BlueShift

Hallo,
Was bedeutet eigentlich

reinterpret_cast<>

? Hab's noch nie gebraucht...

rüdiger

damit kann man casten. Das sind die neuen (sichereren) C++ Casts

Siehe
http://www.ezdefinition.com/cgi-bin/showsubject.cgi?sid=190

und dein lieblings C++ Buch

volkard

ich kann mich auch grad nicht dran erinnern, wann ich's mal gebraucht hätte. fast alle oder gar alle (weiß ich nicht) male, daß ich reinterpret_cast verwendet habe, waren kleine c++-verbrechen, die später besser und ohne reinterpret_cast reimplementiert wurden.
am liebsten wird es glaub ich verwendet, um nach typ zu filtern

Tier* zoo[1000];
...
void alleTigerSollenBruellen()
{
  for(Tier* tier=&zoo[0];tier!=&zoo[anzahl];++tier)
  {
    Tiger* tiger=reinterpret_cast<Tieger*>(tier);
    //castet den Tier-Zeiger in nen Tiger-Zeiger
    //aber wenn kein Tiger in dem Tier-Zeiger war, gibts 0 zurück!
    if(tiger!=0)
    {
      tiger->bruell();
    }
  }
}

man gibt sich hier ungern, der basisklasse ne virtuelle funktion namens bruellWennDuEinTigerBist zu geben.

Wenn du z.B. mal WinAPI mit C++ programmierst, wirst du diesen Cast öfter benötigen.

Jester

@volkard: Kann es sein, daß Du reinterpret_cast mit dynamic_cast verwechselst?

volkard, verwechselst du da nicht

reinterpret_cast<>

mit

dynamic_cast<>

?

volkard

Jester schrieb:

@volkard: Kann es sein, daß Du reinterpret_cast mit dynamic_cast verwechselst?

jo, absolut.

Bashar

reinterpret_cast braucht man hauptsächlich für unportable Schweinereien, z.B. hier das binäre Schreiben einer int-Variable in einen Stream:

void write_int(ostream& os, int value) {
  os.write(reinterpret_cast<const char*>(&value), sizeof value);
}

volkard

dann versuch ichs nochmal.
was reinterpret_cast macht, steht ja auf der per link angegebenen seite.

ich verwende es, um wilde adressarithmetik zu betreiben, wenn ich an nem eigenen memory-manager rumspiele. sieht dann zum beispiel so aus:

void free(void* x)
{
  i32 xAsInt=reinterpret_cast(i32)(x);
  i32 pageAsInt=xi&0xfffff000;
  PageDescriptor* pd=thePageDescriptors.find(pageAsInt);
  pd->free(xi);

hab gerade keinen compiler zum testen, aber wenn ich mich recht erinner war das geile hier dran, daß reinterpret_cast nur klappt, wenn die beiden dinge gleich groß sind. da brauche ich den kommentar

//hoffentlich hat auf dem zielsystem der void* 32 bit

nicht zu schreiben.

itman

Hallo!

reinterpret_cast ist eine C++ implementierung von alten C typen-cast.
mit diesem cast kann man alle type zum allen typen zu casten.
z.b.
int *k;
char *n;
k = (int n; // Bei C oder C++
k = reinterpret_cast<int *>(n); // Nur Bei C++
sehe hier http://www.cplusplus.com/doc/tutorial/tut5-4.html

Shlo

itman schrieb:

mit diesem cast kann man alle type zum allen typen zu casten.

nein, kann man nicht.

Bei casten von Built-in Types verwendet man static_cast<>() sowie beim casten von void Pointer in andere Pointer-Typen. reinterpret_cast<>() erlaubt es auch nicht, die const-ness weg zu casten.

struct A {/*...*/} a;

long p = reinterpret_cast<long>(&a);
A& b = *reinterpret_cast<A*>(p);

itman

nein, kann man nicht.

Ok, Die eine ausgabe: reinterpret_cast kann modifikatoren (static, volatile) nicht umgehen. All andere conversionen sind moeglich!
z.B.:
int * k;
char s;
k = reinterpret_cast<int *>(s);
Das geht ok! Nicht nur zeigern zondern auch integral typen convertiert sein koennen!

Und ueber static_cast static_cast erlaubt es A zu B casten wenn es moeglich ist A zu B oder B zu A implicit zu kasten. z.B. static_cast kann cast eine Unterclass zeiger zu einum Parentklass zeiger.

Bashar

itman schrieb:

reinterpret_cast ist eine C++ implementierung von alten C typen-cast.
mit diesem cast kann man alle type zum allen typen zu casten.

Nö kann man nicht. float nach long geht zb nicht. Die Umwandlungen, die reinterpret_cast vornehmen kann, sind relativ begrenzt und alle im Standard aufgezählt. Auf jeden Fall ist reinterpret_cast nicht die C++-Version des C-Castes.

itman

Bashar schrieb:

Nö kann man nicht. float nach long geht zb nicht.

Kannst du einem link geben? Wenn du mein link besuche du findest doch was ich gesagt habe. Villeicht ist mein link nicht gut. Denn gebe z.B. ein adnderes und besseres :).
PS: g++ z.B. erlaubt es sich float zum int zu casten, mit reinterpret_cast ich meine! Es scheint sich dass du static_cast mit reinterpret_cast verwechselt.

Bashar

itman schrieb:

Kannst du einem link geben?

Ich geb dir ne Fehlermeldung vom gcc 3.2.2:

reinterpret.cc:6: invalid reinterpret_cast from type `float' to type `int'

Wenn du mein link besuche du findest doch was ich gesagt habe. Villeicht ist mein link nicht gut.

Doch, der ist gut. Du hast ihn nur nicht gelesen, da steht nämlich genau das, was ich gesagt habe.

reinterpret_cast casts a pointer to any other type of pointer. It also allows casting from a pointer to an integer type and vice versa.

This operator can cast pointers between non-related classed. The operation results is a simple binary copy of the value from one pointer to the other. The content pointed does not pass any kind of check nor transformation between types.

In the case that the copy is performed from a pointer to an integer, the interpretation of its content is system dependent and therefore any implementation is non portable. A pointer casted to an integer large enough to fully contain it can be casted back to a valid pointer.
class A {};
class B {};
A * a = new A;
B * b = reinterpret_cast<B*>(a);
reinterpret_cast treats all pointers exactly as traditional type-casting operators do.

Nochmal auf deutsch zusammengefasst: Du kannst zwischen Pointern und integralen Typen casten, sowie zwischen beliebigen Pointertypen. Bei Pointern funktioniert reinterpret_cast genauso wie der C-Cast.

itman

Aha... gcc 3.2.2 Na ja, es macht stricter type pruefung. Ich habe 2.96. Da du hast es recht ueber conversion zwischen integralen typen. Aber mit zeigern es ist nicht so gut wie bei meinem link geschrieben ist. reinterpet_cast kann keine modifikatoren (const, volatile) umgehen. z.B. Man braucht const_cast um zum non-const zeiger zu casten.

Da du hast es recht ueber conversion zwischen integralen typen.

itman

der_held schrieb:

Da du hast es recht ueber conversion zwischen integralen typen.

Ich meine dass es nicht moeglich ist zwischen float und int mit reinterpret_cast zu gehen.

Shlo

itman schrieb:

Und ueber static_cast static_cast erlaubt es A zu B casten wenn es moeglich ist A zu B oder B zu A implicit zu kasten. z.B. static_cast kann cast eine Unterclass zeiger zu einum Parentklass zeiger.

kannst du diesen Satz nochmal formulieren, dass es auch jeder Mensch versteht? Meinst du sowas?

class A {/*...*/};
class B : public A {/*...*/};

A a;
B* b = static_cast<B*>(&a)

A* p = b;

was hat das jetzt mit reinterpret_cast<> zu tun?

itman

static_cast hat nichts mit reinterpret_cast zu tun.

Da ich meine etwas sowas...
Bitte, lese diese beschreibung:

static_cast performs any casting that can be implicitly performed as well as the inverse cast (even if this is not allowed implicitly).
Applied to pointers to classes, that is to say that it allows to cast a pointer of a derived class to its base class (this is a valid conversion that can be implicitly performed) and it can also perform the inverse: cast a base class to its derivated class.

In this last case the base class that is being casted is not checked to determine wether this is a complete class of the destination type or not.

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

Ah, OK, du sprichst anscheinend noch nicht lange deutsch. Deswegen haben wir hier zum Teil ein paar Probleme zu verstehen, was du meinst.