Warum/wann `intptr_t` für die Typumwandlung in C verwenden?

Question 1

Ich habe eine Frage zur Verwendung intptr_t vs. long int. Ich habe beobachtet, dass sich das Inkrementieren von Speicheradressen (z. B. über manuelle Zeigerarithmetik) je nach Datentyp unterscheidet. Zum Beispiel fügt das Erhöhen eines char-Zeigers 1 zur Speicheradresse hinzu, während das Erhöhen eines int-Zeigers 4, 8 für ein Double, 16 für ein langes Double usw. hinzufügt.

Anfangs habe ich so etwas gemacht:

char myChar, *pChar;
float myFloat, *pFloat;

pChar = &myChar;
pFloat = &myFloat;

printf( "pChar:  %d\n", ( int )pChar );
printf( "pFloat: %d\n", ( int )pFloat );

pChar++;
pFloat++;

printf( "and then after incrementing,:\n\n" );
printf( "pChar:  %d\n", (int)pChar );
printf( "pFloat:    %d\n", (int)pFloat );

was gut kompiliert und ausgeführt wurde, aber XCode gab mir Warnungen für meine Typumwandlung: “Vom Zeiger in eine Ganzzahl unterschiedlicher Größe umwandeln.”

Nach einigem Googeln und Bingen (ist letzteres schon ein Wort?) sah ich, dass einige Leute die Verwendung empfahlen intptr_t:

#include <stdint.h>

…

printf( "pChar:  %ld\n", ( intptr_t )pChar );
printf( "pFloat: %ld\n", ( intptr_t )pFloat );

was die Fehler tatsächlich behebt. Also dachte ich, von jetzt an sollte ich verwenden intptr_t für Typumwandlungszeiger … Aber dann, nach einigem Herumzappeln, fand ich heraus, dass ich das Problem lösen konnte, indem ich einfach ersetzte int mit long int:

printf( "pChar:  %ld\n", ( long int )pChar );
printf( "pFloat: %ld\n", ( long int )pFloat );

Meine Frage ist also, warum intptr_t nützlich, und wann sollte es verwendet werden? Es scheint in diesem Fall überflüssig. Klar, die Speicheradressen für myChar und myFloat waren einfach zu groß, um in einen zu passen int… also typisieren sie sie long ints hat das Problem gelöst.

Liegt es daran, dass Speicheradressen manchmal zu groß sind? long int auch? Jetzt, wo ich darüber nachdenke, denke ich, dass dies möglich ist, wenn Sie > 4 GB RAM haben. In diesem Fall könnten Speicheradressen 2 ^ 32 – 1 überschreiten (Maximalwert für vorzeichenlose lange Ints …), aber C wurde lange davor erstellt war vorstellbar, oder? Oder waren sie so vorausschauend?

Vielen Dank!

Question 2

intptr_t ist eine neue Erfindung, die geschaffen wurde, nachdem 64-Bit- und sogar 128-Bit-Speicheradressen vorgestellt wurden.

Wenn du je müssen einen Zeiger in einen Integer-Typ umwandeln, stets verwenden intptr_t. Alles andere verursacht unnötige Probleme für Personen, die Ihren Code in Zukunft portieren müssen.

Es hat lange gedauert, alle Fehler damit in Programmen wie Mozilla/Firefox auszubügeln, wenn Leute es auf 64-Bit-Linux kompilieren wollten.

Question 3

Hier ist die Sache: Auf einigen Plattformen int hat die richtige Größe, aber bei anderen long hat die richtige Größe. Woher wissen Sie, welches Sie verwenden sollten? Du nicht. Man könnte Recht haben, aber der Standard gibt keine Garantie dafür, welches es wäre (wenn es eines von beiden ist). Der Standard bietet also einen Typ, der die richtige Größe hat, unabhängig davon, auf welcher Plattform Sie sich befinden. Wo man vorher schreiben musste:

#ifdef PLATFORM_A
  typedef long intptr;
#else
  typedef int intptr;
#endif

Jetzt schreibst du einfach:

#include <stdint.h>

Und es deckt so viele weitere Fälle ab. Stellen Sie sich vor, Sie spezialisieren das obige Snippet auf jede einzelne Plattform Ihr Code läuft weiter.

Question 4

Zuerst, intptr_t ist nur für Datenzeiger (keine Funktionen) und ist nicht garantiert vorhanden.

Dann, nein, Sie sollten es nicht zum Drucken verwenden. Das %p ist dafür. Sie müssen nur Ihren Zeiger auf werfen (void*) und los gehts.

Es ist auch nicht gut für die Arithmetik / den Zugriff auf einzelne Bytes. Cast zu (unsigned char*) stattdessen.

intptr_t ist wirklich für die seltenen Fälle, in denen Sie Zeiger als ganze Zahlen interpretieren müssen (was sie wirklich nicht sind). Tun Sie das nicht, wenn Sie nicht müssen.

Question 5

Sie könnten Ihr Leben einfacher machen, indem Sie die verwenden p Konvertierungsbezeichner:

printf("%p\n", (void *)foo);

Auch die portable Möglichkeit, eine Variable vom Typ zu drucken (u)intptr_t ist die zu verwenden PRI*PTR Makros aus inttypes.h; Folgendes entspricht der Verwendung p auf meiner Plattform (32-Bit):

printf("%08" PRIxPTR "\n", (uintptr_t)(void *)foo);

Die wirft zu void * sind für volle Portabilität notwendig, können aber auf Plattformen mit einheitlichen Zeigerdarstellungen weggelassen werden.