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 ;
     else if ((n_end - n_start) < (m_end - m_start)) return -;
     else
     {
         int i = n_start;
         int j = m_start;
         while (i <= n_end && j <= m_end)
         {
             if (n[i] > m[j]) return ;
             else if (n[i] < m[j]) return -;
             ++i;
             ++j;
         }
     }
     return ;
 }

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

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

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

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

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

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

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

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

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

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

     result[index] = '\0';
 }

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

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

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

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

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

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

     #ifdef Joshua_OJ
     fclose(stdin);
     #endif

     return ;
 }

输入第一个数表示有多少组数据，对于无效数据需要输出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