正数高精度运算

功能描述：进行高长度非负数据的高精度相加运算
长度限制：受内存限制
实现原理：栈的调用
输入限制：正经用户的正常输入，相加的数据在同一换行前，数与数之间仅用一个空格隔开，以文件结束符为运行结束标志，输入样例如下：

2.99792 3.141592658
2.71828 520.1314

郑重声明：在符合要求的输入情况下，仍然可能存在未明BUG，如果发现，请留言
具体实现：

#include <stdio.h>
#include <stdlib.h>

#define STACK_INIT_SIZE 200
#define STACK_INCREMENT 100

typedef char ElemType;
typedef struct Stack
{
 	ElemType *base;
 	ElemType *top;
 	int stack_size;
} STACK, *PSTACK;

void init_stack(PSTACK stack);
void push(PSTACK stack, ElemType elem);
void pop(PSTACK stack, ElemType *elem);
void clear_stack(PSTACK stack);
int stack_length(PSTACK stack);
void destory_stack(PSTACK stack);

int main(void)
{
 	STACK integer_1, integer_2, result_integer;
 	STACK decimal_1, decimal_2, result_decimal;
 	STACK temp;
 	ElemType elem, a, b, c;
 	char ch;
 	int flag = 0;
 	int decimal = 0;
 	int carry = 0;
	int output_decimal = 0;

	init_stack(&integer_1);
	init_stack(&integer_2);
 	init_stack(&result_integer);
 	init_stack(&decimal_1);
 	init_stack(&decimal_2);
 	init_stack(&result_decimal);
 	init_stack(&temp);

	while((ch = getchar()) != EOF)
 	{
  		if(ch != '\n')
  		{
   			if(ch == ' ')
   			{
    				flag = 1;
    				decimal = 0;
    				ch = getchar();
   			}
   			
   			if(!flag)    // 第一个数 
   			{
    				if(ch == '.')
    				{
     					decimal = 1;
     					ch = getchar();
    				}
    				if(!decimal)    // 整数部分 
    				{
     					push(&integer_1, ch);
    				}
    				else    // 小数部分 
    				{
     					push(&decimal_1, ch);
    				}
   			}
   			else    // 第二个数
   			{
    				if(ch == '.')
    				{
     					decimal = 1;
     					ch = getchar();
    				}
    				if(!decimal)    // 整数部分
    				{
     					push(&integer_2, ch);
    				}
    				else    // 小数部分 
    				{
     					push(&decimal_2, ch);
    				}
   			}
  		}
  		else
  		{
   			if(stack_length(&decimal_1) != stack_length(&decimal_2))    // 进行小数部分相加 
   			{
    				while(stack_length(&decimal_1) > stack_length(&decimal_2))
    				{
     					pop(&decimal_1, &c);
     					push(&result_decimal, c);
    				}
    				while(stack_length(&decimal_1) < stack_length(&decimal_2))
    				{
     					pop(&decimal_2, &c);
     					push(&result_decimal, c);
    				}
   			}
   			while(stack_length(&decimal_1))
   			{
    				pop(&decimal_1, &a);
    				pop(&decimal_2, &b);
    				c = (a-'0') + (b-'0') + carry + '0';
    				if(c > '9')
    				{
     					c = c - 10;
     					carry = 1;
    				}
    				else
    				{
     					carry = 0;
    				}
    				push(&result_decimal, c);
   			}
   			if(stack_length(&integer_1) != stack_length(&integer_2))    // 进行整数部分相加 
   			{
    				if(stack_length(&integer_1) > stack_length(&integer_2))
    				{
     					while(stack_length(&integer_1))
     					{
      						if(stack_length(&integer_2) != 0)
      						{
       							pop(&integer_1, &a);
       							pop(&integer_2, &b);
       							c = (a-'0') + (b-'0') + carry + '0';
       							if(c > '9')
       							{
        							c = c - 10;
        							carry = 1;
       							}
       							else
       							{
        							carry = 0;
       							}
       							push(&result_integer, c);
      						}
      						else
      						{
       							pop(&integer_1, &a);
       							c = (a-'0') + carry + '0';
       							if(c > '9')
       							{
        							c = c - 10;
        							carry = 1;
       							}
       							else
       							{
        							carry = 0;
       							}
       							push(&result_integer, c);
      						}
     					}
     					if(carry == 1)
     					{
      						push(&result_integer, '1');
      						carry = 0;
     					}
    				}
    				if(stack_length(&integer_1) < stack_length(&integer_2))
    				{
     					while(stack_length(&integer_2))
     					{
      						if(stack_length(&integer_1) != 0)
      						{
       							pop(&integer_1, &a);
       							pop(&integer_2, &b);
       							c = (a-'0') + (b-'0') + carry + '0';
       							if(c > '9')
       							{
        							c = c - 10;
        							carry = 1;
       							}
       							else
      		 					{
        							carry = 0;
       							}
       							push(&result_integer, c);
      						}
      						else
      						{
       							pop(&integer_2, &a);
       							c = (a-'0') + carry + '0';
       							if(c > '9')
       							{
        							c = c - 10;
        							carry = 1;
       							}
       							else
       							{
        							carry = 0;
       							}
       							push(&result_integer, c);
      						}
     					}
     					if(carry == 1)
     					{
      						push(&result_integer, '1');
      						carry = 0;
     					}
    				}
   			}
   			else
   			{
    				while(stack_length(&integer_1))
    				{
     					pop(&integer_1, &a);
     					pop(&integer_2, &b);
     					c = (a-'0') + (b-'0') + carry + '0';
     					if(c > '9')
     					{
      						c = c - 10;
      						carry = 1;
     					}
     					else
     					{
      						carry = 0;
     					}
     					push(&result_integer, c);
    				}
    				if(carry == 1)
    				{
     					push(&result_integer, '1');
     					carry = 0;
    				}
   			}
   			while(stack_length(&result_decimal))
   			{
    				pop(&result_decimal, &elem);
    				push(&temp, elem);
   			}
   			while(stack_length(&temp))
   			{
    				pop(&temp, &elem);
    				if(elem != '0')
    				{
     					output_decimal = 1;
    				}
    				if(output_decimal)
    				{
     					push(&result_decimal, elem);
    				}
   			}
   			while(stack_length(&result_integer))
   			{
    				pop(&result_integer, &elem);
    				putchar(elem);
   			}
   			if(output_decimal)
   			{
    				putchar('.');
    				while(stack_length(&result_decimal))
    				{
     					pop(&result_decimal, &elem);
     					putchar(elem);
    				}
   			}
   			putchar('\n');
   			
   			clear_stack(&integer_1);
   			clear_stack(&integer_2);
   			clear_stack(&result_integer);
   			clear_stack(&decimal_1);
   			clear_stack(&decimal_2);
   			clear_stack(&result_decimal);
   			clear_stack(&temp);
   			flag = 0;
   			decimal = 0;
   			output_decimal = 0;
  		}
 	}

	destory_stack(&integer_1);
 	destory_stack(&integer_2);
 	destory_stack(&result_integer);
 	destory_stack(&decimal_1);
 	destory_stack(&decimal_2);
 	destory_stack(&result_decimal);
 	destory_stack(&temp); return 0;
}

void init_stack(PSTACK stack)
{
 	stack->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
 	if(!stack->base)
 	{
  		exit(1);
 	}
 	
 	stack->top = stack->base;
 	stack->stack_size = STACK_INIT_SIZE;
}

void push(PSTACK stack, ElemType elem)
{
 	if(stack->top - stack->base >= stack->stack_size)
 	{
  		stack->base = (ElemType *)realloc(stack->base, (stack->stack_size+STACK_INCREMENT) * sizeof(ElemType));
  		if(!stack->base)
  		{
   			exit(1);
  		}

		stack->top = stack->base + stack->stack_size;
  		stack->stack_size = stack->stack_size + STACK_INCREMENT;
 	}

	*(stack->top) = elem;
 	stack->top++;
}

void pop(PSTACK stack, ElemType *elem)
{
 	if(stack->top == stack->base)
 	{
  		return;
 	}

	*elem = *--(stack->top);
}

void clear_stack(PSTACK stack)
{
 	stack->top = stack->base;
}

int stack_length(PSTACK stack)
{
 	return stack->top - stack->base;
}

void destory_stack(PSTACK stack)
{
 	free(stack->base); stack->base = NULL;
 	stack->top = NULL;
}