Warum kann man printf() in C nicht drucken zwei 64-bit-Werte zur gleichen Zeit?

Arbeite ich auf einem 32-bit-system. Wenn ich versuche zu drucken, die mehr als eine 64-bit-Wert in einer einzigen printf -, dann kann es nicht drucken, keine weiteren (d.h. 2., 3., ...) variable Werte.

Beispiel:

uint64_t a = 0x12345678;
uint64_t b = 0x87654321;
uint64_t c = 0x11111111;

printf("a is %llx & b is %llx & c is %llx",a,b,c);

Warum kann das printf nicht drucken aller Werte?

Ich bin das ändern meiner Frage

printf("a is %x & b is %llx & c is %llx",a,b,c);

by doing " dieses Ergebnis ist : ein 12345678 & b ist 8765432100000000 & c ist 1111111100000000

wenn ich bin nicht den Druck ein Wert richtig, warum dann der andere Wert sind gona ändern??

Was ist der output (oder Fehler), dass Sie bekommen?
Tatsächlich, es funktioniert: ideone.com/um0QL
Sie können nicht verwenden ll für uint64_t. Sie können nur ll für long long Arten. Sollten Sie die <inttypes.h> Makros!
Wenn ich dein code-snippet in ein komplettes Programm, es liefert die erwartete Ausgabe. Bitte geben Sie eine minimale, vollständige Beispiel-Programm zusammen mit dem erwarteten Ausgang und die Ausgabe, die Sie tatsächlich sehen. Für eine Erklärung, die zum erstellen einer minimalen komplette Programm, und warum, dass ist ein nützliches Werkzeug, finden Sie unter sscce.org.
Was compiler, os und compiler-Optionen verwenden Sie?
SB: Xcode 4.1 sagt mir %llx ist korrekt für ein uint64_t.
Das ist Zufall, nicht tragbar!
Ja, du hast Recht. PRIx64 auflöst "llx" hier, aber PRIx64 ist tragbar und "llx" ist es nicht.
Gut, llx ist auch portabel, es ist einfach bezieht sich auf eine andere Art! 🙂 Für unsigned long long int Sie drucken llu oder llx für unsigned long int Sie drucken lu oder lx, und für unsigned int Sie drucken u oder x. Never mind, dass diese alle sind bitweise identisch, aber Sie sind unterschiedliche Typen in der Sprache.
Ich meinte es ist nicht tragbar, wenn Sie nicht den Umgang mit einer lange, lange geben.
printf("a ist %x & b ist %llx & c ist %llx",a,b,c); dadurch ergibt sich : ein 12345678 & b ist 8765432100000000 & c ist 1111111100000000, wenn ich nicht den Druck ein Wert richtig, warum dann der andere Wert sind gona ändern??

InformationsquelleAutor Jeegar Patel | 2011-07-27

c printf

Müssen Sie das richtige format:

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>

int main(void)
{
    uint64_t a = 0x12345678;
    uint64_t b = 0x87654321;
    uint64_t c = 0x11111111;

    printf("a is %#" PRIx64
            " & b is %#" PRIx64
            " & c is %#" PRIx64 "\n",
            a, b, c);
    return EXIT_SUCCESS;
}

Ausgabe:

a is 0x12345678 & b is 0x87654321 & c is 0x11111111

printf("a ist %x & b ist %llx & c ist %llx",a,b,c); dadurch ergibt sich : ein 12345678 & b ist 8765432100000000 & c ist 1111111100000000, wenn ich nicht den Druck ein Wert richtig, warum dann der andere Wert sind gona ändern??
Ich bekomme Warnungen %#" PRIx64 "..." so dass ich nur entfernt die # und es funktioniert gut. (msys2 5.3.0 gcc)
Was bedeutet die # tun (wie in %#) ?

InformationsquelleAutor XYZ

14

Sollten Sie die definierten Makros <inttypes.h>
```
printf("a is %"PRIx64" & b is %"PRIx64" & c is %"PRIx64"\n",a,b,c);
```
Es ist hässlich wie die Hölle, aber es ist tragbar. Das wurde in C99, so benötigen Sie einen C99-kompatible compiler.
- Da dies akzeptiert, ich Frage mich, was das format für PRIx64 ist auf Xcode 4.1, wenn es nicht "llx"?
- Ich don ' T haben Zugang zu diesem compiler aber wenn Sie das tun, könnten Sie versuchen: printf("PRIx64 is %s\n", PRIx64") oder die kürzere printf("PRIx64 is "PRIx64"\n");
- Du hast vollkommen Recht, darauf zu bestehen, auf PRIx64 etc. Aber meine Vermutung, was macht den Unterschied, denn die OP ist nur die \n am Ende der format-string...
- Sie könnte genau die richtige sein 😛 ich habe es auf meine Antwort, ohne auch unter Berücksichtigung, dass, ich denke, es ist nur reflex 🙂
- In Xcode 4.1, PRIx64 ist #define PRIx64 __PRI_64_LENGTH_MODIFIER__ "x" und #define __PRI_64_LENGTH_MODIFIER__ "ll".
- printf("a ist %x & b ist %llx & c ist %llx",a,b,c); dadurch ergibt sich : ein 12345678 & b ist 8765432100000000 & c ist 1111111100000000, wenn ich nicht den Druck ein Wert richtig, warum dann der andere Wert sind gona ändern??
- wird es denn bug printf wird mit pop vom stack falsche Anzahl von bytes. eine ist 8 bytes, aber mit %x entfernt nur 4. also die anderen 4 bleiben auf dem stack, dann %llx entfernt 8 bytes, aber Sie sind falsch, denn die 4 sind von a und 4 von b. Das gleiche geschieht mit der nächsten %llx.
InformationsquelleAutor Vinicius Kamakura
2

Er druckt Sie alle auf meinem computer, aber es gibt drei Kompilierung Warnungen seit %llx erwartet eine long long unsigned int.

Sind Sie sicher, dass Sie brauchen, um mit 64-bit-Typen aber? Alle drei hexcodes sind nur 32-bit. Vielleicht könnte man nur 32 bits und tun:
```
unsigned int a = 0x12345678;
unsigned int b = 0x87654321;
unsigned int c = 0x11111111;

printf("a is %x & b is %x & c is %x",a,b,c);
```
(Oder verwenden Sie den stdint-äquivalent von 32-bit unsigned int)

Wenn Sie Sie benötigen 64 bits, so dass Sie hinzufügen können, mehr bits, um Sie später.

InformationsquelleAutor Paulpro
1

Als angemessen für ein forum namens Stack Overflow, die Ursache der unerwarteten printf() Ausgabe ist aufgrund Stapel Versatz. Die Größe der Diskrepanz zwischen der %x Umwandlung-Spezifikation und Funktion argument a Ursachen der Fehlstellung.

Beim kompilieren der Anweisung
```
printf("a is %x & b is %llx & c is %llx",a,b,c);
```
erzeugt der compiler Maschinencode, der schiebt die Funktionsargumente auf dem stack von rechts nach Links um.

Verwendet der compiler den Variablen-Deklarationen, nicht die format-string, um zu bestimmen, die Größe der Daten der einzelnen Argumente auf dem stack (außer vielleicht für die Generierung von Warnungen). In einer x86 CPU (wie in den meisten Maschinen) der stack-pointer dekrementiert mit jedem Stoß. Bei der Eingabe der printf() library-Funktion, die Stapel deshalb hat das folgende layout:
```
 00A4: ... 

Das geschützte Leerzeichen 00A0: 00000000 
009C: 11111111 Variable 'c' auf den stack geschoben, als uint64 

0098: 00000000 
0094: 87654321 'b' auf den stack geschoben, als uint64 

0090: 00000000 
008C: 12345678 'a' auf den stack geschoben, als uint64 

0088: <Zeiger auf format-string> 
0084: <return-Adresse> 
```
Den top-of-stack-Adresse 0084 willkürlich für dieses Beispiel.

Da alle drei Variablen sind deklariert als uint64_t, die den kompilierten code schiebt diese Variablen auf dem stack als 64-bit-Werte. Für eine little-endian-Maschine wie eine x86 CPU, die high-bytes der einzelnen uint64 Wert am Ende in die höheren Adressen.

Die Umsetzung der printf() verwendet die format-string bestimmt die Anzahl und Größe der Argumente auf dem stack. Im Gegensatz zum compiler, printf() erhält keine Informationen über den ursprünglichen Variablen-Deklarationen. Die erste konvertierungsspezifikation ist %x, so printf() erwartet a eine 32-bit-Wert, und daher printf() analysiert die stack-layout wie folgt:
```
 00A4: ... 

Das geschützte Leerzeichen 00A0: 00000000 

009C: 11111111 
0098: 00000000 '%llx' liest 'c' als uint64, aber von der falschen Adresse 

0094: 87654321 
0090: 00000000 '%llx' liest 'b' als uint64, aber von der falschen Adresse 

008C: 12345678 '%x' bewirkt, dass printf() zu Lesen 'a' als uint32 

0088: <Zeiger auf format-string> 
0084: <return-Adresse> 
```
Den Stapel Versatz erklärt, warum a Drucke 12345678 als erwartet, aber b und c wurden effektiv Links-verschoben von 32 bit auf 8765432100000000 und 1111111100000000.

Korrektur der ersten %x Konvertierung Spezifikation oder casting-argument a auf uint32 sollte das problem lösen.

InformationsquelleAutor Fred Schleifer

Verwenden:

"%lli" for int64_t
"%llu" for uint64_t
"%llx" for hex
"%llX" for HEX

Haben Sie einen Blick hinein "inttypes.h".

InformationsquelleAutor nvd

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.