Was ist die richtige Verwendung von printf, um mit 0s aufgefüllte Zeiger anzuzeigen

Question 1

In C möchte ich printf verwenden, um Zeiger anzuzeigen, und damit sie richtig ausgerichtet sind, möchte ich sie mit Nullen auffüllen.

Meine Vermutung war, dass der richtige Weg, dies zu tun, war:

printf("%016p", ptr);

Das funktioniert, aber dieser gcc beschwert sich mit folgender Meldung:

warning: '0' flag used with ‘%p’ gnu_printf format

Ich habe ein bisschen danach gegoogelt, und der folgende Thread behandelt das gleiche Thema, gibt aber keine wirkliche Lösung.

http://gcc.gnu.org/ml/gcc-bugs/2003-05/msg00484.html

Wenn man es liest, scheint der Grund, warum sich gcc beschwert, darin zu liegen, dass die von mir vorgeschlagene Syntax nicht in C99 definiert ist. Aber ich kann anscheinend keinen anderen Weg finden, dasselbe auf eine standardmäßig genehmigte Weise zu tun.

Hier also die Doppelfrage:

Ist mein Verständnis richtig, dass dieses Verhalten nicht durch den C99-Standard definiert ist?
Wenn ja, gibt es eine standardisierte, tragbare Möglichkeit, dies zu tun?

Question 2

#include <inttypes.h>

#include <stdint.h>

printf("%016" PRIxPTR "\n", (uintptr_t)ptr);

aber es wird den Zeiger nicht auf die von der Implementierung definierte Weise drucken (sagt DEAD:BEEF für den segmentierten 8086-Modus).

Question 3

Verwenden:

#include <inttypes.h>

printf("0x%016" PRIXPTR "\n", (uintptr_t) pointer);

Oder verwenden Sie eine andere Variante der Makros aus diesem Header.

Beachten Sie auch, dass einige Implementierungen von printf() drucke ein ‘0x‘ vor dem Zeiger; andere nicht (und beide sind nach dem C-Standard korrekt).

Question 4

Diese Antwort ähnelt der zuvor in https://stackoverflow.com/a/1255185/1905491 gegebenen, berücksichtigt aber auch die möglichen Breiten (wie von https://stackoverflow.com/a/6904396/1905491 beschrieben, was ich nicht erkannt, bis meine Antwort darunter gerendert wurde ;). Der folgende Ausschnitt druckt Zeiger als 8 0-passed Hex-Zeichen auf vernünftigen * Maschinen, wo sie durch 32 Bit, 16 auf 64b und 4 auf 16b-Systemen dargestellt werden können.

#include <inttypes.h>
#define PRIxPTR_WIDTH ((int)(sizeof(uintptr_t)*2))

printf("0x%0*" PRIxPTR, PRIxPTR_WIDTH, (uintptr_t)pointer);

Beachten Sie die Verwendung des Sternchens zum Abrufen der Breite durch das nächste Argument, das sich in C99 befindet (wahrscheinlich früher?), Aber das “in freier Wildbahn” ziemlich selten zu sehen ist. Das ist viel besser als die Verwendung von p Konvertierung, da letztere implementierungsdefiniert ist.

* Die Norm erlaubt uintptr_t größer als das Minimum sein, aber ich gehe davon aus, dass es keine Implementierung gibt, die das Minimum nicht verwendet.

Question 5

Das einzige tragbar Eine Möglichkeit, Zeigerwerte zu drucken, besteht darin, die zu verwenden "%p" Bezeichner, der eine implementierungsdefinierte Ausgabe erzeugt. (Konvertieren in uintptr_t und verwenden PRIxPTR wird wahrscheinlich funktionieren, aber (a) uintptr_t wurde in C99 eingeführt, daher wird es von einigen Compilern möglicherweise nicht unterstützt, und (b) es ist nicht einmal garantiert, dass es in C99 existiert (es gibt möglicherweise keinen Integer-Typ, der groß genug ist, um alle möglichen Zeigerwerte aufzunehmen.

Also verwenden "%p" mit sprintf() (oder snprintf()falls vorhanden), um in eine Zeichenfolge zu drucken, und geben Sie dann die Zeichenfolgenauffüllung mit führenden Leerzeichen aus.

Ein Problem ist, dass es keinen wirklich guten Weg gibt, die maximale Länge der erzeugten Zeichenfolge zu bestimmen "%p".

Dies ist zugegebenermaßen unbequem (obwohl Sie es natürlich in eine Funktion packen können). Wenn Sie keine 100%ige Portabilität benötigen, habe ich noch nie ein System verwendet, auf das der Zeiger gecastet wurde unsigned long und Drucken des Ergebnisses mit "0x%16lx" würde nicht funktionieren. [UPDATE: Yes, I have. 64-bit Windows has 64-bit pointers and 32-bit unsigned long.] (Oder Sie können verwenden "0x%*lx" und die Breite berechnen, wahrscheinlich so etwas wie sizeof (void*) * 2. Wenn Sie wirklich paranoid sind, können Sie Systeme erklären, in denen CHAR_BIT > 8Sie erhalten also mehr als 2 Hexadezimalziffern pro Byte.)

Question 6

Es ist einfach zu lösen, wenn Sie den Zeiger auf einen langen Typ umwandeln. Das Problem ist, dass dies nicht auf allen Plattformen funktioniert, da davon ausgegangen wird, dass ein Zeiger in einen langen Text passt und dass ein Zeiger in 16 Zeichen (64 Bit) angezeigt werden kann. Dies gilt jedoch für die meisten Plattformen.

so würde es werden:

printf("%016lx", (unsigned long) ptr);

Question 7

Wie Ihr Link bereits andeutet, ist das Verhalten undefiniert. Ich glaube nicht, dass es dafür eine portable Möglichkeit gibt, da %p selbst von der Plattform abhängt, auf der Sie arbeiten. Sie könnten den Zeiger natürlich auch einfach auf ein int werfen und es in hex anzeigen:

printf("0x%016lx", (unsigned long)ptr);

Question 8

Vielleicht ist das interessant (von einem 32-Bit-Windows-Rechner mit mingw):

rjeq@RJEQXPD /u
$ cat test.c
#include <stdio.h>

int main()
{
    char c;

    printf("p: %016p\n", &c);
    printf("x: %016llx\n", (unsigned long long) (unsigned long) &c);

    return 0;
}

rjeq@RJEQXPD /u
$ gcc -Wall -o test test.c
test.c: In function `main':
test.c:7: warning: `0' flag used with `%p' printf format

rjeq@RJEQXPD /u
$ ./test.exe
p:         0022FF77
x: 000000000022ff77

Wie Sie sehen können, füllt die %p-Version mit Nullen bis zur Größe eines Zeigers und dann mit Leerzeichen bis zur angegebenen Größe auf, während die Verwendung von %x und Umwandlungen (die Umwandlungen und Formatbezeichner sind höchst unportabel) nur Nullen verwendet.