Erklärung für Cast

[Maik (Gast)]

Hallo,
ich habe eine Frage zu einem Cast in einer Software die ich untersuchen 
muß und da ich mich mit Pointern noch sehr schwer tue wollte ich kurz um 
Hilfe und Erklärung bitten.

Welchen Sinn hat der Cast?

#define Var (*(DWORD*)&Array[4])

Gruß Maik

[Hans M. (hansilein)]

c++ ?

[Achim M. (minifloat)]

Maik schrieb:
> in einer Software
So einfallsreiche wie auch aussagekräftige Namen findet man 
normalerweise nur in diversem Lehrmaterial.

Maik schrieb:
> #define Var (*(DWORD*)&Array[4])
Kennst du die Bottom-Up-Methode? Damit kann man komplexe Datentypen 
entflechten. Kann man in diversen Büchern z.B. der C-Kompaktreferenz von 
Prof. Helmut Herold erfahren, wie es geht.

Maik schrieb:
> Welchen Sinn hat der Cast?
Was ist ein DWORD? Wieviel Bit hat es? Ist es signed oder unsigned?

Überleg mal, was wäre, wenn der nicht da stünde. Da hat das Monster gar 
keinen elementaren Datentyp. Soll es vielleicht ein Array aus Pointern 
sein?

mfg mf

[W.B. (Gast)]

Ein Zeiger auf den Inhalt Array[4].
Der Zeiger wird gecastet auf einen DWORD-Zeiger und dieser wird wieder 
dereferenziert.

Wie ist Array definiert?

Sollte hier nicht Var gleich dem Inhalt des Arrays an der Stelle 4 
sein??

[Klaus W. (mfgkw)]

W.B. schrieb:
> Sollte hier nicht Var gleich dem Inhalt des Arrays an der Stelle 4
> sein??

genauer: Array an den Stellen 4 bis 7

[Karl H. (kbuchegg)]

W.B. schrieb:
> Ein Zeiger auf den Inhalt Array[4].
> Der Zeiger wird gecastet auf einen DWORD-Zeiger und dieser wird wieder
> dereferenziert.
>
> Wie ist Array definiert?
>
> Sollte hier nicht Var gleich dem Inhalt des Arrays an der Stelle 4
> sein??

Nope.
Es werden die nächsten sizeof(DWORD) Bytes zur Bildung des Wertes für 
Var herangezogen. Ob das gleichbedeutend ist mit Array[4] oder ob die 
nachfolgenden Array Positionen mit einbezogen werden, hängt davon ab, 
welchen Basisdatentyp 'Array' hat.

Aber auch bei Maik wird sich irgendwann das Aha-Erlebnis breit machen, 
dass man immer 3 Dinge benötigt, wenn man etwas analysiert
* welche Operanden (Variablen und/oder Konstanten) sind involviert
* welche Datentypen haben die Operanden
* welche Operation ist durchzuführen

Erst wenn man alle 3 Zutaten kennt, kann man eine qualifizierte Aussage 
machen. Und auf die Datentypen wird halt gerne am Anfang vergessen. Ist 
bei manchen Fragstellungen lediglich ein Fauxpas, da allerdings ein Cast 
eine Operation ist, mit der man explizit einen Wechsel der Datentypen 
erzwingt, muss man die Ausgangstypen auf jeden Fall kennen um die 
Details der dann tstächlich stattfindenen Operation bestimmen zu können.

[W.B. (Gast)]

glaube ich nicht...

p = &Array[4];
pDWORD = (*DWORD)p;
Var = *pDWORD;


Nur der Zeiger wird gecastet, ich glaube nicht dass das einen einfluss 
auf Var hat...

[Karl H. (kbuchegg)]

W.B. schrieb:
> glaube ich nicht...
>
> p = &Array[4];
> pDWORD = (*DWORD)p;
> Var = *pDWORD;
>
>
> Nur der Zeiger wird gecastet,

Und was ist mit der Dereferenzierung? Fällt die unter den Tisch oder 
wie? Der Zeiger wird umgecastet, aber mit dem Ergebnis wird ja auch 
etwas gemacht. Und das Umcasten hat direkten Einfluss darauf, was dann 
gemacht wird (sonst könnte man sich ja den Cast gleich in die Haare 
schmieren)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

W.B. schrieb:
> p = &Array[4];
> pDWORD = (*DWORD)p;
> Var = *pDWORD;
> Nur der Zeiger wird gecastet, ich glaube nicht dass das einen einfluss
> auf Var hat...
Was kommt für Var heraus, wenn da steht:
char Array[10] = {0,1,2,3,4,5,6,7,8,9};

[asdf (Gast)]

Der cast reinterpretiert den 4 char array als 32 bit integer. Warnung: 
Ist nicht endianness-safe.
DWORD kamen in diversen Microsoft-zentrischen sachen for und duerfte ein 
double word sein(2*16 bit). Genau weisst du das aber erst wenn du in den 
headern 'rumgraebst.
Es koennte sich um ein programmteil handeln, welches mit 'FOURCC' codes 
hantiert...

[amateur (Gast)]

Geraten auf "Intelerrisch" würde ich sagen:

irgendwo gibt's 'nen Speicher:

char Schubidoo [ min. 4 ];  // Hier 12
oder
byte Schubidoo [ min. 4 ];

sowie einen Zeiger:

char *ZeigDrauf;
oder
BYTE *ZeigDrauf;

darüber hinaus soll mit einer 32-Bit Variablen:

DWORD Variable;

gearbeitet werden.

Ein Grund für die differierenden Variablentypen könnte sein, dass Du 
"Schubidoo" über die serielle Schnittstelle "lädst", deren 
Zugriffsfunktionen alle einen char referieren.

Willst du nun auf das 3. DWORD im Puffer zugreifen, so könnte deine 
Arbeitssequenz folgendermaßen aussehen:
// Anfang 3. DWORD adressieren (Zeiger ist *char)
ZeigDrauf = &Schubidoo [ 8 ]; // 0,1,2,3,4,5,6,7,[8],9,10,11
// Interpretation als DWORD
Variable = (Var)ZeigDrauf;

Vorsicht bei der Verwendung von casts. Wenn Du den Compiler "sagst"
Irgendetwas = (GleicherTyp)WasAnderes; so funktioniert die normalerweise 
aktive Typprüfung nicht mehr und der Compiler "glaubt" Dir fast alles.

[Maik (Gast)]

Dankeschön für die Informationen, beim nächsten mal werde ich mir bei 
der Fragestellung mehr Mühe geben und versuchen alle notwendigen 
Informationen zu liefern. Die Infos die ich von euch bekommen habe, 
haben sich aber schonmal gelohnt.
Gruß Maik