Cómo imprimir de forma portátil un tipo int64_t en C

Question 1

El estándar C99 tiene tipos enteros con tamaño de bytes como int64_t. estoy usando Windows %I64d formato actualmente (o sin firmar %I64u), me gusta:

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

y me sale esta advertencia del compilador:

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

Probé con:

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

Pero recibo la misma advertencia. Estoy usando este compilador:

~/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)

¿Qué formato debo usar para imprimir la variable my_int sin tener una advertencia?

Question 2

Para int64_t escribe:

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

por uint64_t escribe:

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

también puedes usar PRIx64 para imprimir en hexadecimal.

cppreference.com tiene una lista completa de macros disponibles para todos los tipos incluyendo intptr_t (PRIxPTR). Hay macros separadas para scanf, como SCNd64.

Una definición típica de PRIu16 sería "hu"por lo que la concatenación implícita de constantes de cadena ocurre en tiempo de compilación.

Para que su código sea completamente portátil, debe usar PRId32 y así sucesivamente para imprimir int32_ty "%d" o similar para imprimir int.

Question 3

La forma C99 es

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

¡O podrías lanzar!

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

Si está atascado con una implementación C89 (especialmente Visual Studio), quizás pueda usar una fuente abierta <inttypes.h> (y <stdint.h>): http://code.google.com/p/msinttypes/

Question 4

Con C99 el %j El modificador de longitud también se puede usar con la familia de funciones printf para imprimir valores de tipo int64_t y 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;
}

Compilando este código con gcc -Wall -pedantic -std=c99 no produce advertencias y el programa imprime el resultado esperado:

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

esto es de acuerdo a printf(3) en mi sistema Linux (la página de manual dice específicamente que j se utiliza para indicar una conversión a un intmax_t o uintmax_t; en mi stdint.h, ambos int64_t y intmax_t están tipificados exactamente de la misma manera, y de manera similar para uint64_t). No estoy seguro de si esto es perfectamente portátil a otros sistemas.

Question 5

Viniendo del mundo integrado, donde incluso uclibc no siempre está disponible, y código como

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

está imprimiendo basura o no funciona en absoluto; siempre uso un pequeño ayudante, que me permite volcar correctamente uint64_t hex:

#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

En el entorno de Windows, utilice

%I64d

en Linux, utilice

%lld

Question 7

Me topé con esta pregunta cuando estaba buscando una forma de mostrar un número de 64 bits en hexadecimal:

Descubrí que puedes usar:

0x%016llx – al menos funciona con mi compilador (aarch64 GCC 7.3.0)

Question 8

//VC6.0 (386 y superior)

    __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);

Saludos.

¿Ha sido útil esta solución?