這期內(nèi)容當(dāng)中小編將會給大家?guī)碛嘘P(guān)c語言實現(xiàn)表達式求值的方法，以專業(yè)的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

成都創(chuàng)新互聯(lián)公司始終堅持【策劃先行，效果至上】的經(jīng)營理念，通過多達10多年累計超上千家客戶的網(wǎng)站建設(shè)總結(jié)了一套系統(tǒng)有效的全網(wǎng)整合營銷推廣解決方案，現(xiàn)已廣泛運用于各行各業(yè)的客戶，其中包括：成都汽車玻璃修復(fù)等企業(yè)，備受客戶贊美。

一.不包括括號運算

#include  
#include  
#include  
#include  
#include  
#define STACK_INIT_SIZE 100  
using namespace std;  
typedef struct  
{  
    char date[STACK_INIT_SIZE];  
    int top;  
}OptrStack;     //操作符結(jié)構(gòu)體    
  
typedef struct  
{  
    double date[STACK_INIT_SIZE];  
    int top;  
}OpndStack;     //操作數(shù)結(jié)構(gòu)體    
  
//操作符相關(guān)操作  
OptrStack *Init_OptrStack();    //置棧空  
int Empty_OptrStack(OptrStack *s);//判空棧  
int Push_OptrStack(OptrStack *s, char x);//入棧(注意：判斷棧是否已滿)  
char Pop_OptrStack(OptrStack *s, char x);//出棧(注意：判斷棧是否已空)  
char GetTop_OptrStack(OptrStack *s, char x);//取棧頂元素，先判空  
  
//操作數(shù)相關(guān)操作  
OpndStack *Init_OpndStack();//置?？? 
int Empty_OpndStack(OpndStack *t);//判空棧  
int  Push_OpndStack(OpndStack *t, double y);//入棧(注意：判斷棧是否已滿)  
double Pop_OpndStack(OpndStack *t, double y);//出棧(注意：判斷棧是否已空)  
double GetTop_OpndStack(OpndStack *t, double y);//取棧頂元素  
  
//表達式求值函數(shù)  
void Error(char *s);                  //錯誤處理函數(shù)  
int Judge_optr(char ch);              //用于判斷字符ch是否是運算符  
int Operate(int a, int b, char top);  //用于計算當(dāng)前的值，并將該值返回  
void Jsbds_operate(char str[]);        //讀入一個簡單算術(shù)表達式的值  
  
//操作符函數(shù)實現(xiàn)部分  
OptrStack *Init_OptrStack()  
{  
    OptrStack *s;  
    s = (OptrStack *)malloc(sizeof(OptrStack));  
    s->top = -1;  
    return s;  
}  
int Empty_OptrStack(OptrStack *s)//判空棧  
{  
    if (s->top != -1)  
        return 1;  
    else  
        return 0;  
}  
int  Push_OptrStack(OptrStack *s, char x)//入棧(注意：判斷棧是否已滿)  
{  
    if (s->top == (STACK_INIT_SIZE - 1))  
    {  
        return 0;  
    }  
    else  
        s->date[++s->top] = x;  
    return 1;  
  
}  
char Pop_OptrStack(OptrStack *s, char x)//出棧(注意：判斷棧是否已空)  
{  
    if (!Empty_OptrStack(s))  
    {  
        return 0;  
    }  
    else  
    x = s->date[s->top];  
    s->top--;  
    return x;  
}  
char GetTop_OptrStack(OptrStack *s, char x)//取棧頂元素，先判空  
{  
    if (!Empty_OptrStack(s))  
    {  
        return 0;  
    }  
    else  
        x = s->date[s->top];  
    return x;  
}  
//操作數(shù)函數(shù)實現(xiàn)部分  
OpndStack *Init_OpndStack()//置棧空  
{  
    OpndStack *t;  
    t = (OpndStack*)malloc(sizeof(OpndStack));  
    t->top = -1;  
    return t;  
}  
int Empty_OpndStack(OpndStack *t)//判空棧  
{  
    if (t->top != -1)  
        return 1;  
    else  
        return 0;  
}  
int  Push_OpndStack(OpndStack *t, double y)//入棧(注意：判斷棧是否已滿)  
{  
    if (t->top == (STACK_INIT_SIZE - 1))  
    {  
        return 0;  
    }  
    else  
        t->date[++t->top] = y;  
    return 1;  
}  
double Pop_OpndStack(OpndStack *t, double y)//出棧(注意：判斷棧是否已空)  
{  
    if (!Empty_OpndStack(t))  
    {  
        return 0;  
    }  
    else   
    y = t->date[t->top];  
    t->top--;  
    return y;  
}  
double GetTop_OpndStack(OpndStack *t, double y)//取棧頂元素  
{  
    if (!Empty_OpndStack(t))  
    {  
        return 0;  
    }  
    y = t->date[t->top];  
    return y;  
}  
  
//表達式求值函數(shù)實現(xiàn)  
void Error(char *s)   //錯誤處理函數(shù)  
{  
    std::cout << s << endl;  
    exit(1);  
}  
int Judge_optr(char top)//用于判斷字符ch是否是運算符  
{  
    int x;  
    //cout << top << "test" << endl;  
    switch (top)  
    {  
    case '+':  
    case '-':  
        x = 1; break;  
    case '*':  
    case '/':  
        x = 2; break;  
    }  
    return x;  
}  
double Operate(double b, double a, char top)  //用于計算當(dāng)前的值，并將該值返回  
{  
    double c = 0;  
    switch (top)  
    {  
    case '+':  
        c = b + a;  
        break;  
    case '-':  
        c = b - a;  
        break;  
    case '*':  
        c = b * a;  
        break;  
    case '/':  
        if (a == 0)  
        {  
            printf("分母為零!\n");  
            return 0;  
        }  
        else  
            c = b / a;  
        break;  
    default:  
        printf("輸入的字符非法!\n");  
        break;  
    }  
    return c;  
}  
void Jsbds_operate(char str[])             //讀入一個簡單算術(shù)表達式,并將計算結(jié)果返回到主函數(shù)  
{  
    OptrStack *optr = Init_OptrStack();     //初始化操作符棧    
    OpndStack *opnd = Init_OpndStack();     //初始化操作數(shù)棧    
    int i, j;                               //i,j為循環(huán)變量，a,b接收從操作數(shù)棧中出棧的元素    
    double f;                               //接收將字符數(shù)轉(zhuǎn)換為浮點數(shù)的值    
    double a = 0;  
    double b = 0;  
    double c = 0;  
    char d[100];                           //儲存字符串中連續(xù)的‘?dāng)?shù)’    
    char top = 0;                          //接收從操作符棧中出棧的元素   
    for (i = 0; str[i]; i++)               //將字符串中的元素按順序入到棧中  
    {  
        switch (str[i])  
        {  
        case '+':  
        case '-':  
            /*先判斷當(dāng)前運算符與操作符棧棧頂元素的優(yōu)先級，如果高于棧頂元素，則入棧； 
            小于棧頂元素，則從操作數(shù)棧中依次出兩個數(shù)，并將操作符棧中棧頂元素出棧， 
            再將從操作數(shù)棧中出的兩個數(shù)，按從操作符棧棧中出的運算符運算， 
            并將結(jié)果壓入操作數(shù)棧中，再將當(dāng)前的操作符壓入操作符棧中。*/  
            if (!Empty_OptrStack(optr))  //當(dāng)操作符棧為空的時候壓棧保存  
            {  
                Push_OptrStack(optr, str[i]);  
            }  
            else  
            {  
                a = Pop_OpndStack(opnd, a); //接收從操作數(shù)棧中出棧的元素    
                b = Pop_OpndStack(opnd, b); //接收從操作數(shù)棧中出棧的元素    
                top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素    
                c = Operate(b, a, top);  
                Push_OpndStack(opnd, c);  
                //將計算后的值壓入操作數(shù)棧中    
                Push_OptrStack(optr, str[i]);  
            }  
            break;  
        case '*':  
        case '/':  
            if ((!Empty_OptrStack(optr))||(Judge_optr(str[i]) > Judge_optr(GetTop_OptrStack(optr, top))))  
            { //當(dāng)操作符棧為空或者該操作符的優(yōu)先級大于棧頂元素的優(yōu)先級是入棧保存  
                Push_OptrStack(optr, str[i]);  
            }  
            else  
            {  
                a = Pop_OpndStack(opnd, a);//接收從操作數(shù)棧中出棧的元素    
                b = Pop_OpndStack(opnd, b);//接收從操作數(shù)棧中出棧的元素    
                top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素   
                c = Operate(b, a, top);  
                Push_OpndStack(opnd, c);  
                //將計算后的值壓入操作數(shù)棧中    
                Push_OptrStack(optr, str[i]);  
            }  
        case '\0':  
            break;  
        default:  
            j = 0;  
            do  
            {  
                d[j++] = str[i];  
                i++;  
            } while (str[i] >= '0' && str[i] <= '9');  //可存入一個或多個數(shù)字字符    
            d[j] = '\0';                  //將輸入的連續(xù)多個數(shù)字字符拼成了字符串    
            i--;  
            f = atof(d);                //調(diào)用庫函數(shù)atoi()將字符數(shù)轉(zhuǎn)換為浮點數(shù)    
            Push_OpndStack(opnd, f);    //將轉(zhuǎn)換后的數(shù)壓入操作數(shù)棧中    
            break;  
        }  
    }  
    while (Empty_OptrStack(optr))  //當(dāng)操作符棧不為空的時候執(zhí)行  
    {  
        a = Pop_OpndStack(opnd, a);//接收從操作數(shù)棧中出棧的元素   
        b = Pop_OpndStack(opnd, b);//接收從操作數(shù)棧中出棧的元素    
        top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素    
        c = Operate(b, a, top);  
        Push_OpndStack(opnd, c);  
        //將計算后的值壓入操作數(shù)棧中       
    }  
    cout << "該表達式的計算結(jié)果為：";  
    std::cout << GetTop_OpndStack(opnd, c) << endl;//將操作數(shù)棧中的元素(即表達式的最終結(jié)果)打印出來    
}  
  
int main()  
{  
    char str[100];  
    std::cout << "請輸入算術(shù)表達式(功能：+，-，*，/)" << endl;  
    cin >> str;  
    Jsbds_operate(str);  
    return 0;  
}

二.包括括號運算（粘貼修改部分）

int Judge_optr(char top)//用于判斷字符ch是否是運算符
{
int x;
//cout << top << "test" << endl;
switch (top)
{
case '(':
x = 0; break;
case '+':
case '-':
x = 1; break;
case '*':
case '/':
x = 2; break;
case ')':
x = 3; break;
}
return x;
}
double Operate(double b, double a, char top)  //用于計算當(dāng)前的值，并將該值返回
{
double c = 0;
switch (top)
{
case '+':
c = b + a;
break;
case '-':
c = b - a;
break;
case '*':
c = b * a;
break;
case '/':
if (a == 0)
{
printf("分母為零!\n");
return 0;
}
else
c = b / a;
break;
default:
printf("輸入的字符非法!\n");
break;
}
return c;
}
void Jsbds_operate(char str[])             //讀入一個簡單算術(shù)表達式,并將計算結(jié)果返回到主函數(shù)
{
OptrStack *optr = Init_OptrStack();     //初始化操作符棧  
OpndStack *opnd = Init_OpndStack();     //初始化操作數(shù)棧  
int i, j;                               //i,j為循環(huán)變量，a,b接收從操作數(shù)棧中出棧的元素  
double f;                               //接收將字符數(shù)轉(zhuǎn)換為浮點數(shù)的值  
double a = 0;
double b = 0;
double c = 0;
char d[100];                           //儲存字符串中連續(xù)的‘?dāng)?shù)’  
char top = 0;                          //接收從操作符棧中出棧的元素 
for (i = 0; str[i]; i++)               //將字符串中的元素按順序入到棧中
{
switch (str[i])
{
case '(':
case '+':
case '-':
/*先判斷當(dāng)前運算符與操作符棧棧頂元素的優(yōu)先級，如果高于棧頂元素，則入棧；
小于棧頂元素，則從操作數(shù)棧中依次出兩個數(shù)，并將操作符棧中棧頂元素出棧，
再將從操作數(shù)棧中出的兩個數(shù)，按從操作符棧棧中出的運算符運算，
并將結(jié)果壓入操作數(shù)棧中，再將當(dāng)前的操作符壓入操作符棧中。*/
if ((!Empty_OptrStack(optr)) || (Judge_optr(str[i]) > Judge_optr(GetTop_OptrStack(optr, top)))||(str[i]=='('))  //當(dāng)操作符棧為空的時候壓棧保存
{
Push_OptrStack(optr, str[i]);
}
else
{
a = Pop_OpndStack(opnd, a); //接收從操作數(shù)棧中出棧的元素  
b = Pop_OpndStack(opnd, b); //接收從操作數(shù)棧中出棧的元素  
top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素  
c = Operate(b, a, top);
Push_OpndStack(opnd, c);
//將計算后的值壓入操作數(shù)棧中  
Push_OptrStack(optr, str[i]);
}
break;
case '*':
case '/':
if ((!Empty_OptrStack(optr)) || (Judge_optr(str[i]) > Judge_optr(GetTop_OptrStack(optr, top))) || (str[i] == '('))
{ //當(dāng)操作符棧為空或者該操作符的優(yōu)先級大于棧頂元素的優(yōu)先級是入棧保存
Push_OptrStack(optr, str[i]);
}
else
{
a = Pop_OpndStack(opnd, a);//接收從操作數(shù)棧中出棧的元素  
b = Pop_OpndStack(opnd, b);//接收從操作數(shù)棧中出棧的元素  
top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素 
c = Operate(b, a, top);
Push_OpndStack(opnd, c);
//將計算后的值壓入操作數(shù)棧中  
Push_OptrStack(optr, str[i]);
}
break;
case ')':
Push_OptrStack(optr, str[i]);
break;
case '\0':
break;
default:
j = 0;
do
{
d[j++] = str[i];
i++;
} while (str[i] >= '0' && str[i] <= '9');  //可存入一個或多個數(shù)字字符  
d[j] = '\0';                  //將輸入的連續(xù)多個數(shù)字字符拼成了字符串  
i--;
f = atof(d);                //調(diào)用庫函數(shù)atoi()將字符數(shù)轉(zhuǎn)換為浮點數(shù)  
Push_OpndStack(opnd, f);    //將轉(zhuǎn)換后的數(shù)壓入操作數(shù)棧中  
break;
}
}
while (Empty_OptrStack(optr))  //當(dāng)操作符棧不為空的時候執(zhí)行
{
if ((GetTop_OptrStack(optr, top) == ')') || (GetTop_OptrStack(optr, top) == '('))
{
top=Pop_OptrStack(optr, top);
}
else
{
a = Pop_OpndStack(opnd, a);//接收從操作數(shù)棧中出棧的元素 
b = Pop_OpndStack(opnd, b);//接收從操作數(shù)棧中出棧的元素  
top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素  
c = Operate(b, a, top);
Push_OpndStack(opnd, c);
//將計算后的值壓入操作數(shù)棧中  
}
}
cout << "該表達式的計算結(jié)果為：";
std::cout << GetTop_OpndStack(opnd, c) << endl;//將操作數(shù)棧中的元素(即表達式的最終結(jié)果)打印出來  
}

上述就是小編為大家分享的c語言實現(xiàn)表達式求值的方法了，如果您也有類似的疑惑，不妨參照上述方法進行嘗試。如果想了解更多相關(guān)內(nèi)容，請關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊。