Comment formater un entier long long non signé en utilisant 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;
}

Production:

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

Je suppose que ce résultat inattendu provient de l'impression du unsigned long long int. Comment avez - vous printf()une unsigned long long int?

Utilisez le modificateur ll (el-el) long-long avec la conversion u (non signé). (Fonctionne sous Windows, GNU).

printf("%llu", 285212672);

Vous pouvez essayer d' utiliser la bibliothèque inttypes.h qui vous donne types tels que int32_t, int64_t, uint64_tetc. Vous pouvez ensuite utiliser ses macros telles que:

uint64_t x;
uint32_t y;

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

Ceci est "garanti" pour ne pas vous causer le même problème que long, unsigned long longetc., car vous n'avez pas à deviner le nombre de bits dans chaque type de données.

%d-> pour int

%u-> pour unsigned int

%ld-> pour long intoulong

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

%lld-> pour long long intoulong long

%llu-> pour unsigned long long intouunsigned long long

Pour une longue période (ou __int64) en utilisant MSVS, vous devez utiliser% I64d:

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

En effet,% llu ne fonctionne pas correctement sous Windows et% d ne peut pas gérer les entiers 64 bits. Je suggère d'utiliser plutôt PRIu64 et vous constaterez qu'il est également portable pour Linux.

Essayez plutôt ceci:

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

Production

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

Sous Linux c'est le cas %lluet sous Windows c'est%I64u

Bien que j'ai trouvé que cela ne fonctionne pas dans Windows 2000, il semble y avoir un bogue!

Compilez-le au format x64 avec VS2005:

% llu fonctionne bien.

En plus de ce que les gens écrivaient il y a des années:

• vous pourriez obtenir cette erreur sur gcc / mingw:

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

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

Ensuite, votre version de mingw n'est pas par défaut c99. Ajouter ce drapeau du compilateur: -std=c99.

Apparemment, personne n'a mis au point une solution multiplateforme * depuis plus d'une décennie depuis [l'année] 2008, je vais donc ajouter la mienne 😛. Plz upvote. (Blague. Je m'en fiche.)

Solution: lltoa()

Comment utiliser:

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

Exemple de l'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;
}

Contrairement à la %lldchaîne de format d'impression, celle-ci fonctionne pour moi sous GCC 32 bits sous Windows.

*) Eh bien, presque multi-plateforme. Dans MSVC, vous avez apparemment besoin _ui64toa()de lltoa().

Les choses non standard sont toujours étranges :)

pour la partie longue et longue sous GNU c'est L, llouq

et sous les fenêtres je crois que c'est llseulement

Hex:

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

Production:

64bit: FFFFFFFFFFFFFFFF

Eh bien, une façon est de le compiler en x64 avec VS2008

Cela fonctionne comme vous vous en doutez:

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

Pour le code 32 bits, nous devons utiliser le spécificateur de format __int64 correct% I64u. Alors ça devient.

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

Ce code fonctionne pour les compilateurs VS 32 et 64 bits.