Casten

Hallo ich habe eben diesen Artikel gefunden: http://www.codeproject.com/Articles/12935/What-static_cast-is-actually-doing

Dort steht:

float f = 12.3;
float* pf = &f;

// static cast<>
// OK, n = 12
int n = static_cast<int>(f);
// Error, types pointed to are unrelated
//int* pn = static_cast<int*>(pf);
// OK
void* pv = static_cast<void*>(pf);
// OK, but *pn2 is rubbish
int* pn2 = static_cast<int*>(pv);

// reinterpret_cast<>
// Error, the compiler know you should
// call static_cast<>
//int i = reinterpret_cast<int>(f);
// OK, but *pn is actually rubbish, same as *pn2
int* pi = reinterpret_cast<int*>(pf);

Hier hänge ich etwas, ich dachte dort könnte ich jetzt 12 bzw. 12.3 ausgeben lassen und wieso soll man da void* angeben wo ist denn da der Sinn? Ok int* pv = static_cast<int*>(pf); so funktioniert es nicht aber void* ist das an der Stelle nicht sinnlos?

#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{

float f = 12.3;
float *pf = &f;

void* pv = static_cast<void*>(pf);
cout<< pv;

system("PAUSE");
}

cooky451

Und deine Frage war?

Was hab ich hier von?

float f = 12.3;
float* pf = &f;
void* pv = static_cast<void*>(pf); 
 cout<< pv;

Was kann ich damit machen nachdem ich es nach void* gecastet habe?

Hier ist es mir klar wenn ich jetzt n ausgeben lasse dann bekomme ich eine 12 ausgeben.

float f = 12.3;
float* pf = &f;
int n = static_cast<int>(f);

Aber bei dem void* cast bekomme ich immer nur die Adresse vom Pointer ausgeben daher weiss ich nicht was der Autor von dem Artikel damit verdeutlichen will.

cooky451

Wenn du nicht weißt wozu du etwas machen sollst, dann lass es halt. Nach dem Sinn einer Typumwandlung zu fragen ist irgendwie.. sinnlos.

Aber wenn du allgemein wissen willst, wozu man void* braucht: In C++ eigentlich eher selten. Manchmal um Zeiger auf beliebige Speicherbereiche zu übergeben. Oder um alte C-Schnittstellen zu nutzen, die keine Templates kennen.

SeppJ

Du kannst einen void* wieder in jeden beliebigen anderen Zeiger casten, der Compiler erinnert sich nicht, was ður ein Zeiger es ursprünglich war. So kannst du nun aus dem ursprünglichen float* über zwei static_cast Stationen einen int* machen, so als hättest du einen reinterpret_cast zwischen den Zeigern gemacht. Dies illustriert bloß die Regeln eines static_casts, das Ergebnis ist eben so unsinnig wie das Ergebnis des äquivalenten reinterpret_casts.

Es gibt ein paar Anwendungen dafür, wenn man generische Programmierung ohne Templates machen möchte (z.B. um C-Schnittstellen von Bibliotheken zu bedienen), aber sonst ist dies in C++ eher ein exotisches Feature.

edit: zu langsam...

SeppJ schrieb:

Du kannst einen void* wieder in jeden beliebigen anderen Zeiger casten, der Compiler erinnert sich nicht, was ður ein Zeiger es ursprünglich war.

Sagt der Standard nicht, dass man void* nur dorthin casten darf, von wo man gekommen ist?

cooky451

Casten an sich sollte klappen denke ich, Dereferenzieren ist dann eine andere Nummer. ^^