Comment puis-je multiplier les vraiment grands nombres c++

J'ai le code suivant

      int i, a, z;
i = 2343243443;
a = 5464354324324324;
z = i * a;
cout << z << endl;

Lorsque ceux-ci sont multipliés il me donne -1431223188 qui n'est pas la réponse. Comment puis-je faire il me donner la bonne réponse?

Commencez par regarder stackoverflow.com/questions/269268/.... Si vous ne t voulons lancer notre propre: boost.org/doc/libs/1_56_0/libs/multiprecision/doc/html/...
Vous pouvez essayer de long int et long long int. Si ceux qui ne sont pas assez grandes, alors vous voudrez peut-être une sorte de bibliothèque spéciale de la forme: GNU MP (BPF)

OriginalL'auteur Fred Roy | 2014-10-25

  1. 4

    Comme Jarod42 proposé est tout à fait correct, mais je ne suis pas sûr de savoir si dépassement de sera ou non ?

    Essayer d'enregistrer chaque et chaque chiffre d'un nombre dans un tableau et après que se multiplier. Vous aurez certainement obtenir la bonne réponse.

    Pour plus de détails comment multiplier à l'aide de la matrice de suivre ce post http://discuss.codechef.com/questions/7349/computing-factorials-of-a-huge-number-in-cc-a-tutorial

    2343243443 déjà des débordements d'un int32 (mais pas un uint32), donc oui, il y a un dépassement.
    Je suis intéressé par le stockage de chaque nombre dans un tableau puis en multipliant, mais je ne peux pas le comprendre. Assez complexe.

    OriginalL'auteur Shravan40

  2. 5

    Le résultat des débordements de l'int (et aussi std::uint64_t)

    Vous devez utiliser une BigInt bibliothèque.

    OriginalL'auteur Jarod42

  3. 2

    ints contenir uniquement 32 bits. Lorsque le résultat d'une multiplication est plus grand que 2^31 - 1, le résultat roule plus grande valeur négative. Au lieu d'utiliser le type de données int, utilisez long long int, qui détient 64 bits.

    OriginalL'auteur Alex Monroe

  4. 1

    L'utilisation pan de papier de l'approche que nous avons utilisé dans la 2e série.
    Magasin de deux nombres à deux tableau dans l'ordre inverse. Et de prendre les sna de la matrice de taille (arr1.taille + arr2.taille).Et aussi initilize sna tableau à zéro.

    Dans votre cas
    arr1[10]={3,4,4,3,4,2,3,4,3,2},
    arr2[15]={4,2,3,4,2,3,,4,5,3,4,5,3,4,6,4,5};

    for(int i=0;i<arr1_length;i++)
{
    for(int j=0;j<arr2_length;j++)
    {

        ans[i+j]+=arr1[i]*arr2[j];
        ans[i+j+1]=ans[i+j+1]+ans[i+j]/10;
        ans[i+j]%=10;
    }
}

    Puis sna tableau contient le résultat.Veuillez imprimer soigneusement sna tableau. il peut contenir zéro.

    OriginalL'auteur Shravan Kumar Suthaar

  5. 0
    //its may heplfull for you
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define MAX 1000
void reverse(char *from, char *to ){
int len=strlen(from);
int l;
for(l=0;l<len;l++)to[l]=from[len-l-1];
to[len]='\0';
}
void call_mult(char *first,char *sec,char *result){
char F[MAX],S[MAX],temp[MAX];
int f_len,s_len,f,s,r,t_len,hold,res;
f_len=strlen(first);
s_len=strlen(sec);
reverse(first,F);
reverse(sec,S);
t_len=f_len+s_len;
r=-1;
for(f=0;f<=t_len;f++)temp[f]='0';
temp[f]='\0';
for(s=0;s<s_len;s++){
hold=0;
for(f=0;f<f_len;f++){
res=(F[f]-'0')*(S[s]-'0') + hold+(temp[f+s]-'0');
temp[f+s]=res%10+'0';
hold=res/10;
if(f+s>r) r=f+s;
}
while(hold!=0){
res=hold+temp[f+s]-'0';
hold=res/10;
temp[f+s]=res%10+'0';
if(r<f+s) r=f+s;
f++;
}
}
for(;r>0 && temp[r]=='0';r--);
temp[r+1]='\0';
reverse(temp,result);
}
int main(){
char fir[MAX],sec[MAX],res[MAX];
while(scanf("%s%s",&fir,&sec)==2){
call_mult(fir,sec,res);
int len=strlen(res);
for(int i=0;i<len;i++)printf("%c",res[i]);
printf("\n");
}
return 0;
}

    OriginalL'auteur sakib_akon

  6. 0

    Vous devriez d'abord essayer d'utiliser 64 bits (long ou mieux, unsigned long si tout est positif). Avec unsigned long, vous pouvez fonctionner entre 0 et 18446744073709551615, avec de longues entre -9223372036854775808 et 9223372036854775807.

    Si elle n'est pas assez, alors il n'y a pas de solution facile, vous devez effectuer votre opération au niveau des logiciels à l'aide de tableaux de type unsigned long par exemple, et la surcharge de "<<" opérateur pour l'affichage. Mais ce n'est pas facile, et je suppose que vous êtes un débutant (n'en déplaise) l'examen de la question que vous avez posée.

    Si 64-bit de la représentation n'est pas assez pour vous, je pense que vous devriez envisager de représentation à virgule flottante, en particulier "double". Avec en double, on peut représenter les nombres entre environ -10^308 et 10^308. Vous ne serez pas en mesure d'avoir parfaitement exacte computatiosn sur un très grand nombre (chiffres les moins significatifs ne seront pas calculés), mais ce devrait être une bonne option assez pour tout ce que vous voulez ici.

    OriginalL'auteur Benjamin Barrois