当计算的结果较大时，结果会是负数

当计算的结果为较大值时会为，例如20乘20为0三个六相乘为负四十


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

#define MAXSIZE 100    //顺序栈存储空间的初始分配址
#define OK  1
#define ERROR  0
#define OVERFLOW -2

typedef int  Status;
typedef char SElemType;

typedef struct
{
    char* base;      //栈底指针
    char* top;       //栈顶指针
    int stacksize;   //栈可用的最大容量
}SqStack;


Status InitStack(SqStack* S)
{                              //构造一个空栈s
    S->base = (char*)malloc(MAXSIZE * sizeof(char));//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
    if (!S->base) exit(OVERFLOW);         //存储分配失败
    S->top = S->base;            //top初始为base，空栈
    S->stacksize = MAXSIZE;     //stacksize置为栈的最大容量MAXSIZE
    return OK;
}

Status Push(SqStack* S, char e)
{                                    //插入
    if (S->top - S->base == S->stacksize) return ERROR;    //栈满
    *S->top++ = e;           //元素e压入栈顶，栈顶指针加1
    return OK;
}

Status Pop(SqStack* S, char* e)
{                                 //删除s的栈顶元素，用e返回其值
    if (S->top == S->base) return ERROR;   //判断栈空
    *e = *--S->top;    //栈顶指针减1，将栈顶元素赋给e
    return OK;
}

SElemType GetTop(SqStack S)
{                     //返回s的栈顶元素，不修改栈顶指针
    if (S.top != S.base)   //栈非空
        return *(S.top - 1);   //返回栈顶元素的值，栈顶指针不变
}

Status In(char e)
{//判断读入字符是否为运算符
    if (e == '+' || e == '-' || e == '*' || e == '/' || e == '(' || e == ')' || e == '#')
        return OK;//是
    else
        return ERROR;//不是
}

//判断运算符优先级
char Precede(char theta1, char theta2)
{
    if ((theta1 == '(' && theta2 == ')') || (theta1 == '#' && theta2 == '#'))
    {
        return '=';
    }
    else if (theta1 == '(' || theta1 == '#' || theta2 == '(' ||( theta1 == '+' || theta1 == '-') && (theta2 == '*' || theta2 == '/'))
    {
        return '<';
    }
    else
        return '>';
}
//计算两数计算结果 

int  Operate(int  first, char theta, int second)
{

    //int result;
    switch (theta)
    {
    case'+':
        return first + second ;
        break;
    case'-':
        return first  -second  ;
        break;
    case'*':
        return first * second  ;      
        break;
    case'/':
        return  first/second  ;
        break;

    }
    return 0;

}

char EvaluateExpression()
{//算术表达式求值的算符优先算法，设OPTR和OPND分别为运算符栈和操作数栈
    SqStack OPND, OPTR;
    int ch; //把读入的字符转换为整数型，即ASCII表值
    char a, b, theta, x; //ch为当前读入字符, theta为运算符，x仅仅只是变量寄存弹出值，对计算表达式无影响
    InitStack(&OPND); //初始化OPND栈，寄存操作数和运算结果
    InitStack(&OPTR); //初始化OPTR栈，寄存运算符
    Push(&OPTR, '#');
    ch = getchar();
    while (ch != '#' || GetTop(OPTR) != '#')
    {
        printf(" %c\n", ch);
        if (!In(ch))//ch不是运算符则进OPND栈
        {
            ch = ch - 48;//数字字符转换为对应整数
            Push(&OPND, ch);
            ch = getchar();
        }
        else
        {
            switch (Precede(GetTop(OPTR), ch))
            {//优先级选择
            case '<':
                Push(&OPTR, ch);
                ch = getchar();
                break;
            case '>':
                Pop(&OPTR, &theta);
                Pop(&OPND, &b);
                Pop(&OPND, &a);
                Push(&OPND, Operate(a, theta, b));
                break;
            case '=':
                Pop(&OPTR, &x);
                ch = getchar();
                break;
            }
        }
    }
    return GetTop(OPND);
}
int main()
{
    printf("请输入算术表达式，并以#结束：");
    printf("表达式结果：%d", EvaluateExpression());

    return 0;
}

```

较大是多大？是否超出了数据类型允许的最大值？

这篇文章：用数组求出斐波那契数列前20项，并且每5项换行一次也许能够解决你的问题，你可以看下
除此之外, 这篇博客: 专升本C语言中的 输入20个整数，用一维数组存储，请编程求其中最大值和次大值并输出。 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

//方法一
#include<stdio.h>
#define N 20
void main() {

	int i, j, a[N], max1, max2;
	for ( i = 0; i < N; i++)
	{
		scanf("%d", &a[i]);
	}
	//打擂台法求最大值，大的当擂主
	max1 = a[0];
	for ( i = 1; i < N; i++)
	{
		if (a[i] > max1) {
			max1 = a[i];
			j = i;//提取擂主的下标
		}
	}
	for ( i = j; i < N-1; i++)
	{
		a[i] = a[i + 1];//后面一个数覆盖擂主的数，去除擂主
	}
	//继续打擂，求次大值
	max2 = a[0];
	for (i = 1; i < N-1; i++)
	{
		if (a[i] > max2) {
			max2 = a[i];
		}
	}
	printf("最大值%d，次大值%d",max1, max2);
}

//方法二
#include<stdio.h>
#define N 20
void main() {

	int i, j, a[N],t;
	for (i = 0; i < N; i++)
	{
		scanf("%d", &a[i]);
	}
	//使用冒泡排序但是只排序两次 就是把最大的和次大的放后面
	for (i = 0; i < 2; i++)
	{
		for ( j = 0; j < N-1-i; j++)
		{
			if (a[j] > a[j+1]) {
				t = a[j];
				a[j] = a[j + 1];
				a[j+1] = t;
			}
		}
	}
	
	printf("最大值%d，次大值%d", a[N-1], a[N-2]);
}