So drucken Sie einen int64_t-Typ in C

Question 1

Der C99-Standard hat Integer-Typen mit einer Bytegröße wie int64_t. Ich verwende Windows %I64d aktuelles Format (oder unsigned %I64u), wie:

#include <stdio.h>
#include <stdint.h>
int64_t my_int = 999999999999999999;
printf("This is my_int: %I64d\n", my_int);

und ich bekomme diese Compiler-Warnung:

warning: format ‘%I64d’ expects type ‘int’, but argument 2 has type ‘int64_t’

Ich habe es versucht mit:

printf("This is my_int: %lld\n", my_int); // long long decimal

Aber ich bekomme die gleiche Warnung. Ich verwende diesen Compiler:

~/dev/c$ cc -v
Using built-in specs.
Target: i686-apple-darwin10
Configured with: /var/tmp/gcc/gcc-5664~89/src/configure --disable-checking --enable-werror --prefix=/usr --mandir=/share/man --enable-languages=c,objc,c++,obj-c++ --program-transform-name=/^[cg][^.-]*$/s/$/-4.2/ --with-slibdir=/usr/lib --build=i686-apple-darwin10 --program-prefix=i686-apple-darwin10- --host=x86_64-apple-darwin10 --target=i686-apple-darwin10 --with-gxx-include-dir=/include/c++/4.2.1
Thread model: posix
gcc version 4.2.1 (Apple Inc. build 5664)

Welches Format sollte ich verwenden, um die Variable my_int ohne Warnung zu drucken?

Question 2

Zum int64_t Typ:

#include <inttypes.h>
int64_t t;
printf("%" PRId64 "\n", t);

zum uint64_t Typ:

#include <inttypes.h>
uint64_t t;
printf("%" PRIu64 "\n", t);

kannst du auch verwenden PRIx64 hexadezimal drucken.

cppreference.com hat eine vollständige Auflistung der verfügbaren Makros für alle Typen einschließlich intptr_t (PRIxPTR). Es gibt separate Makros für scanf, wie z SCNd64.

Eine typische Definition von PRIu16 wäre "hu"sodass die implizite Verkettung von Zeichenfolgenkonstanten zur Kompilierzeit erfolgt.

Damit Ihr Code vollständig portierbar ist, müssen Sie verwenden PRId32 und so weiter zum Drucken int32_tund "%d" oder ähnliches zum Ausdrucken int.

Question 3

Der C99-Weg ist

#include <inttypes.h>
int64_t my_int = 999999999999999999;
printf("%" PRId64 "\n", my_int);

Oder du könntest werfen!

printf("%ld", (long)my_int);
printf("%lld", (long long)my_int); /* C89 didn't define `long long` */
printf("%f", (double)my_int);

Wenn Sie mit einer C89-Implementierung (insbesondere Visual Studio) feststecken, können Sie vielleicht eine Open Source verwenden <inttypes.h> (und <stdint.h>): http://code.google.com/p/msinttypes/

Question 4

Mit C99 die %j Der Längenmodifikator kann auch mit der printf-Funktionsfamilie verwendet werden, um Werte des Typs auszugeben int64_t und uint64_t:

#include <stdio.h>
#include <stdint.h>

int main(int argc, char *argv[])
{
    int64_t  a = 1LL << 63;
    uint64_t b = 1ULL << 63;

    printf("a=%jd (0x%jx)\n", a, a);
    printf("b=%ju (0x%jx)\n", b, b);

    return 0;
}

Kompilieren Sie diesen Code mit gcc -Wall -pedantic -std=c99 erzeugt keine Warnungen und das Programm gibt die erwartete Ausgabe aus:

a=-9223372036854775808 (0x8000000000000000)
b=9223372036854775808 (0x8000000000000000)

Dies ist gem printf(3) auf meinem Linux-System (die Manpage sagt das ausdrücklich j wird verwendet, um eine Umwandlung in an anzuzeigen intmax_t oder uintmax_t; in meiner stdint.h beides int64_t und intmax_t werden auf genau die gleiche Weise typdefiniert, und ähnlich für uint64_t). Ich bin mir nicht sicher, ob dies perfekt auf andere Systeme übertragbar ist.

Question 5

Aus der eingebetteten Welt kommend, wo sogar uclibc nicht immer verfügbar ist, und Code wie

uint64_t myval = 0xdeadfacedeadbeef; printf("%llx", myval);

druckt du Mist oder funktioniert überhaupt nicht — ich benutze immer einen kleinen Helfer, der es mir erlaubt, richtig uint64_t hex zu dumpen:

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

char* ullx(uint64_t val)
{
    static char buf[34] = { [0 ... 33] = 0 };
    char* out = &buf[33];
    uint64_t hval = val;
    unsigned int hbase = 16;

    do {
        *out = "0123456789abcdef"[hval % hbase];
        --out;
        hval /= hbase;
    } while(hval);

    *out-- = 'x', *out="0";

    return out;
}

Question 6

Verwenden Sie in der Windows-Umgebung

%I64d

unter Linux verwenden

%lld

Question 7

Stolperte über diese Frage, als ich nach einer Möglichkeit suchte, 64-Bit-Zahlen in Hex anzuzeigen:

Herausgefunden, dass Sie verwenden können:

0x%016llx – funktioniert zumindest mit meinem Compiler (aarch64 GCC 7.3.0)

Question 8

//VC6.0 (386 und besser)

    __int64 my_qw_var = 0x1234567890abcdef;

    __int32 v_dw_h;
    __int32 v_dw_l;

    __asm
        {
            mov eax,[dword ptr my_qw_var + 4]   //dwh
            mov [dword ptr v_dw_h],eax

            mov eax,[dword ptr my_qw_var]   //dwl
            mov [dword ptr v_dw_l],eax

        }
        //Oops 0.8 format
    printf("val = 0x%0.8x%0.8x\n", (__int32)v_dw_h, (__int32)v_dw_l);

Grüße.