Twitter und Facebook-Anbindung
X
Tweet Follow @twitterapi
!!! Anbindung an twitter und facebook öffnen !!!

Wenn Ihnen mein Online-Buch gefällt,
dann bedanken Sie sich doch mit einer kleinen Spende...

20.1.5 reinterpret Casting

20.1.5 reinterpret Casting

Diese Typumwandlung ist etwas besonderes und auch die gefährlichste Variante. Mit ihr kann man Speicherbereiche neu interpretieren. Was meine ich damit? Angenommen, Sie haben einen Float und machen ein statisches Casten in einen Int. Dann wird der Wert des Floats so im Speicher mgeschrieben, dass ein Integer daraus wird. Das Ergebnis im Arbeitsspeicher sieht also nach der Konvertierung total anders aus. Beim Reinterpretieren, bleibt jede 1 und 0 an der Stelle wo sie war, was zur folge hat, dass man nicht genau voraussagen kann, was am Ende dabei herauskommt.

Ein denkbarer Anwendungsfall ist, dass man wirklich sehen möchte, wie gewisse Datentypen im Speicher abgelegt werden. In diesem Fall würde man eine reinterpret Typumwandlung auf beispielsweise einen unsigned int machen. Dies will ich jetzt einmal Demonstrieren.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
					
// Ausgabe eines Integers als Binärzahl //////////////////////////////////
void Ausgabe(unsigned int iWert) {
	unsigned int	iErgebnis			= iWert;
	unsigned int	aSpeicher[32];
	int		iPosition			= 31;

	do { // Umwandlung Dezimal -> Binär
		aSpeicher[iPosition--]			= iErgebnis % 2;
		iErgebnis				/= 2;
	} while (iErgebnis > 0);

	// Mit Nullen auffüllen
	while (iPosition >= 0) aSpeicher[iPosition--]	= 0;

	printf("Dezimal: %11i - Binaer: ", iWert);
	
	for (iPosition = 0; iPosition < 32; iPosition++) | 
		printf("%u", aSpeicher[iPosition]);
	} // end of for
	
	printf("\n");
} // Ausgabe //////////////////////////////////////////////////////////////////



// Hauptfunktion der Anwendung ////////////////////////////////////////////////
int main(int argc, char** argtv) {
	float* pWert1			= new float(-20.25f);
	float* pWert2			= new float(0.125f);

	unsigned int* pKonvertiert1	= reinterpret_cast<unsigned int*>(pWert1);
	unsigned int* pKonvertiert2	= reinterpret_cast<unsigned int*>(pWert2);

	Ausgabe(*pKonvertiert1);
	Ausgabe(*pKonvertiert2);

	delete pWert1;
	delete pWert2;

	return 0;
} // main /////////////////////////////////////////////////////////////////////
					

Ausgabe:

Dezimal: -1046347776 - Binaer: 11000001101000100000000000000000
Dezimal:  1040187392 - Binaer: 00111110000000000000000000000000
		

Sie sehen also deutlich, dass der Speicherbereich komplett neu interpretiert wird und dass es ohne weiteres nicht möglich ist, den neuen Wert abzuschätzen. Wenn man sich nur den Wert des Integers anschaut, fragt man sich, wie jener zustande kommt. In dem Moment, wo man diese Dezimalzahl in eine binäre umwandelt und ausgibt, sieht man dann, dass der Binärwert, nach IEEE 754, tatsächlich dem Wert des Floats entspricht.

Ein weiterer Anwendungsfall wäre, eine Adresse (also den Wert eines Zeigers) in einem Array aus Integern zwischenzuspeichern. Genauso kann man auch Zeiger auf ganz andere Sachen umbiegen. Diese Art der Typumwandlung ist also eine Art Baseballschläger, mit dem man fast alles gnadenlos umwandeln kann. Also, auch hier sollten Sie sehr vorsichtig sein!

Zum Seitenanfang
Zum Inhaltsverzeichnis

© Copyright by Thomas Weiß, 2009 - 2012