Nicht verstanden, was der Ausdruck *(uint32_t*) bewirkt

Ich verstehe den Ausdruck nicht *(uint32_t*) tut.

Ich habe die Anweisung auf ein Beispiel heruntergebrochen, das die Teile deklariert, damit ich versuchen kann, zu interpretieren, was jeder tut.

  uint32_t* ptr;
  uint32_t num
  *(uint32_t*)(ptr + num); // <-- what does this do?

Ich verstehe das letzte Bit im Beispiel nicht, was passiert, wenn der Ausdruck *(uint32_t*)(ptr + num); wird zur Laufzeit ausgeführt?

uint32_t ist ein numerischer Typ, der 32 Bit garantiert. Der Wert ist vorzeichenlos, was bedeutet, dass der Wertebereich von 0 bis 2 reicht³² – 1.

Dies

uint32_t* ptr;

deklariert einen Zeiger vom Typ uint32_t*, aber der Zeiger ist nicht initialisiert, d. h. der Zeiger zeigt auf nichts Bestimmtes. Der Versuch, über diesen Zeiger auf den Speicher zuzugreifen, führt zu undefiniertem Verhalten und Ihr Programm kann abstürzen.

Dies

uint32_t num;

ist nur eine Variable vom Typ uint32_t.

Dies

*(uint32_t*)(ptr + num);

ptr + num gibt Ihnen einen neuen Zeiger zurück. Sie wird Zeigerarithmetik genannt. Es ist wie normale Arithmetik, nur dass der Compiler die Größe von Typen berücksichtigt. Denk an ptr + num als Speicheradresse basierend auf dem Original ptr Zeiger plus die Anzahl der Bytes für num uint32_t Objekte.

Das (uint32_t*) x ist eine Besetzung. Dies teilt dem Compiler mit, dass er den Ausdruck behandeln soll x als wäre es ein uint32_t*. In diesem Fall ist es nicht einmal erforderlich, weil ptr + num ist schon ein uint32_t*.

Das * Am Anfang steht der Dereferenzierungsoperator, mit dem über einen Zeiger auf den Speicher zugegriffen wird. Der gesamte Ausdruck ist äquivalent zu

ptr[num];

Da keine dieser Variablen initialisiert wird, ist das Ergebnis Müll.

Wenn Sie sie jedoch wie folgt initialisieren:

uint32_t arr[] = { 1, 3, 5, 7, 9 };
uint32_t *ptr = arr;
uint32_t num = 2;

printf("%u\n", *(ptr + num));

dies würde 5 drucken, weil ptr[2] ist 5.

uint32_t ist darin definiert stdint.halso muss man es vielleicht einschließen

#include <stdint.h>

diese Überschrift definieren soll uint32_t ein vorzeichenloser ganzzahliger Typ sein, der genau 32 Bits benötigt.

Das bringt nicht wirklich was. Lassen Sie mich Ihnen ein anderes Beispiel geben:

uint32_t data;
void *pointer = &data;
*(uint32_t *)pointer = 5;

Zuerst, void* bedeutet “generischer” Zeiger. Es kann auf Objekte beliebigen Typs zeigen.

Jetzt, (uint32_t *) bedeutet „interpretieren pointer als Zeiger auf ein Objekt mit Typ uint32_t.

Der Rest des Ausdrucks bedeutet einfach “5 an der von diesem Zeiger gespeicherten Stelle speichern”.

Wenn Sie wissen wollen, was uint32_t Das ist eine Ganzzahl ohne Vorzeichen mit genau 32 Bit. Und pointer + num ist die gleiche wie die Adresse von pointer[5].

Diese Art von Ausdruck wird normalerweise beim Wortspiel verwendet. Wenn Sie mit Typ-Wortspielen nicht vertraut sind, besteht die Hauptidee darin, das Typsystem zu umgehen, damit Sie etwas als einen anderen Typ behandeln können, als es wirklich ist (dh ein int a als doppelt behandeln).

Die Hauptidee hinter Typ-Punning ist, dass Sie einen Zeiger auf eine aktuelle Variable nehmen und ihn dann in einen anderen Typ umwandeln, indem Sie ihn in einen Zeiger dieses Typs umwandeln und ihn dann dereferenzieren, daher die häufig verwendete Umwandlung und Dereferenzierung, auf die Sie sich beziehen ( *(uint32_t *) = Umwandlung in vorzeichenlosen 32-Bit-Int-Zeiger und dann Dereferenzierung).

Wie andere bereits betont haben, macht Ihr Code “nichts”, weil Sie ein Int mit einem Int vertauschen, was keine Wirkung hat. Wenn Sie jedoch ein Int in ein Double punzieren wollten …

uint32_t num=5;
double& myvar=*(double*) #

Jetzt können Sie manipulieren nums Speicher als Double Via myvar wenngleich num ist noch ein Int. Dies ist eine schreckliche Idee und soll nur als Spielzeugbeispiel für die Verwendung von Wortspielen dienen.