| Symbol.h
| Stack.h
| Expression.h
| Expression.c
**********************************/
// --Expression.c
#include "Expression.h"
extern EXPRESSION_DEBUG
STATUS EvaluateExpression(float*,char*)
void Usage(char *)
int HandleOptions(int,char **)
int main(int argc,char*argv[ ])
{
char strLine[30]={0}
float fResult=0
/* handle the program options */
HandleOptions(argc,argv)
fprintf(stderr,"Input cls to clear the screen\n")
fprintf(stderr," debug to show stack change\n")
fprintf(stderr," nodebug to show no stack change\n")
fprintf(stderr," end to exit\n")
while(TRUE)
{
printf("Input:\n")
gets(strLine)
if(!strcmp(strLine,"end"))
break
if(!strcmp(strLine,"cls")) {
system("cls")
continue
}
if(!strcmp(strLine,"debug")){
EXPRESSION_DEBUG=TRUE
continue
}
if(!strcmp(strLine,"nodebug")){
EXPRESSION_DEBUG=FALSE
continue
}
EvaluateExpression(&fResult,strLine)
printf("Ans=%f\n",fResult)
}
return OK
}
void Usage(char *programName)
{
fprintf(stderr,"%s usage:%s [-d][-h/?]\n",programName,programName)
fprintf(stderr,"-d Test program, calculate expression and\n")
fprintf(stderr," see changes in the stack at the same time.\n")
exit(OK)
}
/* returns the index of the first argument that is not an optioni.e.
does not start with a dash or a slash
*/
int HandleOptions(int argc,char *argv[])
{
int i,firstnonoption=0
for (i=1i<argci++) {
if (argv[i][0] == '/' || argv[i][0] == '-') {
switch (argv[i][1]) {
/* An argument -? means help is requested */
case '?':
case 'h':
case 'H':
Usage(argv[0])
break
case 'd':
case 'D':
EXPRESSION_DEBUG=TRUE
break
default:
fprintf(stderr,"unknown option %s\n",argv[i])
break
}
}
else {
firstnonoption = i
break
}
}
return firstnonoption
}
//--Symbol.h
//--symbol.h - definitions/declarations for symbols used by other C Header files
#ifndef SYMBOL_H
#define SYMBOL_H
#define STACK_H
#define TRUE 1
#define OK 1
#define YES 1
#define FALSE 0
#define ERROR 0
#define NO 0
#define OVERFLOW -1
#ifndef NULL
#define NULL 0
#endif
typedef unsigned int UINT
typedef int STATUS
typedef int BOOL
#endif /*SYMBOL_H*/
//--stack.h - definitions/declarations for stack operation
#ifndef STACK_H
#define STACK_H
#include "Symbol.h"
#include <malloc.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
#define S_CHAR 1
#define S_SHORT 2
#define S_INT 3
#define S_FLOAT 4
#define S_DOUBLE 5
//-- Stack.h
typedef struct tagNode
{
void*pData
struct tagNode*pNext
}Node,*PNode
typedef struct tagStack
{
UINT uType
/*1 char
*2 short/short int
*3 int
*4 float
*5 double
*/
UINT uLength
struct tagNode*pFirst
struct tagNode*pTop
}Stack,*PStack
STATUS InitStack(PStack pStack,UINT uType)
{
pStack->uType=uType
pStack->uLength=0
pStack->pFirst=pStack->pTop=NULL
return OK
}
STATUS ShowStack(PStack pStack)
{
PNode pNode=pStack->pFirst
while(pNode)
{
switch(pStack->uType)
{
case S_CHAR: // char
printf("%c ",*(char*)(pNode->pData))break
case S_FLOAT: // float
printf("%-4.1f ",*(float*)(pNode->pData))
}
pNode=pNode->pNext
}
putchar(10)
return OK
}
STATUS Push(PStack pStack,void*pData)
{
PNode pNode=(PNode)malloc(sizeof(Node))
if(!pNode)
{
printf("\nmalloc error!\n")
fflush(stdin)
getch()
exit(ERROR)
}
if(pStack->uType==1)
{
pNode->pData=(char*)malloc(sizeof(char))
*(char*)(pNode->pData)=*(char*)pData
}
else if(pStack->uType==3)
{
pNode->pData=(int*)malloc(sizeof(int))
pNode->pData=(int*)malloc(sizeof(int))
*(int*)(pNode->pData)=*(int*)pData
}
else if(pStack->uType==4)
{
pNode->pData=(float*)malloc(sizeof(float))
pNode->pData=(float*)malloc(sizeof(float))
*(float*)(pNode->pData)=*(float*)pData
}
else if(pStack->uType==5)
{
pNode->pData=(double*)malloc(sizeof(double))
pNode->pData=(double*)malloc(sizeof(double))
*(double*)(pNode->pData)=*(double*)pData
}
pNode->pNext=NULL
if(!pStack->pTop)
pStack->pTop=pStack->pFirst=pNode
else
{
pStack->pTop->pNext=pNode
pStack->pTop=pNode
}
pStack->uLength++
return OK
}
STATUS Pop(PStack pStack,void*pData)
{
PNode pPre=pStack->pFirst
if(pStack->pTop!=pStack->pFirst)
while(pPre->pNext!=pStack->pTop)
pPre=pPre->pNext
else
pPre=NULL
if(pStack->uType==1)
*(char*)(pData)=*(char*)(pStack->pTop->pData)
else if(pStack->uType==3)
*(int*)(pData)=*(int*)(pStack->pTop->pData)
else if(pStack->uType==4)
*(float*)(pData)=*(float*)(pStack->pTop->pData)
else if(pStack->uType==5)
*(double*)(pData)=*(double*)(pStack->pTop->pData)
free(pStack->pTop->pData)
free(pStack->pTop)
pStack->pTop=pPre
if(pPre)
pStack->pTop->pNext=NULL
else
pStack->pFirst=NULL
pStack->uLength--
return OK
}
STATUS GetTop(PStack pStack,void*pData)
{
if(pStack->uType==1)
*(char*)(pData)=*(char*)(pStack->pTop->pData)
else if(pStack->uType==3)
*(int*)(pData)=*(int*)(pStack->pTop->pData)
else if(pStack->uType==4)
*(float*)(pData)=*(float*)(pStack->pTop->pData)
else if(pStack->uType==5)
*(double*)(pData)=*(double*)(pStack->pTop->pData)
return OK
}
STATUS DestroyStack(PStack pStack)
{
PNode pPre1,pPre2
pPre1=pPre2=pStack->pFirst
while(pPre1)
{
pPre1=pPre1->pNext
free(pPre2->pData)
free(pPre2)
pPre2=pPre1
}
pStack->pFirst=pStack->pTop=NULL
pStack->uLength=0
return OK
}
#endif /* STACK_H */
//--Expresson.h
#ifndef EXPRESSION_H
#define EXPRESSION_H
#include "Stack.h"
typedef struct tagOptr
{
char cOptr
UINT uPriority
}Optr,*POptr
BOOL EXPRESSION_DEBUG=FALSE
Optr pOptr[8]={{0,7},{')',1},{'*',2},{'/',2},{'+',3},{'-',3},{'(',4},{'#',4}}
STATUS Operate(float*fTemp3,float fTemp1,char theta,float fTemp2)
{
switch(theta)
{
case '+':*fTemp3=fTemp1+fTemp2break
case '-':*fTemp3=fTemp1-fTemp2break
case '*':*fTemp3=fTemp1*fTemp2break
case '/':
if(fTemp2!=0)
*fTemp3=fTemp1/fTemp2
else
{
printf("\n0 can not be divisor!\n\nPress any key to continue...\n")
fflush(stdin)
getch()
exit(ERROR)
}// else
break
}
return OK
}
int Precede(char cOptrTop,char cChar)
{
UINT i,j
if(cOptrTop=='#'&&cChar=='#')
return 0
if(cChar=='(')
return -1
if(cChar==')')
if(cOptrTop=='(')
return 0
else
return 1
for(i=1i<=pOptr[0].uPriorityi++)
if(pOptr[i].cOptr==cOptrTop)
{
i=pOptr[i].uPriority
break
}
for(j=1j<=pOptr[0].uPriorityj++)
if(pOptr[j].cOptr==cChar)
{
j=pOptr[j].uPriority
break
}
if(i<=j)
return 1
else
return -1
return -2
}
STATUS IsIn(char cChar)
{
if(cChar>='0'&&cChar<='9'||cChar=='.')
return YES
return NO
}
STATUS Debug(PStack stackOptr,PStack stackOpnd,char*strExpression,int i)
{
// --debug
if(EXPRESSION_DEBUG)
{
printf("-------------------------------\n")
printf("%s\n",strExpression)
printf("Optr:")
ShowStack(stackOptr)
printf("Opnd:")
ShowStack(stackOpnd)
}
return OK
}
STATUS EvaluateExpression(float*fResult,char*strExpression)
{
char cChar='#',cOptrTop=0,theta=0
float fTemp1,fTemp2,fTemp3,fTemp4
int i=0,iTemp
Stack stackOptr,stackOpnd
InitStack(&stackOptr,S_CHAR)
InitStack(&stackOpnd,S_FLOAT)
Push(&stackOptr,&cChar)
GetTop(&stackOptr,&cOptrTop)
strcat(strExpression,"#")
if(strExpression[0]=='-'){
fTemp1=0
Push(&stackOpnd,&fTemp1)
}
cChar=strExpression[0]
while(cChar!='#'||cOptrTop!='#')
{
Debug(&stackOptr,&stackOpnd,strExpression,i)
if(IsIn(cChar))
{
fTemp1=0
fTemp3=10
fTemp4=1
while(IsIn(cChar))
{
if(cChar=='.'){
fTemp3=1
cChar=strExpression[++i]
continue
}
fTemp2=(float)(cChar-'0')
if(fTemp3==1)
{
iTemp=i
while(IsIn(strExpression[i])){
fTemp2/=10
i++
}
i=iTemp
}
fTemp1=fTemp1*fTemp3+fTemp2
cChar=strExpression[++i]
}
Push(&stackOpnd,&fTemp1)
}
else
{
switch(Precede(cOptrTop,cChar))
{
case -1:Push(&stackOptr,&cChar)cChar=strExpression[++i]break
case 0:Pop(&stackOptr,&cChar)cChar=strExpression[++i]break
case 1:
Pop(&stackOptr,&theta)
Pop(&stackOpnd,&fTemp2)Pop(&stackOpnd,&fTemp1)
Operate(&fTemp3,fTemp1,theta,fTemp2)
Push(&stackOpnd,&fTemp3)
break
}// switch
GetTop(&stackOptr,&cOptrTop)
}// else
}// while
Pop(&stackOptr,&cChar)
Debug(&stackOptr,&stackOpnd,strExpression,i)
GetTop(&stackOpnd,fResult)
DestroyStack(&stackOptr)
DestroyStack(&stackOpnd)
return OK
}// EvaluateExpression
#endif // EXPRESSION_H
图片说明：
红圈是输入的两个数字
篮圈是输入的运算符号
黄圈是运算后计算结果
下面是完整的代码，不知能不能满足你，可以私信联系
#include <stdio.h>#include <stdlib.h>
#include <string.h>
int main()
{
int y
double shu1=0
double shu2=0
char fuhao
do
{
printf("\n 迷你计算器\n\n")
printf(" 1.数据输入\n\n")
printf(" 2.四则运算\n\n")
printf(" 0.退 出\n\n")
printf(" 请选择（0-2）\n")
scanf("%d",&y)
getchar()
switch(y)
{
case 1:
shu1=0
shu2=0
fuhao=0
printf("请输入两个数字，空格分开：")
scanf("%lf %lf",&shu1,&shu2)
printf("\n输入完成： %lf %lf\n",shu1,shu2)
getchar()
break
case 2:
printf("\n请输入运算符号（+ - * /）:")
scanf("%c",&fuhao)
getchar()
if(fuhao == '+')
printf("\n加法，运算结果：%lf\n",shu1+shu2)
if(fuhao == '-')
printf("\n减法，运算结果：%lf\n",shu1-shu2)
if(fuhao == '*')
printf("\n乘法，运算结果：%lf\n",shu1*shu2)
if(fuhao == '/')
printf("\n除法，运算结果：%lf\n",shu1/shu2)
break
case 0:
printf(" 谢谢使用\n")
exit(1)
default:
printf(" 输入错误,请重新输入\n")
}
}
while (y>0)
}
易跑MINI-C跑步机是依托于华为智能健康系统，打造的智能跑步机设备，旨在为消费者提供舒适的智能化健康生活，更好的满足各种都市健身使用需求，我为大家带来易跑MINI-C跑步机的实际使用评测，让您对这款性能智能跑步机更了解哦。
易跑MINI-C跑步机怎么样？MINI-C也叫Mini- change，是易跑旗下的主打产品之一，易跑2012年成立，是国内定位高端的健身器材专业厂商，专注智能健身解决方案，所以易跑的跑步机在智能应用方面亮点特别多。
易跑MINI-C在2019年和华为合作，升级搭载一款华为运动健康app，作为华为运动生态款新品首发，其价格¥ 2099.00-2299.00。适合女性专用。
华为运动健康生态款MINI-C，可以通过NFC同华为运动健康一碰秒联，实现手机、跑步机数据的同步传送，精细精确的记录跑者的运动状态，智能分析并实时提供语音跑步建议；另外，通过AI算法振动计步，实现精准计步，计步精度高达95%以上。计步数据可以同步至华为运动健康APP与微信运动，轻松一键分享，解放双手，让用户获得沉浸式的智能跑步体验。
这款易跑mini-c跑步机可以收置起来，然后靠在墙边，它的占地还不到0.25㎡，也不用担心它会沦为置物架。它只有44公斤，不到普通跑步机重量的一半，对于女士单身薄臂力，也可以轻轻松松移动它。
参数：跑带区域123x46cm，跑步机最大承重120kg，持续输出马力1hp，峰值马力3hp，速度调节范围: 0.8-12Km/h。
1、造型：Mini- change是真的不辜负它Mini的前缀，造型非常迷你，整个跑步机造型简单,跑步带+手扶架，设计方面少了花俏的设计，看起来就轻便灵巧。
2、易 *** 作折叠：易收纳，就算是都市只有一个蜗居小房的白领们，也完全可以在小房间里施展得开。平时不需要使用的时候，只需要放下扶手把跑步机提起来，就自动停止运转， *** 作简单，小白轻松上手，不用怕忘记关开关引起的安全问题，而且不占地方，完全不害怕占用空间，和瑜伽垫一样，用就铺开，不用就收起来，这也是很多朋友中意这款跑步机的理由。
3、智能模式：在跑步模式上，Mini- c也是智能调控模式，如果你不希望做跑步的剧烈运动，比如慢走、快走，只需要将跑步机铺在地下，不要提起扶手，就直接唤醒走路模式，这时候的最高时速是6km/h，很适合平时日常刷剧听歌的闲暇时候来使用。
而只要抬起跑步机的扶手，智能设置可以立即将模式切换为跑步模式，这时候的最高限速是12km/h，扶手可以帮你平衡，更具有稳固性，也更安全。
4、小程序：Mini-change还可以和微信绑定，拥有一定的社交属性。微信绑定了易跑运动小程序之后，还能和好朋友每天PK运动指数，无形中对自己的运动也有督促作用，非常贴心。
5、噪音和平稳性：Mini-c在跑步带上使用的材质是活性蜂窝结构硅胶，配合的是和运动鞋同一减震原理的air空气回d减震系统，在减震静音上有非常明显的感受，这点上简直充分兼顾到了家用需求，比较静音，无需担心扰邻居。
除外，Mini-c是一款 *** 作易上手，体验较佳的家用跑步机，所以它的 *** 作键也充分遵循了智能、 *** 作便捷的理念，全部都依靠一个类似手机home键的旋钮。通过按压进行跑步机开关的 *** 作，按一下开，再按一下关，然后通过旋转来控制速度的加强和减弱，同时home键的旋钮上，也会显示出你的运动记录，比如公里、时速、卡路里等等，一目了然。
点评：
总得来说，如果你需要的是一款收纳容易、 *** 作简单、减震好，使用起来没有什么噪音。对于我们小户型来说，最适合家庭使用，Mini-c一定会是个好选择。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）