Умножить 2 1000-значных двоичных числа в C ++ [duplicate]

ints содержат только 32 бита. Когда результат умножения больше 2 ^ 31 - 1, результат переходит к большому отрицательному значению. Вместо использования типа данных int используйте long long int, который содержит 64 бита.

Сначала вы должны использовать 64-битные номера (длинный или лучший, без знака длинный, если все положительно). С unsigned long вы можете работать между 0 и 18446744073709551615, с длинными между -9223372036854775808 и 9223372036854775807.

Если этого недостаточно, то нет простого решения, вам нужно выполнить свою работу на программном уровне с помощью массивов например, unsigned long, и перегрузка "& lt; & lt; оператор для отображения. Но это не так просто, и я думаю, что вы новичок (без обид), учитывая вопрос, который вы задали.

Если для вас недостаточно 64-битного представления, я думаю, вам следует рассмотреть возможность с плавающей запятой представительство, особенно «двойное». С двойным вы можете представлять числа между примерно -10 ^ 308 и 10 ^ 308. Вы не сможете получить абсолютно точные вычисления на очень большом количестве (наименее значимые цифры не будут вычислены), но это должно быть достаточно хорошим вариантом для того, что вы хотите здесь сделать.

Результат переполняет int (а также std::uint64_t)

Вы должны использовать библиотеку BigInt.

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

Используйте подход с бумажной бумагой, как мы использовали в 2-м стандарте. Храните два номера в двух разных массивах в обратном порядке. И возьмите массив ans как размер (arr1.size + arr2.size). И также инициализируйте массив ans до нуля.

В вашем случае 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;
    }
}

Затем массив ans содержит результат. Пожалуйста, тщательно напечатайте массив ans. он может содержать начальный ноль.