#include <stdio.h>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
using namespace std;
//我们把输入的两个操作数放在结构体中方便解决 
//首先，为了方便后面运算，我们先定义一个结构体把超长整数都定义为此类型 
struct doublelong{
    int d[1000];
    //定义一维数组D 
    int len;
    //下面定义构造函数，初始化，给予长度 
    doublelong(){
        memset(d,0,sizeof(d));
        //memset为初始化函数 数组d sizeof求出的d大小赋予空间 指向要填充的内存块d 
        //d用于存放 输入的两个操作数  
        //全初始化为0 
        len=0;
    }
}; 
//大整数使用字符串输入的，
//下面将字符串储存的大整数
//存放在结构体中
doublelong change(char str[]){
    doublelong a;
    a.len=strlen(str);//得出输入的大整数长度写入结构体中 
    for(int i=0;i<a.len;i++){
        a.d[i]=str[a.len-i-1]-'0';//这里把大整数的地位切换为高位 反序
    }
    return a; 
} 
//比较两个大整数的大小
int compare(doublelong a,doublelong b){
    int g;
    //greater此处返回更大数字 g的值为1时a的值更大，2时b的值更大，为0时两个数字的值相等 
    //由于我们此函数只比较两个输入数字的绝对值，由于运算方式是单独判断符号所以不对符号进行比较 
    if(a.len>b.len){
    g=1;return g;//a大于b
    }
    else if(a.len<b.len){
        g=2;
    return g;//a<b
    }
    else{
        for(int i=a.len-1;i>=0;i++)
        //一位位对比一位位读取向后读 
        {
            if(a.d[i]>b.d[i]) 
            {
                g=1;return g;
            }
            if(a.d[i]<b.d[i]) {
                g=2;return g;
            }
            if(a.d[i]=b.d[i]) {
                g=0;return g;
            }
        }
    } 
} 
//下面是大数的四则运算法则
doublelong add(doublelong a,doublelong b)
{
    doublelong c;
    int carry=0;//这里的carry表示进位
    for(int i=0;i<a.len||i<b.len;i++)
    //循环向后读取相加 
    {
        int temp=a.d[i]+b.d[i]+carry;
        c.d[c.len++]=temp%10;
        //将我们相加得到的temp值给写入我们的输出大整数c中去 
        carry=temp/10;//求是否有进位 
    } 
    if(carry!=0)
    {//如果最后一位的进位不为0，直接付给结果的最高位
       c.d[c.len++] =carry;
    }
    return c;//程序结束返回doublelong c
} 
void print(doublelong a)
{
    for(int i=a.len-1;i>=0;i--)
    {
        printf("%d",a.d[i]);
    }
}

简单注释了一下，如果还有问题，留言。问题解决请采纳

#include<iostream>
#include<string>
#include<cstdio>


using namespace std;
#define MAX 1010  


int main()
{
string std1, std2;
cin>>std1>>std2;
int length1 = std1.length();
int length2 = std2.length();
int a[MAX] = {0};
int b[MAX] = {0};
int result[2 * MAX] = {0};
int i = 0, j = 0;
//将字符串转移到数组中，以方便计算 ，注意是倒叙存储
//即字符串123存为321，为的是将低位放在前面方便计算 
for(i = length1 - 1, j = 0; i >= 0; i--, j++)
{
a[j] = std1[i] - '0';
}
for(i = length2 - 1, j = 0; i >= 0; i--, j++)
{
b[j] = std2[i] - '0';
}
//将结果储存在 resullt中，result[i + j] = a[i] * b[j]是关键算法 
for(i = 0; i < length1; i++)
{
for(j = 0; j < length2; j++)
{
result[i + j] += a[i] * b[j];
}
}

//从低位到高位进行进位

for(i = 0; i < (length1+length2); i++)
{
if(result[i] > 9)
{
result[i+1] += result[i]/10;
result[i] %= 10; 
}
}
//将前导0全部剔掉，比如我们结果是236，在result中
//是这样存储的63200……我们需要定位到第一个不为零的数，它的位置也就是i ，两数相乘，位数最多是两数位数之和

for(i = length1 + lengrh2; i >= 0 ; i--)
{
if(result[i] == 0) continue;
else break;
}
//接着i继续输出，就是我们的结果 
for(; i >=0; i--)
cout<<result[i];
return 0;
}

BigDecimal t("123456");

BigDecimal b("123456");

std::cout<< (t*b) << std::endl;

你这个是加法，不是乘法
https://blog.csdn.net/qq_44116998/article/details/100847957

看你的加法是 用int数组来做这个大整数,我只有思路，这东西想想都繁杂，不知你要做什么。
乘法是按位相乘的但是可以拆分为加法运算，
基本思路比如（12x110）就是12x10=10个12相加+12x100=100个12相加.12是原数，100和10是110的按位表示的数
那么按你的位来运算也就是数组的索引。左高右低，低位进高位。
原数x乘数=SUM（原数x乘数[i..0]）=也就是在乘数[i]的位上表示的数x原数的和;
这需要实现减法运算。用来在乘数[i]所表示数进行计数加法来求出乘数[i]x原数的和，
假设乘数[i-0]=1234,也就是从乘数左第i为到右边最低位0表示的数是1234。
乘数[i=3]x原数就是1000个原数相加，相当于调加法运算1000次。
乘数[i-0]x原数=1000x原数+200x原数+30x原数+4x原数；
而这1234次加运算需要减法运算来计数，从1000减到0的加法运算
并将结果保存然后追位加上后面的按位相乘。也可以从低位加起。
实现乘法还要在实现你的大整数减法。但这想想你可能还要实现超大数，^_^，用来装按位加法结果。
真是从入门到放弃。你会发现这算出来要好久好久。。。

写了一个简单的。

#include<iostream>
#include<string.h>
#define RADIX 100000
class BigDecimal
{
public:
    BigDecimal(const char *number)
    {
        memset(data,0,sizeof(data));
        if ( isNumber(number) )
        {
            parseInt(number);
        }
    }
    BigDecimal(const BigDecimal& t)
    {
        memcpy(this,&t,sizeof(BigDecimal));
    }
    friend std::ostream & operator<<(std::ostream& os,const BigDecimal& t)
    {
        os << t.data[t.datalen-1];
        os.width(4);
        os.fill('0');
        for( int i = t.datalen-1 ; i > 0 ; i-- )
        {
            os << t.data[i-1];
        }
        return os;
    }
    BigDecimal operator*(const BigDecimal& t)
    {
        BigDecimal temp("0");
        int plus = 0;
        int sum = 0;
        for( int i = 0 ; i < t.datalen ; i++ )
        {
            for( int j = 0 ; j < this->datalen ; j++ )
            {
                sum = temp.data[ i + j ] + plus + t.data[i] * this->data[j];
                temp.datalen=temp.datalen > i + j + 1 ? temp.datalen :i+j+1;
                temp.data[ i + j ] = sum % RADIX;
                plus = sum / RADIX;
            }
            while(plus)
            {
                temp.data[temp.datalen++]=plus%RADIX;
                plus /= RADIX;
            }
        }
        return temp;
    }
private:
    bool isNumber(const char *number)
    {
        if( NULL == number )
        {
            return false;
        }
        for( const char* iter = number ; *iter != 0 ; iter ++ )
        {
            if( '0' >= *iter && *iter >= '9' )
            {
                return false;
            }
        }
        return true;
    }
    bool parseInt(const char *number)
    {
        int len = strlen(number);
        int counter = 1;
        unsigned int sum = 0;
        datalen = 0;
        for( const char * iter = number + len - 1 ; iter + 1 != number ; iter-- )
        {
            sum = sum + ( *iter - '0' ) * counter;
            counter *= 10;
            if( counter%RADIX==0 )
            {
                data[datalen++] = sum;
                sum = 0;
                counter = 1;
            }
        }
        if( sum )
        {
            data[datalen++] = sum;
        }
        return true;
    }
private:
    unsigned long data[100];
    unsigned long datalen;
};
int main()
{
    BigDecimal t("123456");
    BigDecimal b("123456");
    std::cout<< (t*b) << std::endl;
}