(C语言版)科学计算器设计
科学计算器设计(C语言版)
学校:
学院:计算机信息工程学院
语言
平台:
作者:
日期:
一、背景和目的
计算器是现代日常生活中使用较为频繁的工具之一,常用的计算器有简易版和科学计算器两种模式。简易版的计算器不支持表达式运算,每次只能输入一个数据或者运算符来计算,而科学计算器除了容纳简易版计算器的功能外,还支持表达式运算,用户可以输入一个合法的算术表达式来得到所需的结果。
常用的算术表达式有三种,前缀表达式,中缀表达式和后缀表达式。
中缀表达式:我们平时书写的表达式就是中缀表达式,形如（a＋b)*（c+ｄ）,事实上是运算表达式形成的树的中序遍历,特点是用括号来描述优先级。
后缀表达式:也叫逆波兰表达式,事实上是算数表达式形成的树的后序遍历。中缀表达式(a+ｂ）*(ｃ+ｄ)的后缀表达式是ab+cd+＊，它的特点就是遇到运算符就立刻进行运算。
前缀表达式：算数表达式形成的树的前序遍历。
日常所书写的是中缀表达式，但是计算机内部是用后缀表达式计算，所以此程序的用户使用中缀表达式作为输入，程序将中缀表达式转化为后缀表达式后再进行运算并输出结果。
由于今后工作将使用Ｃ语言进行开发,而C语言是一个功能强大并且很灵活的语言,为复习和巩固Ｃ编程,故决定用C语言编写一个科学计算器。
本次开发采用C语言，以面对过程思想进行开发，使用的数据结构有队列和栈。
二、模块设计
本次开发，使用的控制台输入,并直接在控制台输出。
科学计算器的功能组件如下：
三、详细设计
宏：
#define ＴESＴ???/／表示测试阶段
#ｄefｉne MAＸ＿ＳIZE 100 //表达式长度#ｄefinｅＬＢRACKEＴ 0??/／左括号
#deｆｉne RBRACKET 1?/／右括号
#deｆine ＡDD 2??//加
＃defｉnｅSUB ３?//减
＃dｅfine MUＬ 4?/／乘
#ｄefine DIV 5 ?／／乘
#define INＴ 6?? //整数
#deｆine ＤＯUＢLE ７??//浮点数
数据结构:
表达式节点
ｓtruct ExｐｒNode{
iｎt n; ?／／表达式节点类型
dｏuble p; ?//表达式节点数据
};
中缀表达式:
ｓtruｃt ＥxprＮode iｎfixExpr［ＭAX＿SIZＥ]；
inｔ infixLen；
后缀表达式：
sｔruct ＥｘprNodｅ sｕfｆiｘExpr[ＭAX_SIＺE]；
int suffｉxLen;
后缀转换栈：
ｉｎt ｔransＳtack［ＭAＸ_ＳIＺE];
iｎt tranｓToｐ;
后缀表达式运算栈：
strucｔ EｘｐrNode calcuStａck［MAX_ＳＩZE];
inｔ cａlcuTop；
函数过程:
__iｎliｎｅ iｎｔ gｅt＿ｃhaｒ( chａr *c )
缓冲变量无字符则读入字符
读入成功返回0,否者返回-1
ｉｎt inpｕt_expr( ｖoid )
读入表达式
若输入非法字符则返回-１，否则返回0
int ｐｒi( int a, int ｂ )
优先级计算
若a优先于b则返回-1，否则返回0
inｔ trans_eｘpr( ｖoｉｄ）
中缀表达式转换为后缀表达式
括号不匹配返回－1，否则返回0
_＿inliｎe int maxn( ｉnt a, int b )
求最大值
ｓｔruct ExprNode calcu( sｔｒucｔ EｘｐrNｏde *ａ, strucｔEｘprNode *b, int ｃ)
计算a和b做c运算的结果
int calｃu_expｒ（ｖoid )
计算后缀表达式
表达式计算失败返回-１,否则为0
?
void ｓhoｗ( ｖoid )
输出运算结果
代码：
#ｉnclude＜ｓtｄio.h＞
//#ｄefine ＴESＴ?//表示测试阶段
#ｄｅｆine ＭAX_SＩＺE 100?／／表达式长度
#defｉne LBＲACKＥT 0?//左括号
#dｅfｉnｅ RBRAＣKET １?//右括号
＃deｆinｅ AＤD ２???/／加
＃defiｎｅ SUB 3 ?//减
＃dｅfｉne MＵＬ 4 ?//乘
#deｆiｎe DIV ５??//乘
#define IＮT ６??／/整数
#defｉne DOＵBLE 7?//浮点数
ｓtrｕcｔＥxprＮｏｄe{
ｉnｔｎ；?//表达式节点类型
?double ｐ；?//表达式节点数据
};
sｔrucｔ ExpｒＮode infixExpr[MＡＸ_SIZE]；/／中缀表达式
inｔ infｉxＬen；
ｓｔｒuct ExｐｒＮode sｕffiｘExpr[MAX＿SIZＥ］;?/／后缀表达式
ｉnt suｆfiｘLeｎ;
ｉnt traｎsＳｔack［MAＸ_ＳＩZE];??//后缀转换栈
ｉnt transTop;
struct ExpｒＮｏde calcuSｔack[MAX_SIＺE］; ／／后缀表达式运算栈
int calcｕTop；
//缓冲变量无字符则读入字符
/／读入成功返回0,否者返回－1
__ｉnlinｅ int ｇet_char（ char ＊ｃ）
{
if ( *ｃ == '\0＇ ) ｒetｕrｎ scanf( "％c", ｃ );
return 0；
｝
/／读入表达式
//若输入非法字符则返回-1,否则返回0
int inpuｔ_ｅｘｐr（ void )
{
?cｈar c = 0;
int fｌag = 0， eｒror ＝ 0, ｓ, ｉ;
?iｎfｉxLen = 0；
?whiｌe ( ｇeｔ_cｈａr(＆c） !＝ -１）
?{
switch ( c )
?｛
?casｅ '\n': fｌaｇ = -1; breａk;
cａsｅ '（': infixExpｒ［ｉｎfixLen++］.n = LＢＲACKET; c = 0; bｒe ａk；
??cａse ')': infｉxExpr[infixＬeｎ++].n = ＲBRACＫＥT; ｃ = 0; bｒeaｋ;
ｃaｓe '+': infiｘExpr[infiｘLen++].n = ADD； c = 0；break;
?case ＇-': iｎfｉxＥｘｐr[infiｘLeｎ+＋].n = SUB; c = 0; ｂｒeaｋ;
cａse '*': ｉｎfixExｐr[iｎfiｘＬeｎ++].n = ＭＵL; c ＝０; break;
?case '／＇: inｆixExpr[infｉｘLen+＋].n = DIＶ; c ＝0； brｅaｋ；
??defaｕｌt:
?iｆ ( ｃ＞= '0' ＆& ｃ＜= '9＇ || c ＝= '．＇ )
{
if ( c !＝ '.＇ )
??{
??infiｘExpr[ｉnfixLen].n = INＴ;
?ｉnfiｘEｘpr[ｉnfixLen].p ＝ c－'0'；
??s = ０；
??｝
???else
{
?ｉnfｉxＥxpr[infixLen].n = DOUBLＥ;
???infｉxExpｒ［infixLｅｎ].p ＝０；
???s ＝１;
?｝
? c ＝ 0;
??ｗhilｅ（ gｅt_char(&c） != -1 )
???{
?if ( c >＝ '0' ＆& c ＜＝ '9' )
???{
?????infixExpr[ｉｎfｉｘLeｎ].p ＝ infixＥｘpｒ[infixＬen］．p*10+(c-＇０'）；
????iｆ( ｓ) s＋+;
? c = 0；
????}
ｅlse if ( ｃ＝= '.' )
?{
??if ( s ）
?????{
??ｅｒror ＝-1;
??}
????elsｅ
??{
???infixExｐr[infixLen].n ＝ DOＵBLE;
??s++;
?????｝
???ｃ = 0;
???}
??elsｅ brｅak;
??}
???iｆ ( infixＥxpr［iｎｆiｘLen].ｎ == DOUBLE )
??｛
?fｏｒ ( ｉ = １; i < s; i＋+ )
?{
???ｉnfixＥxpr[iｎｆixLen]．p /= 1０;
??}
???}
?iｎfｉxLｅn＋+;
???｝
??eｌｓe
??{
???error ＝ -1;
?ｃ＝ 0;
?}
??breaｋ;
?}
?if ( fｌag ）ｂｒｅak；
}；
?ｒeｔurn ｅrroｒ;
}
／/优先级计算
/／若a优先于b则返回-1,否则返回0
iｎt prｉ( inｔ a, iｎt ｂ )
{
?iｎｔ c［2], p[2]， i;
c［0] = ａ; c[1］ = ｂ;
?for ( i ＝0; i < ２; i+＋）
?{
?switch ( c［i] )
?｛
?cａse LBRAＣKET： p[i] = 0；breａk；
?ｃase ADD:
?case SＵＢ: ｐ［i] = 1; ｂreａk;
caｓｅMUＬ:
?cａse DIV: ｐ[i］= 2; bｒeak;
??
??}
?｝
?iｆ ( p［0] ＞＝ｐ[1］ )
{
?retｕrn -1;
?}
?rｅｔｕrn 0;
}
//中缀表达式转换为后缀表达式
//括号不匹配返回-1,否则返回0
ｉnt trａns_expr( void )
{
inｔ i, ｅrror ＝ 0， fｌag;
?suffｉxLen = 0;
trａｎsTop = 0;
?for ( i = 0; i < infｉxＬen；i+＋）
{
?iｆ（ infixExpr[ｉ]．n >＝ＩNＴ )?//当读到数字直接送至输出队列中
?{
?ｓufｆiｘExｐr［suffixLen＋+] ＝ｉnfｉｘEｘｐr[i]；
??}
??elｓe ｉf ( infｉｘEｘpr[i］．n ＞ RBRACKET ）//当读入运算符时
??｛
?//将栈中所有优先级高于或等于T的运算符弹出,送至输出队列
while ( ｔranｓTop > 0 )
?{
?if （ pｒi（ tｒansSｔａck[tｒａｎｓTop-１］, infixExpｒ［i］.n ) ) ??｛
??ｓuffiｘEｘpr[sufｆiｘLen＋+].ｎ = transＳtack[－－transTop］;
?｝
???eｌse bｒeak；
}
??//再把运算符入栈
???tranｓStack[transTｏｐ＋+] ＝ iｎｆixEｘpr［i].n；
?｝
eｌse if ( ｉｎfiｘExpr[ｉ］.n == LBRACＫEＴ )?//读到左括号时总是将它压入栈中
?｛
???ｔransStack[tranｓTop++] = ｉnfixＥxpr［i]．n;
?}
??elｓｅ?／/读到右括号时
?{
???flag = －1;
??//将靠近栈顶的第一个左括号上面的运算符依次全部弹出,送至输出队列
???whilｅ ( tｒanｓTop > 0 )
??｛
??if （tranｓStaｃk［tｒansToｐ-１] == ＬBRACＫET )
??{
?ｆlaｇ = 0;
?break;
???}
ｓuffiｘＥxpr［sｕffixLen+＋]．ｎ = traｎsStacｋ[－-trａnsＴop]; ??}
???//再丢弃左括号
??ｉｆ( flａｇ ) error = -1;
??else transTop-－;
?}
?}
?ｗhile （trａnｓTop > 0 ）
?{
if ( transStaｃk[ｔrａnｓＴop-1] == LＢＲACKET ）
?{
?eｒror = -1；
?}
suffixExpr[sufｆixLen++］.n ＝ｔrａｎsStaｃｋ[-－ｔｒaｎsTop]；
?}
?
//在测试阶段输出后缀表达式
#ifｄｅf ＴEST
?for ( i = 0； i < suffｉxLen；ｉ＋+ )
?{
??sｗitｃｈ（suffixExpr[i].n )
?{
?cａse ADD: pｒintｆ（ "+ " );ｂreak;
?ｃase SUＢ: printf( "－ " ）； brｅak;
case MUL: pｒintf( ＂＊＂ )；bｒeak；
?case ＤＩV： printf( "/ " ); brｅak；
?caｓｅＩNT： flag = suffixExpr[ｉ]．ｐ; ｐｒiｎtf（ "％d ＂, flag ）; break; ?cａｓe ＤOUＢＬE: ｐrintｆ( "%ｌｆ ", sufｆiｘExpr[ｉ］.ｐ); breａk；
}
}
#endｉｆ
?rｅturn error;
}
//求最大值
__ｉnｌiｎe ｉnt maｘn（int a, int b )
{
?if （ａ >＝ b ) returｎ a;
?reｔｕrn b;
｝
//计算ａ和b做c运算的结果
sｔｒuｃt ＥxｐrＮｏｄe caｌcｕ( sｔrucｔ ExｐrNode *a, struｃt ExprNodｅ *ｂ，inｔｃ )
{
strｕct ExpｒNoｄe r;
ｉnt i, j;
r.ｎ = maxn( ａ－>n, b->ｎ）；
?sｗitch （ c ）
?｛
cａse ＡDD：ｒ.ｐ＝(a-＞ｐ)+(ｂ->ｐ); bｒｅak;
?case SUB: ｒ.p = (a->ｐ)-（b－>p)； brｅak;
caｓe MUL: r.ｐ = (ａ->p)*(b->p); brｅａk；
ｃase DＩV： r.ｐ = (a-＞ｐ）/(b->ｐ）；
???ｉf ( ｒ.n ＝= INT )
? {
????ｉ＝ａ->ｐ;
? j = ｂ->ｐ;
?? if ( i%j ) ｒ.ｎ = DＯUＢLE;
? }
bｒeak；
}
ｒeｔurｎｒ;
}
//计算后缀表达式
//表达式计算失败返回-１,否则为0
iｎt caｌcu_expr（ｖｏid )
{
ｉｎｔ i， j, erroｒ = 0;
strｕcｔEｘｐrNode a［2], ｒ；
?calcuTop ＝ 0；
ｆor ( i = 0; i < suffiｘＬen && !error; ｉ++ )
?{
if （ｓｕffixExpr［i]．ｎ >= INT ) ／/读到数字就将它压入栈S中
?{
??ｃａlcuＳｔack[ｃalcuTop++] = sufｆｉxExpr[ｉ];
?}
?ｅｌse //读到运算符
??{
??//从栈中依次弹出两个数Ｘ和Y
?ｆor ( ｊ = ０； j < 2; ｊ＋+ )
??{
???ｉｆ( cａlcｕＴoｐ ) a[ｊ］ = calcｕStaｃk[--cａlｃuTｏp]；
else ｅrror ＝ -１；
?}
／/以＂Ｘ运算符Y"的形式计算出结果,再将结果压入栈S
iｆ( !eｒror ）
??{
??calcuSｔack[cａlcuTop++] = calcu( ＆ａ[1]，＆a[０], ｓuｆｆｉxExｐr ［i].ｎ);
??｝
?}
?}
if （ｃalcuTop !＝１ ) eｒror = -１；
?retuｒn erroｒ;
｝
//输出运算结果
ｖoid show（ｖｏｉd )
｛
?ｉｎｔi, n；
#ｉfｎdef TEST
?for ( i ＝ 0; i < sｕfｆixLｅn； i+＋ )
?{
?switch ( infixExpr[i].n )
?｛
?ｃase ＬＢRAＣKET: prｉnｔf( ＂（＂ ); break;
?cａsｅRBRAＣKET: ｐrｉntf( ") ＂ ); break;
?ｃase ADＤ: ｐrinｔｆ( "+ " );ｂreａk;
?casｅ SＵB: printf( "- " ）; bｒeaｋ；