c 程序设计语言 第二版 练习题 4-10

#include <stdio.h>
#include <stdlib.h>	
#include <string.h>
#include <math.h>
#include <ctype.h>

#define MAXOP 100  
#define NUMBER '0' //数字信号
#define FUN  'A' //命令信号
#define COM	'CM' //变量信号

void push(double d);
double pop();		//值栈
int getop(char *s); //获取输入字符
void printTop();	//打印值栈顶元素 
int getCount();		//获取 值栈 个数
void swob();		//交换栈顶两个元素
void clear();		//清空值栈元素
void pushVar(int c, double d);  //把变量的值存入
double popVar(int c);			//取出变量的值
int ungets(const char *s);		//把字符串，全部压入输入流中
int getline(char *s);// 每次读取一行
int powFlag = 1;
int main() {

	int type;
	double op2;
	char s[MAXOP];
	while ((type= getop(s)) != EOF)
	{
		switch (type)
		{
		case NUMBER:
			push(atof(s));
			break;
		case '+':
			push(pop() + pop());
			break;
		case '-':
			//op2 = pop();
			swob();
			push(pop() - pop());
			break;
		case '*':
			push(pop()*pop());
			break;
		case '/':
			op2 = pop();			
			if (op2 != 0.0)
				push(pop() / op2);
			else {
				printf("error:除数不能为0\n");
				clear();
			}
			break;

		case '%':
			op2 = pop();
			if (op2 != 0.0) {
				push((long int)pop() %(long int)op2);  //%操作符，操作数不能是浮点数，所以强制转换成 long int类型了
			}
			else {
				printf("error:除数不能为0\n");
				clear();
			}
			break;
		case COM://4-6 处理变量，s字符第一位默认是变量名，后面是数字字符
			if (strlen(s) > 1) {
				pushVar(s[0], atof(s + 1));
			}
			else
			{
				push(popVar(s[0]));
			}
			break;
		case FUN:  //4-5 处理函数
			if (strcmp(s, "clear") == 0) {
				clear();
			}
			else if (strcmp(s, "sin") == 0) {
				if (getCount() >= 1)
					push(sin(pop()));
				else {
					printf("参数有误\n");
					clear();
				}
			}
			else if (strcmp(s, "pow") == 0) {
				if (getCount() >= 2) {
					if (powFlag) {
						swob();
						powFlag = 0;
					}
					push(pow(pop(), pop()));
				}
				else {
					printf("参数有误\n");
					clear();
				}
			}
			else if (strcmp(s, "exp") == 0) {
				if (getCount() >= 1)
					push(exp(pop()));
				else {
					printf("参数有误\n");
					clear();
				}
			}
			else
			{
				printf("error:unknown command\n");
				clear();
			}
			break;
		case '\n':
			printTop();
			break;
		default:
			printf("error:unknown command\n");
			clear();
			break;
		}

	}

	system("pause");
	return 0;
}

#define MAXVAL 100
#define MAXVAR 26
int sp = 0;
double val[MAXVAL];
double var[MAXVAR]; //变量 栈 初始化可以设置一个 不常用的数，如:-1001101,用于后面判断是否存在该变量
					//当前默认初始化
void push(double d) {
	if (sp < MAXVAL) {
		val[sp++] = d;
	}
	else
	{
		printf("error:栈已满，不能存入%f\n", d);
	}
}

double pop() {
	if (sp > 0) {
		return val[--sp];
	}
	else
	{
		printf("error:栈是空的\n");
		return 0.0;
	}
}

int getch(void);
void ungetch(int);
int dflag = 1;  //一个数中是否‘.' ，没有则存入
int _flag = 1; // 用于判断'-' 是减号，还是负号
int count = 0; //记录连续字母个数，用于判断是函数，还是变量
char buffer[MAXOP]; //输入缓冲区
int bufPos = 0;
int getop(char *s) {
	int i, c;
	if (strlen(buffer)==0) { //判断缓冲区为空，才会继续读输入
		bufPos = 0;		// 缓冲区指针 置0
		getline(buffer);
	}
	while ((s[0] = c = buffer[bufPos++]) == ' ' || c == '\t')
		;
	s[1] = '\0';
	i = 0;
	if (!isdigit(c)&& c!='.') {
		if (isalpha(c)) { //如果是'c' 返回执行clear()
			do {
				s[i] = tolower(s[i]); //全部转为小写
				++count;
			} while (isalpha(s[++i] = c = buffer[bufPos++]));
			s[i] = '\0';
			if (c != '\0') { //如果不是字符串结尾，则bufPos 回调一位，=>ungetch(c)
				--bufPos;
			}
			else
			{				
				memset(buffer, 0, sizeof(buffer));
			}
			if (count == 1) { //如果连续字母只有一个，则当变量处理，否则当函数处理
				while ((s[i] = c = buffer[bufPos++]) == ' ' || c == '\t'); //跳过空格
				while(isdigit(c)) {					//继续读取 变量值
					if (isdigit(s[++i] = c = buffer[bufPos++]) == 0) {
						break;
					}
				}
				s[i] = '\0';
				if (c != '\0') {  //如果不是字符串结尾，则bufPos 回调一位，=>ungetch(c)
					--bufPos;
				}
				else
				{				
					memset(buffer, 0, sizeof(buffer));
				}
				count = 0;  //返回需要把 记录 连续字符 变量 设 0
				return COM;								   
			}
			count = 0; //返回需要把 记录 连续字符 变量 设 0
			return FUN;
		}
		else if (c == '-'&& getCount()<2 && _flag) { //判断'-'，如果val值栈里面有两个操作数			
			_flag = 0 ;								//那么'-'，当减号处理，_flag标示用于判断	
		}											//一个操作数里面只能包含一个'-'符号
		else
		{
			_flag = 1;  //返回要把标示 复位	

			if (c == '\n' || c == EOF) { //如果字符 是'\' 或者EOF 清空buffer			
				memset(buffer, 0, sizeof(buffer));
			}
			return c;
		}
		
	}
	if (isdigit(c) || _flag == 0 || dflag == 0) {
		while (1) {
			if (isdigit(s[++i] = c = buffer[bufPos++])) {
				continue;
			}
			else if (c == '.' && dflag) {  
			if (i >= 1 && isdigit(s[i-1])) {  //判断'.',	一个操作数里面只能包含一个.'符号	
					dflag = 0;  
					continue;
				}
			}
			else
			{
				dflag = 1;  //返回要把标示 复位
				break;
			}
		}
	}
	s[i] = '\0';
	if (c != '\0') {  //如需要压回EOF,取消if判断
		--bufPos;		 //如果不是字符串结尾，则bufPos 回调一位，=>ungetch(c)
		//ungets(s); 可以把全部字符压会
	}	
	_flag = 1;
	dflag = 1;
	return NUMBER;
}

void printTop()
{
	if (sp > 0) {
		printf("栈顶元素:%.8g\n", val[sp - 1]);
	}
	else
	{
		printf("元素为空，请继续输入:");
	}
}

int getCount()
{
	return sp;
}

void swob()
{
	if (sp > 1) {
		val[sp] = val[sp-1];
		val[sp-1] = val[sp - 2];
		val[sp - 2] = val[sp];
		val[sp] = 0.0;
	}
}

void clear()
{
	while (sp > 0)
	{
		val[--sp] = 0.0;
	}
}

void pushVar(int c, double d)
{
	c -= 'a';  //变量var 数组下标
	if (c >= 0 && c < MAXVAR) {  //判断是否越界
		var[c] = d;  //存入变量的值
	}
}

double popVar(int c)
{
	c -= 'a';  //变量var 数组下标
	if (c >= 0 && c < MAXVAR) { //判断是否越界
		double temp = var[c];
		var[c] = 0.0;  //取出变量的值后，该位置设0
		return temp; //返回变量的值
	}
	return 0.0;
}


#define BUFSIZE 100
char buf[BUFSIZ];
int bufp = 0;

//int getch(void) {
//	return (bufp > 0) ? buf[--bufp] : getchar();
//}

//void ungetch(int c) {
//	if (bufp >= BUFSIZE) {
//		printf("ungetch:字符缓冲已满\n");
//	}
//	else
//	{
//		//练习4-9处理压回的 EOF;如果是EOF,并且不需要处理后面的运算，则可以不用修改
//		//照常压入即可，否则 直接返回,忽略压入的EOF
//		/*if (c == EOF) {
//			return;
//		}*/
//		buf[bufp++] = c;
//	}
//
//	//练习4-8 只能压回一个字符
//	/*if (bufp > 0) {
//		printf("ungetch:字符缓冲已满\n");
//	}
//	else
//	{
//		buf[bufp++] = c;
//	}*/
//}
//4-7
int ungets(const char *s) {
	if (s == NULL) {
		return -1;
	}
	int len;
	int count = 0;
	for (len = strlen(s) - 1;len >= 0;--len) {
		ungetch(s[len]);
		++count;
	}
	return count;
}
//每次读取一行 4-10
int getline(char * s)
{
	int count = 0;
	char *p=NULL;
	while ((s[count++] = getchar()) != '\n' && s[count-1] !=EOF ); //判断不是换行符或者EOF,则继续读取
	return count; //返回读取数量
}