Como você formata um int longo e não assinado usando printf?

#include <stdio.h>
int main() {
    unsigned long long int num = 285212672; //FYI: fits in 29 bits
    int normalInt = 5;
    printf("My number is %d bytes wide and its value is %ul. A normal number is %d.\n", sizeof(num), num, normalInt);
    return 0;
}

Resultado:

My number is 8 bytes wide and its value is 285212672l. A normal number is 0.

Presumo que esse resultado inesperado seja da impressão do unsigned long long int. Como você printf()um unsigned long long int?

Use o modificador ll (el-el) long-long com a conversão u (não assinada). (Funciona em janelas, GNU).

printf("%llu", 285212672);

Você pode querer tentar usar a biblioteca inttypes.h que lhe dá tipos, tais como int32_t, int64_t, uint64_tetc. Você pode então usar suas macros, tais como:

uint64_t x;
uint32_t y;

printf("x: %"PRId64", y: %"PRId32"\n", x, y);

Isso é "garantido" para não causar o mesmo problema que long, unsigned long longetc, pois você não precisa adivinhar quantos bits existem em cada tipo de dados.

%d-> para int

%u-> para unsigned int

%ld-> para long intoulong

%lu-> para unsigned long intou long unsigned intouunsigned long

%lld-> para long long intoulong long

%llu-> para unsigned long long intouunsigned long long

Por muito tempo (ou __int64) usando MSVS, você deve usar% I64d:

__int64 a;
time_t b;
...
fprintf(outFile,"%I64d,%I64d\n",a,b);    //I is capital i

Isso ocorre porque% llu não funciona corretamente no Windows e% d não pode lidar com números inteiros de 64 bits. Eu sugiro usar o PRIu64 e você verá que também é portátil para Linux.

Tente isso:

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

int main() {
    unsigned long long int num = 285212672; //FYI: fits in 29 bits
    int normalInt = 5;
    /* NOTE: PRIu64 is a preprocessor macro and thus should go outside the quoted string. */
    printf("My number is %d bytes wide and its value is %" PRIu64 ". A normal number is %d.\n", sizeof(num), num, normalInt);
    return 0;
}

Resultado

My number is 8 bytes wide and its value is 285212672. A normal number is 5.

No Linux é %llue no Windows é%I64u

Embora eu tenha achado que não funciona no Windows 2000, parece haver um bug por lá!

Compile-o como x64 com o VS2005:

% llu funciona bem.

Além do que as pessoas escreveram anos atrás:

• você pode receber este erro no gcc / mingw:

main.c:30:3: warning: unknown conversion type character 'l' in format [-Wformat=]

printf("%llu\n", k);

Então sua versão do mingw não é padronizada para c99. Adicionar esta bandeira compilador: -std=c99.

Aparentemente, ninguém inventou uma solução multiplataforma * por mais de uma década desde [o] ano de 2008, então acrescentarei a minha 😛. Voto positivo. (Brincadeira. Eu não ligo.)

Solução: lltoa()

Como usar:

#include <stdlib.h> /* lltoa() */
// ...
char dummy[255];
printf("Over 4 bytes: %s\n", lltoa(5555555555, dummy, 10));
printf("Another one: %s\n", lltoa(15555555555, dummy, 10));

Exemplo do OP:

#include <stdio.h>
#include <stdlib.h> /* lltoa() */

int main() {
    unsigned long long int num = 285212672; // fits in 29 bits
    char dummy[255];
    int normalInt = 5;
    printf("My number is %d bytes wide and its value is %s. "
        "A normal number is %d.\n", 
        sizeof(num), lltoa(num, dummy, 10), normalInt);
    return 0;
}

Ao contrário da %lldstring de formato de impressão, esta funciona para mim no GCC de 32 bits no Windows.

*) Bem, quase multiplataforma. No MSVC, você aparentemente precisa em _ui64toa()vez de lltoa().

Coisas fora do padrão são sempre estranhas :)

para a longa porção longa sob GNU é L, llouq

e sob as janelas eu acredito que é llapenas

Hex:

printf("64bit: %llp", 0xffffffffffffffff);

Resultado:

64bit: FFFFFFFFFFFFFFFF

Bem, uma maneira é compilá-lo como x64 com o VS2008

Isso é executado conforme o esperado:

int normalInt = 5; 
unsigned long long int num=285212672;
printf(
    "My number is %d bytes wide and its value is %ul. 
    A normal number is %d \n", 
    sizeof(num), 
    num, 
    normalInt);

Para código de 32 bits, precisamos usar o especificador de formato __int64 correto% I64u. Assim se torna.

int normalInt = 5; 
unsigned __int64 num=285212672;
printf(
    "My number is %d bytes wide and its value is %I64u. 
    A normal number is %d", 
    sizeof(num),
    num, normalInt);

Esse código funciona para o compilador VS de 32 e 64 bits.