Multiplication de deux nombres longs

Question

J'ai essayé de multiplier par des nombres, par exemple 10000 et 10000 + 1 par le biais du programme C. Mais je ne reçois pas la bonne sortie.

printf("%lld",(100000)*(100001)); 

J'ai essayé le code ci-dessus sur différents compilateurs mais je reçois même 1410165408 au lieu de 10000100000.

Answer 1

Eh bien, nous allons multiplier

int64_t a = 100000; 
    int64_t b = 100001; 
    int64_t c = a * b; 

Et nous allons obtenir (binaire)

 1001010100000011010110101010100000 /* 10000100000 decimal */ 

mais si vous le convertir en int32_t

int32_t d = (int32_t) c; 

vous obtiendrez le 32 derniers bits seulement (et thr OW loin haut 10):

 01010100000011010110101010100000 /* 1410165408 decimal */ 

Une façon plus simple, probablement, est de déclarer les constantes que 64 bits valeurs (LL suffixe signifie long long):

printf("%lld",(100000LL)*(100001LL)); 

Answer 2

Vous pouvez le faire comme ça

long long int a = 100000; 
long long int b = 100001; 
printf("%lld",(a)*(b)); 

Cela vous donnera la bonne réponse.

Ce que vous faites est (100000)*(100001)-à-dire par le compilateur par défaut prend 100000 en un entier et se multiplie 100001 et le stocke dans (int) Mais pendant printf il imprime (int) comme (long int)

Answer 3

Vos deux entiers sont int, cela fera le résultat int aussi. Que le spécificateur de format printf() dit %lld, qui a besoin de long long int, n'a pas d'importance.

Vous pouvez lancer ou utiliser: suffixes

printf("%lld", 100000LL * 100001LL); 

Cette imprime 10000100000. Bien sûr, il y a toujours une limite, puisque le nombre de bits dans un long long int est toujours constant.

Answer 4

En C, le type utilisé pour un calcul est déterminé à partir du type des opérandes , et non du type dans lequel vous stockez le résultat.

Les constantes entières simples telles que 100000 sont de type int, car elles s'insèrent à l'intérieur d'une seule. La multiplication de 100000 * 100001 ne correspondra pas, de sorte que vous obtenez un débordement d'entier et un comportement indéfini. Passer à long ne résoudra pas forcément quoi que ce soit, car cela pourrait aussi être 32 bits.

De plus, l'impression d'un int avec le spécificateur de format %lld est également un comportement indéfini sur la plupart des systèmes.

La racine de tout mal est ici les types par défaut de merde en C (appelés "types de données primitifs" pour une raison). Il suffit de se débarrasser d'eux et toutes leurs incertitudes, et tous vos insectes vont disparaître avec eux:

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

int main(void) 
{ 
    printf("%"PRIu64, (uint64_t)100000 * (uint64_t)100001); 
    return 0; 
} 

ou équivalent: UINT64_C(100000) * UINT64_C(100001).