C++实现两个大整数的相加（考虑到负数异常情况）

实现两个大整数的相加，首先应该排除直接使用int和long long的方法，这些方法很容易溢出，这里为了方便（是否可以使用更精简的结构存储？）采用char来存储整数，整体思路如下：

1. 对于整数n和m的字符串形式，按照数组索引的从大到小累加计算，直接将结果存储到对应的result字符串中，处理完毕后再将result逆序输出，需考虑0和-的输出情况；

2. 考虑到有负号的情况，一开始就需要判断负号字符，这里将(-,-)和(+,+)统一当成相加操作然后都是负号的话在结尾补上负号，对于(+,-)和(-,+)统一处理成（大-小）的形式然后在结尾补负号；比如对于20-500转换成-(-20+500)，对于-500+20准换成-(500-20)。

3. 这里需要使用标志位nTake记录是否进位或借位；

4. 还要考虑是否有异常字符出现，使用全局变量gInvalid记录有无异常。

#include<stdio.h>
#include<string.h>

#define Joshua_OJ

bool gInvalid = false;

// 0: equal, -1: n less m, 1: n bigger m
int AbsIsEqual(char* n, char* m, int n_start, int n_end, int m_start, int m_end)
{
    if ((n_end - n_start) > (m_end - m_start)) return 1;
    else if ((n_end - n_start) < (m_end - m_start)) return -1;
    else
    {
        int i = n_start;
        int j = m_start;
        while (i <= n_end && j <= m_end)
        {
            if (n[i] > m[j]) return 1;
            else if (n[i] < m[j]) return -1;
            ++i;
            ++j;
        }
    }
    return 0;
}

void BigNumberAdd(char* n, char* m, char* result)
{
    gInvalid = false;

    if (n == NULL || m == NULL)
    {
        gInvalid = true;
        return;
    }

    int n_index = strlen(n) - 1;
    int m_index = strlen(m) - 1;

    // 负数特别处理
    int n_start = 0;
    int m_start = 0;
    int n_signed = 1;
    int m_signed = 1;
    if (n[0] == '-')
    {
        n_start = 1;
        n_signed = -1;
    }
    if (m[0] == '-')
    {
        m_start = 1;
        m_signed = -1;
    }
    // 如果只有一个负数，转换为大数减小数再取负号，这样方便异号借位相减
    bool isResetPosNeg = false;
    if (n_signed == 1 && m_signed == -1)
    {
        int tag = AbsIsEqual(n, m, n_start, n_index, m_start, m_index);
        if (tag == -1)
        {
            n_signed = 0 - n_signed;
            m_signed = 0 - m_signed;
            isResetPosNeg = true;
        }
        else if (tag == 0)
        {
            result[0] = '0';
            result[1] = '';
            return;
        }
    }
    else if (n_signed == -1 && m_signed == 1)
    {
        int tag = AbsIsEqual(n, m, n_start, n_index, m_start, m_index);
        if (tag == 1)
        {
            n_signed = 0 - n_signed;
            m_signed = 0 - m_signed;
            isResetPosNeg = true;
        }
        else if (tag == 0)
        {
            result[0] = '0';
            result[1] = '';
            return;
        }
    }

    int index = 0;
    int nTake = 0;
    while (n_index >= n_start || m_index >= m_start)
    {
        int op1, op2;
        op1 = op2 = 0;

        if (n_index >= n_start && (n[n_index] < '0' || n[n_index] > '9'))
        {
            gInvalid = true;
            return;
        }
        if (m_index >= m_start && (m[m_index] < '0' || m[m_index] > '9'))
        {
            gInvalid = true;
            return;
        }

        if (n_index >= n_start) op1 = n[n_index] - '0';
        if (m_index >= m_start) op2 = m[m_index] - '0';
        if (n_signed == 1 && m_signed == -1) op2 = m_signed * op2;
        else if (m_signed == 1 && n_signed == -1) op1 = n_signed * op1;

        int nSum = op1 + op2 + nTake;
        if (nSum >= 10)
        {
            nSum -= 10;
            result[index] = nSum + '0';
            nTake = 1;
        }
        else if (nSum >= 0)
        {
            result[index] = nSum + '0';
            nTake = 0;
        }
        else
        {
            nSum = 10 + nSum;
            result[index] = nSum + '0';
            nTake = -1;
        }
        --n_index;
        --m_index;
        ++index;
    }

    if (nTake == 1) result[index++] = nTake + '0';
    else if (nTake == -1) result[index++] = '-';

    if (isResetPosNeg) result[index++] = '-';
    else if (n_signed == -1 && m_signed == -1) result[index++] = '-';

    result[index] = '';
}

// 从后往前打印出这个数字，并忽略开头的0
void PrintNumber(char* number)
{
    bool isBeginning0 = true;
    int length = strlen(number);

    for (int i = length - 1; i >= 0; --i)
    {
        if (i == length - 1 && number[i] == '-')
        {
            printf("%c", '-');
            continue;
        }

        if (isBeginning0 && number[i] != '0')
        {
            isBeginning0 = false;
        }

        if (!isBeginning0)
        {
            printf("%c", number[i]);
        }
        else
        {
            if (i == 0) printf("%c", '0');
        }
    }
}

int main(void)
{
    #ifdef Joshua_OJ
    freopen("in.txt", "r", stdin);
    #endif
    int num;
    char n[10000];
    char m[10000];
    char result[10002];

    scanf("%d", &num);
    while (num--)
    {
        scanf("%s %s", n, m);
        BigNumberAdd(n, m, result);
        if (gInvalid)
        {
            printf("%s
", "invalid number");
            continue;
        }
        PrintNumber(result);
        printf("
");
    }

    #ifdef Joshua_OJ
    fclose(stdin);
    #endif

    return 0;
}

输入第一个数表示有多少组数据，对于无效数据需要输出invalid number

Input：

15
200 -22
22 -200
-200 22
-22 200
0 0
000 000
-111 -111
-50 50
50 -50
-333 -333
222 -100
222.222 222
123222222222456 89701234562222222
11111111111111111 11111111111111100
9999999999999999999999999999999999999999999999999999999 9999999999999999999999999999999999999999999999999999999

Output：

178
-178
-178
178
0
0
-222
0
0
-666
122
invalid number
89824456784444678
22222222222222211
19999999999999999999999999999999999999999999999999999998