如何输入多组字符串数据

Question

现在只能输入一组数据，输出一组数据
怎样才能
输入
5+(102)-6
8(999+1)
1+5/(1-1)
7*2^3
输出
19
8000
INVALID
56

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <malloc.h>
#include <math.h>
#define MAXSIZE 100000

typedef struct
{
    float data[MAXSIZE];
    int top;
}number;

typedef struct
{
    char data[MAXSIZE];
    int top;
}sign;
void InitNumber(number* stack)
{
    stack->top = 0;
}
void GetTopNumber(number stack, float* e)
{
    if (stack.top == 0) return;
    else *e = stack.data[stack.top - 1];
}
void PushNumber(number* stack, float e)
{
    if (stack->top >= MAXSIZE) return;
    else stack->data[stack->top++] = e;
}

void PopNumber(number* stack, float* e)
{
    if (stack->top == 0) return;
    else *e = stack->data[--stack->top];
}

void InitSign(sign* stack)
{
    stack->top = 0;
}
void GetTopSign(sign stack, char* e)
{
    if (stack.top == 0) return;
    else *e = stack.data[stack.top - 1];
}

void PushSign(sign* stack, char e)
{
    if (stack->top >= MAXSIZE) return;
    else
    {
        stack->data[stack->top] = e;
        stack->top++;
    }
}
void PopSign(sign* stack, char* e)
{
    if (stack->top == 0) return;
    else *e = stack->data[--stack->top];
}
void Calculate(number* stack, char e)
{
    float num1, num2, result;
    PopNumber(stack, &num2);
    PopNumber(stack, &num1);
    switch (e)
    {
    case '+':
        result = num1 + num2;
        PushNumber(stack, result);
        break;
    case '-':
        result = num1 - num2;
        PushNumber(stack, result);
        break;
    case '*':
        result = num1 * num2;
        PushNumber(stack, result);
        break;
    case '/':
        if (num2 == 0) printf("INVALID");
        else
        {
            result = num1 / num2;
            PushNumber(stack, result);
            break;
        }
    case '^':
        result = pow(num1, num2);
        PushNumber(stack, result);
        break;
    }
}


number Num;
sign sig;
char expression[MAXSIZE];

int main()
{
    gets(expression);
    int length;
    length = strlen(expression);
    int i;
    float en, n;
    char es;
    InitNumber(&Num);
    InitSign(&sig);
    for (i = 0; i < length; i++)
    {
        if (expression[i] >= '0' && expression[i] <= '9')
        {
            n = expression[i] - '0';
            while (expression[i + 1] != '\0')
            {
                if (expression[i + 1] >= '0' && expression[i + 1] <= '9')
                {
                    n = n * 10 + expression[i + 1] - '0';
                    ++i;
                }
                else break;
            }
            PushNumber(&Num, n);
        }
        else if (expression[i] == '+' || expression[i] == '-' || expression[i] == '*' || expression[i] == '/' || expression[i] == '^' || expression[i] == '(' || expression[i] == ')')
        {
            switch (expression[i])
            {
            case '+':
                if (sig.data[sig.top - 1] != '+' && sig.data[sig.top - 1] != '-' && sig.data[sig.top - 1] != '*' && sig.data[sig.top - 1] != '/' && sig.data[sig.top - 1] != '^')
                    PushSign(&sig, '+');
                else
                {
                    while (sig.top > 0 && sig.data[sig.top - 1] != '(')
                    {
                        PopSign(&sig, &es);
                        Calculate(&Num, es);
                    }
                    PushSign(&sig, '+');
                }
                break;
            case '-':
                if (sig.data[sig.top - 1] != '+' && sig.data[sig.top - 1] != '-' && sig.data[sig.top - 1] != '*' && sig.data[sig.top - 1] != '/' && sig.data[sig.top - 1] != '^')
                    PushSign(&sig, '-');
                else
                {
                    while (sig.top > 0 && sig.data[sig.top - 1] != '(')
                    {
                        PopSign(&sig, &es);
                        Calculate(&Num, es);
                    }
                    PushSign(&sig, '-');
                }
                break;
            case '*':
                if (sig.data[sig.top - 1] != '*' && sig.data[sig.top - 1] != '/' && sig.data[sig.top - 1] != '^')
                    PushSign(&sig, '*');
                else
                {
                    while (sig.top > 0 && sig.data[sig.top - 1] != '(')
                    {
                        PopSign(&sig, &es);
                        Calculate(&Num, es);
                    }
                    PushSign(&sig, '*');
                }
                break;
            case '/':
                if (sig.data[sig.top - 1] != '*' && sig.data[sig.top - 1] != '/' && sig.data[sig.top - 1] != '^')
                    PushSign(&sig, '/');
                else
                {
                    while (sig.top > 0 && sig.data[sig.top - 1] != '(')
                    {
                        PopSign(&sig, &es);
                        Calculate(&Num, es);
                    }
                    PushSign(&sig, '/');
                }
                break;
            case '^':
                if (sig.data[sig.top - 1] != '^')
                    PushSign(&sig, '^');
                else
                {
                    while (sig.top > 0 && sig.data[sig.top - 1] != '(')
                    {
                        PopSign(&sig, &es);
                        Calculate(&Num, es);
                    }
                    PushSign(&sig, '^');
                }
            case '(':
                PushSign(&sig, '(');
                break;
            case ')':
                while (sig.data[sig.top - 1] != '(')
                {
                    PopSign(&sig, &es);
                    Calculate(&Num, es);
                }
                PopSign(&sig, &es);
            }
        }
    }
    while (sig.top > 0)
    {
        PopSign(&sig, &es);
        Calculate(&Num, es);
    }
    GetTopNumber(Num, &en);
    
    printf("%.0f\n", en);
    return 0;
}

而且好多输出是错的
求指正

Answer 1

计算器程序。
运行结果：

代码修改如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define STACK_INIT_SIZE 1000 //存储空间初始分配量 
#define STACKINCREMENT 100 //分配增量
typedef int Status;
typedef char ElemType;
typedef int Datatype;  //数据类型
typedef struct {
    ElemType* base;
    ElemType* top;
    int stacksize;
}OPTRStack;

typedef struct {
    Datatype* base;
    Datatype* top;
    int stacksize;
}OPNDStack;

//定义幂函数
int pow_m(int a, int b)
{
    int s = 1;
    int i = 0;
    for (i = 0; i < b; i++)
        s *= a;
    return s;
}

Status InitStackOPTR(OPTRStack& s) {
    s.base = (ElemType*)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if (!s.base) {
        exit(1);
    }
    s.top = s.base;
    s.stacksize = STACK_INIT_SIZE;
    return 0;
}//

Status InitStackOPND(OPNDStack& s) {
    s.base = (Datatype*)malloc(STACK_INIT_SIZE * sizeof(Datatype));
    if (!s.base) {
        exit(1);
    }
    s.top = s.base;
    s.stacksize = STACK_INIT_SIZE;
    return 0;
}//

ElemType GetTopOPTR(OPTRStack s) {//获取栈顶元素 
    ElemType e;
    if (s.top == s.base) {
        return 0;
    }
    e = *(s.top - 1);
    return e;
}

Datatype GetTopOPND(OPNDStack s) {//获取栈顶元素 
    Datatype e;  //MOD  
    if (s.top == s.base) {
        return 0;
    }
    e = *(s.top - 1);
    return e;
}


void PushOPTR(OPTRStack& s, ElemType e) {//插入元素e为新的栈顶元素 

    if (s.top - s.base >= s.stacksize) {//如果栈满，扩充空间 
        s.base = (ElemType*)realloc(s.base, (s.stacksize + STACKINCREMENT) * sizeof(ElemType));
        if (!s.base) {
            exit(1);
        }
        s.top = s.base + s.stacksize;
        s.stacksize += STACKINCREMENT;
    }
    *s.top++ = e;//赋值后栈顶指针+1 
}

void PushOPND(OPNDStack& s, Datatype e) {//插入元素e为新的栈顶元素   

    if (s.top - s.base >= s.stacksize) {//如果栈满，扩充空间 
        s.base = (Datatype*)realloc(s.base, (s.stacksize + STACKINCREMENT) * sizeof(Datatype));
        if (!s.base) {
            exit(1);
        }
        s.top = s.base + s.stacksize;
        s.stacksize += STACKINCREMENT;
    }
    *s.top++ = e;//赋值后栈顶指针+1 
}
ElemType PopOPTR(OPTRStack& s) {//删除栈顶元素 
    ElemType e;
    if (s.top == s.base) {
        return 1;
    }
    e = *--s.top;//栈顶指针-1，给e赋值 
    return 0;
}

Status PopOPND(OPNDStack& s) {//删除栈顶元素 
    Datatype e;
    if (s.top == s.base) {
        return 1;
    }
    e = *--s.top;//栈顶指针-1，给e赋值 
    return 0;
}

Status In_sign(ElemType c) {
    if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')' || c == '[' || c == ']' || c == '^')
        return 1;
    else
        return 0;
}
Status In_Num(ElemType e) {
    if (e >= '0' && e <= '9')
        return 1;
    else
        return 0;
}
Status Precede(ElemType op) {//存储函数的优先级
    switch (op) {
    case'+':
    case'-':
        return 1;
    case'*':
    case'/':
        return 2;
    case'^':
        return 3;
    case'(':
    case'[':
        return 4;
    case')':
    case']':
        return 0;
    }
}

Status arity(ElemType x) {//存储运算符的元数
    switch (x) {
    case'+':
    case'-':
    case'*':
    case'/':
    case'^':
        return 2;
    case'(':
    case')':
    case'[':
    case']':
        return 0;
    }
}
Datatype Operate(Datatype a, ElemType x, Datatype b) {//进行运算的函数 
    if (arity(x) == 2) {
        switch (x) {
        case '+':
            return a + b;
        case '-':
            return a - b;
        case '*':
            return a * b;
        case '/':
            return a / b;
        case'^':
            return pow_m(a, b);
        }
    }
}//Operate

Status check(ElemType left, ElemType right) {
    if (left == '(' && right == ')')
        return 1;
    else if (left == '[' && right == ']')
        return 1;
    else
        return 0;
}//判断括号

Status emptyOPND(OPNDStack s) {
    if (s.top == s.base || s.top < s.base)
        return 0;
    else
        return 1;
}//判断栈是否为空

Status emptyOPTR(OPTRStack s) {
    if (s.top == s.base || s.top < s.base)
        return 0;
    else
        return 1;
}//判断栈是否为空

//计算一条表达式
int CaculateAll(char* s) {
    OPTRStack OPTR, BRACKETS;//OPTR:运算符栈 OPND:运算数栈 BRACKETS:括号栈
    OPNDStack OPND;
    ElemType theta;
    InitStackOPTR(OPTR);
    InitStackOPND(OPND);
    InitStackOPTR(BRACKETS);
    Status len, n;
    
    len = strlen(s);
    s[len] = '#';
    len++;
    Status i;
    Datatype a, b, c = 0;
    for (i = 0; i < len; i++) {
        if (s[i] == '(' || s[i] == '[') {
            PushOPTR(BRACKETS, s[i]);
        }
        else if (s[i] == ')' || s[i] == ']') {
            if (check(GetTopOPTR(BRACKETS), s[i]) == 1) {
                PopOPTR(BRACKETS);
            }
            else
            {
                //printf("ERROR_02"); //括号不匹配
                return 0;
            }
        }
    }//判断括号是否匹配
    for (i = 0; i < len - 1; i++) {
        if (In_sign(s[i]) == 0 && In_Num(s[i]) == 0 && s[i] != '.') {
            //printf("ERROR_02"); //输入非法
            return 0;
        }//判断是否是数字和运算符号
    }
    i = 0;
    if (s[0] == '+' || s[0] == '-' || s[0] == '*' || s[0] == '/' || s[0] == '^' /* || s[0] == '.'*/) {
        //printf("ERROR_02");
        return 0;
    }
    while (s[i] != '#') {
        Datatype x = 0;
        if (In_Num(s[i]) == 1) {
            while (s[i] >= '0' && s[i] <= '9') {
                x *= 10;
                x += s[i++] - '0';
            }
            /*if (s[i] == '.') {  //小数部分
                double d = 0.1;
                i++;
                while (s[i] >= '0' && s[i] <= '9') {
                    x += ((s[i] - '0') * d);
                    d *= 0.1;
                    i++;
                }
            }*/
            PushOPND(OPND, x);
            continue;
        }
        else {
            ElemType theta = s[i];
            while (emptyOPTR(OPTR) == 1 && Precede(GetTopOPTR(OPTR)) >= Precede(s[i])) {
                if (arity(GetTopOPTR(OPTR)) == 2) {
                    a = GetTopOPND(OPND);
                    PopOPND(OPND);
                    b = GetTopOPND(OPND);
                    PopOPND(OPND);
                    if (a == 0 && GetTopOPTR(OPTR) == '/')
                    {
                        printf("INVALID\n");
                        return 0;
                    }
                    c = Operate(b, GetTopOPTR(OPTR), a);
                    PushOPND(OPND, c);
                    PopOPTR(OPTR);
                }
                else {
                    break;
                }
            }
            if (Precede(theta) == 0 && Precede(GetTopOPTR(OPTR)) == 4) {
                PopOPTR(OPTR);
            }
            if (Precede(theta) != 0) {
                PushOPTR(OPTR, theta);
            }
            i++;
        }
    }
    while (emptyOPTR(OPTR) == 1) {
        a = GetTopOPND(OPND);
        PopOPND(OPND);
        b = GetTopOPND(OPND);
        PopOPND(OPND);
        if (a == 0 && GetTopOPTR(OPTR) == '/')
        {
            printf("INVALID\n");
            return 0;
        }
        c = Operate(b, GetTopOPTR(OPTR), a);
        PushOPND(OPND, c);
        PopOPTR(OPTR);
    }
    printf("%d\n", GetTopOPND(OPND));
    return 1;
}

int main()
{
    char all[100][100] = { 0 }; //保存所有的公式 ，长度根据需要调整
    int nmb = 0, i = 0;
    while (scanf("%s", all[nmb]) != EOF)
        nmb++;
    for (i = 0; i < nmb; i++)
        CaculateAll(all[i]);
    return 0;
}