大数相加与相乘

//先说相加

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    char num1[200];
    char num2[200];
    //用以存放反转后的字符串
    char num3[200];
    char num4[200];
    //用以存放结果,到时候从后往前输出即可
    char result[201];
    memset(num1, 0, 200);
    memset(num2, 0, 200);
    memset(num3, 0, 200);
    memset(num4, 0, 200);
    memset(result, 0, 201);
    cin >> num1 >> num2;
    //字符串反转
    int count = 0;
    for (int i = strlen(num1)-1; i >=0; --i)
    {
        num3[count++] = num1[i];
    }
    count = 0;
    for (int i = strlen(num2) - 1; i >= 0; --i)
    {
        num4[count++] = num2[i];
    }
    int maxlen = strlen(num1) > strlen(num2) ? strlen(num1) : strlen(num2);
    for (int i = 0; i < maxlen; ++i)
    {
        result[i] = num3[i] + num4[i] -'0';
    }
    //进位
    for (int i = 0; i < strlen(result); ++i)
    {
        if (result[i] > '9')
        {
            result[i] = result[i] - 10;
            result[i + 1] += 1;
        }
    }
    //为了防止这一位是进位上来的，而不是原来就有的，所以先判断一下然后加上    ‘0’
    if (result[strlen(result) - 1] < '0')
        result[strlen(result) - 1] += '0';
    //输出
    for (int i = strlen(result) - 1; i >= 0; --i)
    {
        cout << result[i];
    }


    system("pause");
    return 0;
}

//相乘(经测试只能乘不是很大的数，原因是某个小于10的数乘以一个大数还是不够安全，以后会加上加强版的，估计就是继续进行拆分，(●ˇ∀ˇ●))

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    char num1[100];
    char num2[100];
    //用以存放反转后的字符串
    char num3[100];
    char num4[100];
    //用以存放结果,到时候从后往前输出即可,这里换成long long类型而不是char类型（cahr方便输出），因为相加的时候数字比较小，char可以存下，相乘就不行了
    long long result[101];

    memset(num1, 0, 100);
    memset(num2, 0, 100);
    memset(num3, 0, 100);
    memset(num4, 0, 100);
    for (int i = 0; i < 101; ++i)
        result[i] = 0;
    cin >> num1 >> num2;
    //字符串反转
    int count = 0;
    for (int i = strlen(num1) - 1; i >= 0; --i)
    {
        num3[count++] = num1[i];
    }
    count = 0;
    for (int i = strlen(num2) - 1; i >= 0; --i)
    {
        num4[count++] = num2[i];
    }
    //开始乘啦
    int flag = 0;//result的位数
    for (int i = 0; i < strlen(num3); ++i)
    {
        count = 0;//位数

        for (int j = 0; j < strlen(num4); ++j)
        {
            result[flag]+=(num3[i]-'0')*(num4[j]-'0')*pow(10,count);
            ++count;
        }
        ++flag;
    }
    //进位
    for (int i = 0; i < 101; ++i)
    {
        if (result[i] > 9)
        {
            result[i + 1] += (result[i] / 10);
            result[i] %= 10;
        }
    }
    //防止输出不必要的0
    for (int i = 100;; --i)
    {
        if (result[i] != 0)
        {
            count = i;
            break;
        }
    }

    for (int i = count; i >= 0; --i)
        cout << result[i];

    system("pause");
    return 0;
}

//今天下课回来的路上一直在想着怎么解决昨晚遗留的问题，问题主要是即使分解了原来的数，但是第一个数的每一位还是要和另一个数相乘，当数字过大时显然不能存放下，所以还得进行分解，于是想到了二维数组。，下面是代码：（我分别测试了一下两者，发现差距还不小呢(●ˇ∀ˇ●)）

#include<iostream>
#include<cstring>
using namespace std;
//问为什么要在主函数外定义这些数组。他们现在属于全局变量，存放在中静态存储区中，而主函数中的数组存放在栈中，显然前者空间比较大，因此我们定义一个过大的数组或容器，应当把它把它定义为全局变量为宜
char num1[1000];
char num2[1000];
//用以存放反转后的字符串
char num3[1000];
char num4[1000];
//用以存放结果,到时候从后往前输出即可,这里换成long long类型而不是char类型（cahr方便输出），因为相加的时候数字比较小，char可以存下，相乘就不行了
long long result[1001][1001];//通过之前的教训，即使是这样也不能计算比较大的数，所以设成二维数组
int main()
{
    memset(num1, 0, 1000);
    memset(num2, 0, 1000);
    memset(num3, 0, 1000);
    memset(num4, 0, 1000);
    for (int i = 0; i < 1001; ++i)
        for(int j=0;j<1001;++j)
        result[i][j] = 0;
    cin >> num1 >> num2;
    //字符串反转
    int count = 0;
    for (int i = strlen(num1) - 1; i >= 0; --i)
    {
        num3[count++] = num1[i];
    }
    count = 0;
    for (int i = strlen(num2) - 1; i >= 0; --i)
    {
        num4[count++] = num2[i];
    }
    //开始乘啦
    int flag = 0;//result的位数
    for (int i = 0; i < strlen(num3); ++i)
    {
        count = i;//这样就能每次乘的时候自动往前填数，而不是始终从0开始，到时候还得移位

        for (int j = 0; j < strlen(num4); ++j)
        {
            result[i][count++] = (num3[i] - '0')*(num4[j] - '0');
        }
        ++flag;
    }
    //进位
    for (int i = 0; i <= flag; ++i)
    {
        for (int j = 0; j < 1001; ++j)
        {
            if (result[i][j] > 9)
            {
                result[i][j + 1] += result[i][j] / 10;
                result[i][j] %= 10;
            }
        }
    }
    //将所有的数相加
    int finalresult[1001];
    for (int i = 0; i < 1001; ++i)
        finalresult[i] = 0;
    for (int j = 0; j < 1001; ++j)
    {
        for (int i = 0; i < 1001; ++i)
        {
            finalresult[j] += result[i][j];
        }
    }
    //最终结果进位
    for (int i = 0; i < 1001; ++i)
    {
        if (finalresult[i] > 9)
        {
            finalresult[i + 1] += finalresult[i] / 10;
            finalresult[i] %= 10;
        }
    }
    //防止输出不必要的0
    for (int i = 1000;; --i)
    {
        if (finalresult[i] != 0)
        {
            count = i;
            break;
        }
    }
    //逆序输出
    for (; count >= 0; --count)
    {
        cout << finalresult[count];
    }
    system("pause");
    return 0;
}

下面是测试内容：
第一种相乘：

看，如果出现这种稍大些的数就溢出了。

再来看看第二种：

还是好好的呢(●ˇ∀ˇ●)

再来更变态的：