Cum a face tu a format un unsigned long long int folosind printf?

Utilizați ll (el-el) timp lung de modificator cu u (unsigned) de conversie. (Funcționează în windows, GNU).

printf("%llu", 285212672);

Poate doriți să încercați să utilizați inttypes.h bibliotecă care vă oferă tipuri, cum ar fi int32_t, int64_t, uint64_t etc. Apoi, puteți utiliza macro-uri, cum ar fi:

uint64_t x;
uint32_t y;

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

Acest lucru este "garantat" pentru a nu oferi aceleași probleme ca timp, unsigned long long etc, din moment ce nu't trebuie să ghicească câți biți sunt în fiecare tip de date.

%d--> pentru int

%u--> pentru unsigned int`

%ld--> pentru long int

%lu--> pentru unsigned long int`

%lld--> pentru long long int

%llu--> pentru unsigned long long int`

Pentru mult timp (sau __int64) folosind MSVS, ar trebui să utilizați %I64d:

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

Asta pentru că %llu nu't de lucru în mod corespunzător sub Windows și %d't se ocupe de numere întregi pe 64 de biți. Am sugerăm să utilizați PRIu64 în loc și te'll găsi o's portabil pentru Linux la fel de bine.

Încearcă asta:

#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;
}

Ieșire

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

În Linux este %llu și în Windows este %I64u

Deși am găsit-o nu't de lucru în Windows 2000, nu pare a fi un bug acolo!

Compila și x64 cu VS2005:

%llu funcționează bine.

Non-standard, lucrurile sunt întotdeauna ciudat :)

pentru mult timp parte sub GNU l's "L", " ll " sau "q"

și sub windows cred că's " ll " numai

Hex:

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

Ieșire:

64bit: FFFFFFFFFFFFFFFF

În plus față de ceea ce oamenii au scris cu ani în urmă:

• s-ar putea obține această eroare pe gcc/mingw:

principal.c:30:3: avertisment: necunoscut conversie de tip caracter 'l', in format [-Wformat=]

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

Atunci versiunea de mingw implicit la c99. Adauga acest compilator flag: -std=c99.

Se pare că nimeni nu a venit cu un multi-platformă* soluție pentru peste un deceniu din [în] anul 2008, așa că trebuie să adăugați mea 😛. Plz upvote. (Glumesc. Nu-mi pasă.)

Soluție: lltoa()

Cum să utilizați:

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

OP exemplu:

#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;
}

Spre deosebire de %lld print format string, acesta funcționează pentru mine sub 32-bit GCC pe Windows.

) Ei, aproape* multi-platformă. În MSVC, se pare că ai nevoie _ui64toa() în loc de lltoa().

Ei bine, o modalitate este de a compila și x64 cu VS2008

Acest lucru se execută după cum v-ați aștepta:

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

Pentru 32 de biți de cod, trebuie să utilizați corect __int64 specificatorul de format %I64u. Așa devine.

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

Acest cod funcționează pentru ambele 32 și 64 de biți VS compiler.