文档章节

计算器--gtk--003

小代码2016
 小代码2016
发布于 2015/09/02 15:55
字数 5750
阅读 819
收藏 17

其实这次写这个程序,原本是帮一个学妹完成课程设计,不过写着写着就想要重新拿走这个项目了

现在在只是先记录一下,尔后还要在linux上重新测试

文件列表


D:\code\xin\eclipse\cal>dir *.h *.c
 驱动器 D 中的卷是 软件
 卷的序列号是 0006-17B7

 D:\code\xin\eclipse\cal 的目录

2015/07/25  01:32               671 bolan.h
2015/07/25  01:30             1,851 node.h
2015/07/24  23:33             1,587 stack.h
2015/08/31  21:53             1,729 tools.h

 D:\code\xin\eclipse\cal 的目录

2015/08/31  21:43             4,290 bolan.c
2015/08/31  22:07            17,088 main.c
2015/08/31  21:42             4,573 node.c
2015/07/27  20:09             2,952 stack.c
2015/08/31  21:44             4,073 tools.c
               9 个文件         38,814 字节
               0 个目录 35,335,245,824 可用字节

D:\code\xin\eclipse\cal>

tools.h


/** @file tools.h
 * 
 * @param expPtr
 * @return
 */

#ifndef TOOLS_H_
#define TOOLS_H_

/** @brief 删除表达式中的空格及不可见字符
 * 
 * @param expPtr 原表达式字符串
 * 
 * @retval 0 执行成功
 * @retval 1 执行失败
 */
int tools_delete_spaces( char * expPtr );


/** @brief 表达式的正负号前加0
 * 
 * @param expPtr 表达式
 * 
 * @retval 0 执行成功
 * @retval 1 执行失败
 */
int tools_add_zero( char * expPtr );

/** @brief 判断当前字符是否为+ - * / 这四个运算符之一
 * 
 * @param ch 要判断的符号
 * 
 * @retval 0 是
 * @retval 1 否
 */
int tools_is_char_operator( char ch );

/** @brief 判断字符 ch 是否为括号
 * 
 * @param ch 要判断的字符
 * 
 * @retval 0 是
 * @retval 1 否
 */
int toolls_is_char_paren( char ch );

/** @brief 字符串末尾添加 # 
 * 
 * @param expPtr 字符串
 * 
 * @retval 0 执行成功
 * @retval 1 执行失败
 */
int tools_add_sharp( char * expPtr );

/** @brief 比较运算符优先级
 * 
 * @param ch1 当前运算符
 * @param ch2 与之比较的运算符,也就是临时栈栈顶元素的值
 * 
 * @retval 1    当前运算符大于与之比较的运算符
 * @retval 0    当前运算符等于与之比较的运算符
 * @retval -1   当前运算符小于于与之比较的运算符
 */
int tools_operator_compare(char ch1, char ch2);

/** @brief 在字符串str中查找字符ch第一次出现的位置
 * 
 * @param str 要搜索字符串
 * @param ch 要查找的字符
 * @return 查找到的位置
 */
int tools_str_ch_index_first( char * str, char ch );

/** @brief 处理表达式中的0
 * 如果小数点后面全为0,则将小数点及之后的字符去除
 * 如果小数点之后有数字,则将最后一个非0字符后面的0去除
 * @param exp 要处理的字符串
 * @retval 0 操作成功 
 * @retval 1 操作失败
 */
int tools_exp_handle_zero(char * exp);

#endif /* TOOLS_H_ */

tools.c



#include<string.h>
#include<ctype.h>

#include "tools.h"

/** @brief 删除表达式中的空格及不可见字符
 * 
 * @param expPtr 原表达式字符串
 * 
 * @retval 0 执行成功
 * @retval 1 执行失败
 */
int tools_delete_spaces(char * expPtr) {
	int res = 1;
	char tmp[100] = { '\0' };
	strcpy(tmp, expPtr);
	int i = 0;
	int j = 0;
	int len = strlen(tmp);

	for (i = 0; i < len; i++) {
		char ch = tmp[i];

		//忽略不可见字符
		if (!isspace(ch)) {
			expPtr[j] = ch;
			j++;
		}
	}

	expPtr[j] = '\0';

	res = 0;

	return res;
}

/** @brief 表达式的正负号前加0
 * 
 * @param expPtr 表达式
 * 
 * @retval 0 执行成功
 * @retval 1 执行失败
 */
int tools_add_zero(char * expPtr) {
	int res = 1;
	char tmp[100] = { '\0' };
	strcpy(tmp, expPtr);
	int len = strlen(tmp);
	int i = 0;
	int j = 0;

	//如果第一个符号是正负号,则在其前加0
	if ('+' == tmp[0] || '-' == tmp[0]) {
		expPtr[0] = '0';
		expPtr[1] = tmp[0];
		j = 2;
	}else{
		//如果不是,则直接复制
		expPtr[j] = tmp[0];
		j++;
	}

	for (i = 1; i < len; i++) {
		
		char ch = tmp[i];
		
		
		expPtr[j] = tmp[i];
		j++;

		//如果当前字符是 ( 且其后面是 + 或 - ,则在 ( 之后加 0
		if ('(' == ch) {
			if ('+' == tmp[i + 1] || '-' == tmp[i + 1]) {
				expPtr[j] = '0';
				j++;
			}

		}
	}
	expPtr[j] = '\0';

	return res;
}

/** @brief 判断当前字符是否为+ - * / 这四个运算符之一
 * 
 * @param ch 要判断的符号
 * 
 * @retval 0 是
 * @retval 1 否
 */
int tools_is_char_operator(char ch) {
	int res = 1;

	switch (ch) {
	case '+':
	case '-':
	case '*':
	case '/': {
		res = 0;
		break;
	}
	}

	return res;
}

/** @brief 判断字符 ch 是否为括号
 * 
 * @param ch 要判断的字符
 * 
 * @retval 0 是
 * @retval 1 否
 */
int toolls_is_char_paren(char ch) {
	int res = 1;

	switch (ch) {
	case '(':
	case ')': {
		res = 0;
		break;
	}
	}

	return res;
}

/** @brief 字符串末尾添加 # 
 * 
 * @param expPtr 字符串
 * 
 * @retval 0 执行成功
 * @retval 1 执行失败
 */
int tools_add_sharp(char * expPtr) {
	int res = 1;
	int len = strlen(expPtr);
	expPtr[len] = '#';
	expPtr[len + 1] = '\0';

	res = 0;
	return res;
}

/** @brief 比较运算符优先级
 * 
 * @param ch1 当前运算符
 * @param ch2 与之比较的运算符,也就是临时栈栈顶元素的值
 * 
 * @retval 1    当前运算符大于与之比较的运算符
 * @retval 0    当前运算符等于与之比较的运算符
 * @retval -1   当前运算符小于于与之比较的运算符
 */
int tools_operator_compare(char ch1, char ch2) {
	int res = 0;
	if ('+' == ch1 || '-' == ch1) {
		if ('#' == ch2) {
			res = 1;
		} else if ('+' == ch2 || '-' == ch2) {
			res = 0;
		} else if ('*' == ch2 || '/' == ch2) {
			res = -1;
		} else if ('(' == ch2) {
			res = 1;
		}
	} else if ('*' == ch1 || '/' == ch1) {
		if ('#' == ch2) {
			res = 1;
		} else if ('+' == ch2 || '-' == ch2) {
			res = 1;
		} else if ('*' == ch2 || '/' == ch2) {
			res = 0;
		} else if ('(' == ch2) {
			res = 1;
		}
	}
	return res;
}

/** @brief 在字符串str中查找字符ch第一次出现的位置
 * 
 * @param str 要搜索字符串
 * @param ch 要查找的字符
 * @return 查找到的位置
 */
int tools_str_ch_index_first( char * str, char ch ){
	int i = 0;
	int index;
	int str_len = strlen(str);
	
	for( i = 0; i < str_len; i++ ){
		if( ch == str[i]){
			break;
		}
	}
	
	index = i--;
	
	return index;
}	

/** @brief 处理表达式中的0
 * 如果小数点后面全为0,则将小数点及之后的字符去除
 * 如果小数点之后有数字,则将最后一个非0字符后面的0去除
 * @param exp 要处理的字符串
 * @retval 0 操作成功 
 * @retval 1 操作失败
 */
int tools_exp_handle_zero(char * exp){
	int res = 0;
	//小数点的位置 
	int dot_index = tools_str_ch_index_first(exp,'.');
	int i = 0;


	//结果字符串的长度 
	int exp_len = strlen(exp);

	//小数点之后最后一个数字出现的位置
	int last_num = 0;
	for( i = exp_len - 1; i > dot_index	; i-- ){
		if( '0' != exp[i]){
			last_num = i;
			break;
		}
	}
	
	if( 0 == last_num ){
		exp[dot_index] = '\0';
	}else{
		exp[i+1] = '\0';
	}
	
	res = 1;	
	
	return res;
}

node.h



/** @file node.h
 * 保存由字符串转换后的数据
 * 
 */

#ifndef NODE_H_
#define NODE_H_

/** @struct __node
 * 栈中的每个元素的类型
 * 
 * flag 的值所代表的意义
 * 0 
 * 	数字 保存在num中
 * + - / * 
 * 	运算符 保存在operator中
 * ( ) 
 * 	括号 保存在paren中
 * #
 *  结束符 保存在sharpt中
 */
struct __node{
	/** @brief 保存数字  */
	double num;
	
	/** @brief 保存运算符  */
	char operator;
	
	/** @brief 保存括号  */
	char paren;
	
	/** @brief 保存 #  */
	char sharp;
	
	/** @brief 标志,表达本 node所保存的数据的类型   */
	char flag;
};

typedef struct __node _node;
typedef struct __node * nodePtr;


/** @brief 创建数字node
 * 
 * @param num 数字
 * @return 创建的node
 */
nodePtr node_create_num( double num );

/** @brief 创建运算符node
 * 
 * @param operator 运算符
 * @return 创建的node
 */
nodePtr node_create_operator( char operator );

/** @brief 创建括号node
 * 
 * @param paren 括号
 * @return 创建的node
 */
nodePtr node_create_paren( char paren );

/** @brief 创建结符
 * 
 * @param sharp #
 * 
 * @return 创建的node
 */
nodePtr node_create_sharp( char sharp );

/** @brief 根据指定的符号创建node
 *  
 * @param ch 指定的node
 * 
 * @retval 0 创建成功
 * @retval 1 创建失败
 */
nodePtr node_create_from_char( char ch );

/** @brief 打印此node的内容
 * 若是数字开型,则只打印数字,其它类似
 * 
 * @param node 要打印的node
 * 
 * @retval 0 执行成功 
 * @retval 1 执行失败 
 */
int node_print( nodePtr node );

/** @brief 计算一个表达式应当用多少个node保存
 * 
 * @param expPtr 表达式
 * 
 * @return 就使用的node数
 */
int node_exp_num( char * expPtr );

/** @brief 把表达式字符串转换为node数组
 * 
 * @param expPtr 表达式字符串
 * 
 * @return 转换后的node数组
 */
nodePtr node_create_array( char * expPtr );


#endif /* NODE_H_ */

node.c



#include"node.h"
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include "tools.h"

/** @brief 创建数字node
 * 
 * @param num 数字
 * @return 创建的node
 */
nodePtr node_create_num(double num) {
	nodePtr node = (nodePtr) malloc(sizeof(_node));
	if ( NULL == node) {
		puts("创建数字node失败...NULL == node ");
		exit(0);
	}

	node->num = num;
	node->flag = '0';

	node->operator = '\0';
	node->paren = '\0';
	node->sharp = '\0';

	return node;
}

/** @brief 创建运算符node
 * 
 * @param operator 运算符
 * @return 创建的node
 */
nodePtr node_create_operator(char operator) {
	nodePtr node = (nodePtr) malloc(sizeof(_node));
	if ( NULL == node) {
		puts("创建数字node失败...NULL == node ");
		exit(0);
	}

	node->operator = operator;
	node->flag = operator;

	node->num = 0;
	node->paren = '\0';
	node->sharp = '\0';

	return node;

}

/** @brief 创建括号node
 * 
 * @param paren 括号
 * @return 创建的node
 */
nodePtr node_create_paren(char paren) {
	nodePtr node = (nodePtr) malloc(sizeof(_node));
	if ( NULL == node) {
		puts("创建数字node失败...NULL == node ");
		exit(0);
	}

	node->paren = paren;
	node->flag = paren;

	node->operator = '\0';
	node->num = 0;
	node->sharp = '\0';

	return node;
}

/** @brief 创建结符
 * 
 * @param sharp #
 * 
 * @return 创建的node
 */
nodePtr node_create_sharp(char sharp) {
	nodePtr node = (nodePtr) malloc(sizeof(_node));
	if ( NULL == node) {
		puts("创建数字node失败...NULL == node ");
		exit(0);
	}

	node->sharp = sharp;
	node->flag = sharp;

	node->operator = '\0';
	node->num = 0;
	node->paren = '\0';

	return node;
}

/** @brief 根据指定的符号创建node
 *  
 * @param ch 指定的node
 * 
 * @retval 0 创建成功
 * @retval 1 创建失败
 */
nodePtr node_create_from_char(char ch) {
	nodePtr node = NULL;

	if (!tools_is_char_operator(ch)) {
		node = node_create_operator(ch);
	} else if (!toolls_is_char_paren(ch)) {
		node = node_create_paren(ch);
	} else if ('#' == ch) {
		node = node_create_sharp(ch);
	}

	return node;
}

/** @brief 打印此node的内容
 * 若是数字开型,则只打印数字,其它类似
 * 
 * @param node 要打印的node
 * 
 * @retval 0 执行成功 
 * @retval 1 执行失败 
 */
int node_print(nodePtr node) {
	int res = 1;

	//运算符
	if (!tools_is_char_operator(node->flag)) {
		printf("%c\n", node->operator);
	} else if (!toolls_is_char_paren(node->flag)) {
		printf("%c\n", node->paren);
	} else if ('0' == node->flag) {
		printf("%.2lf\n", node->num);
	} else if ('#' == node->flag) {
		printf("%c\n", node->sharp);
	}

	res = 0;
	return res;

}

/** @brief 计算一个表达式应当用多少个node保存
 * 
 * @param expPtr 表达式
 * 
 * @return 就使用的node数
 */
int node_exp_num(char * expPtr) {
	//需要的node数
	int count = 0;
	int len = strlen(expPtr);
	int i = 0;
//	int j = 0;

	for (i = 0; i < len; i++) {
		char ch = expPtr[i];

		if ('#' == ch) {
			count++;
			break;
		}

		//如果是运算符,count直接加1
		if (!tools_is_char_operator(ch) || !toolls_is_char_paren(ch)) {
			count++;
		} else {
			//如果是数字,则遍历至当前数字的最后一个字符,count加1
			while (('0' <= ch && ch <= '9') || '.' == ch ) {
				i++;
				ch = expPtr[i];
			}

			count++;
			i--;

		}
	}

	return count;
}

/** @brief 把表达式字符串转换为node数组
 * 
 * @param expPtr 表达式字符串
 * 
 * @return 转换后的node数组
 */
nodePtr node_create_array(char * expPtr) {
	//得到转换后的数组的长度
	int array_len = node_exp_num(expPtr);
	int len = strlen(expPtr);
	int i = 0;
	int j = 0;
	int k = 0;
	nodePtr tmp = NULL;
	//创建数组
	nodePtr node_array = (nodePtr) malloc(sizeof(_node) * array_len);

	if ( NULL == node_array) {
		puts("创建node数组失败...NULL == node_array");
		exit(0);
	}

	for (i = 0; i < len; i++) {
		char ch = expPtr[i];

		//运算符
		if (!tools_is_char_operator(ch)) {

			tmp = node_create_operator(ch);
			node_array[j] = *tmp;
			j++;

		} else if (!toolls_is_char_paren(ch)) {

			//括号
			tmp = node_create_paren(ch);
			node_array[j] = *tmp;
			j++;

		} else if ('#' == ch) {

			//结束符
			tmp = node_create_sharp(ch);
			node_array[j] = *tmp;
			j++;

		} else {

			//数字
			char numArr[20] = { '\0' };
			while (('0' <= ch && ch <= '9') || '.' == ch ) {
				numArr[k++] = ch;
				i++;
				ch = expPtr[i];
			}
			double num = atof(numArr);
			tmp = node_create_num(num);
			node_array[j] = *tmp;
			j++;

			i--;
			k = 0;

		}
	}

	return node_array;
}

stack.h



/** @file stack.h
 * 栈的操作的声明
 * 
 */

#include"node.h"

#ifndef STACK_H_
#define STACK_H_


/** @brief 栈结构体
 * 
 */
struct __stack{
	/** @brief node 数组头指针  */
	nodePtr node_arr;
	
	/** @brief 栈有效长度 */
	int size;
	
	/** @brief 栈实际长度  */
	int length;
	
};


typedef struct __stack _stack;
typedef struct __stack * stackPtr;


/** @brief 创建栈
 * 
 * @param length 栈的实际长度
 * 如果length 指定为0,则默认的length值为40
 * 
 * @return 创建好的栈
 * 
 * @retval NULL 创建失败
 */
stackPtr stack_create( int length );

/** @brief 入栈
 * 
 * @param stack 栈
 * @param node 要入栈的node
 * 
 * @retval 0 入栈成功
 * @retval 1 入栈失败
 */
int stack_push( stackPtr stack, nodePtr node);

/** @brief 判断栈是否已满
 * 
 * @param stack 栈
 * 
 * @retval 0 已满
 * @retval 1 未满
 */
int stack_is_full( stackPtr stack );


/** @brief 栈扩容
 * 
 * @param stack 栈
 * 
 * @retval 0 扩容成功
 * @retval 1 扩容失败
 */
int stack_node_array_extends( stackPtr stack );

/** @brief 出栈
 * 
 * @param stack 栈
 * @param node 保存出栈的元素
 * 
 * @retval 0 出栈成功 
 * @retval 1 出栈失败 
 */
int stack_pop( stackPtr stack, nodePtr node);

/** @brief 取出栈顶元素的值
 * 
 * @param stack 栈
 * @param node 保存栈顶元素的值
 * 
 * @retval 0 取出成功
 * @retval 1 取出失败
 */
int stack_top( stackPtr stack, nodePtr node );

/** @brief 输出栈
 * 
 * @param stack 栈
 * 
 * @retval 0 输出成功
 * @retval 1 输出失败
 */
int stack_print( stackPtr stack );
#endif /* STACK_H_ */

stack.c



#include"stack.h"
#include"node.h"
#include<stdlib.h>
#include<stdio.h>

/** @brief 创建栈
 * 
 * @param length 栈的实际长度
 * 如果length 指定为0,则默认的length值为40
 * 
 * @return 创建好的栈
 * 
 * @retval NULL 创建失败
 */
stackPtr stack_create(int length) {
	stackPtr stack = (stackPtr) malloc(sizeof(_stack));

	if ( NULL == stack) {
		puts("创建栈失败...NULL == stack ");
		exit(0);
	}

	if (0 == length) {
		stack->length = 40;
	} else {
		stack->length = length;
	}

	stack->node_arr = (nodePtr) malloc(sizeof(_node) * stack->length);

	if ( NULL == stack->node_arr) {
		puts("创建栈失败...NULL == stack->node_arr ");
		exit(0);
	}

	stack->size = 0;
//	stack->length = 40;

	return stack;
}

/** @brief 入栈
 * 
 * @param stack 栈
 * @param node 要入栈的node
 * 
 * @retval 0 入栈成功
 * @retval 1 入栈失败
 */
int stack_push(stackPtr stack, nodePtr node) {
	int res = 1;

	if (!stack_is_full(stack)) {
		stack_node_array_extends(stack);
	}

	//数据后移
	int i = stack->size - 1;
	for (i = stack->size - 1; i >= 0; i--) {
		stack->node_arr[i + 1] = stack->node_arr[i];
	}
	//数据入栈
	stack->node_arr[0] = *node;
	//栈有效长度加1
	stack->size++;

	res = 0;
	return res;
}

/** @brief 判断栈是否已满
 * 
 * @param stack 栈
 * 
 * @retval 0 已满
 * @retval 1 未满
 */
int stack_is_full(stackPtr stack) {
	int res = 0;
	if (stack->size < stack->length) {
		res = 1;
	}

	return res;
}

/** @brief 栈扩容
 * 
 * @param stack 栈
 * 
 * @retval 0 扩容成功
 * @retval 1 扩容失败
 */
int stack_node_array_extends(stackPtr stack) {
	int res = 1;

	if ( NULL != stack) {
		stack->length = stack->length * 1.75;
		stack->node_arr = (nodePtr) realloc(stack->node_arr, stack->length);

		res = 0;
	}

	return res;
}

/** @brief 出栈
 * 
 * @param stack 栈
 * @param node 保存出栈的元素
 * 
 * @retval 0 出栈成功 
 * @retval 1 出栈失败 
 */
int stack_pop(stackPtr stack, nodePtr node) {
	int res = 1;

	if ( NULL != stack && stack->size > 0) {
		//保存栈顶元素
		*node = stack->node_arr[0];
		int i = 0;
		for (i = 0; i <= stack->size - 2; i++) {
			stack->node_arr[i] = stack->node_arr[i + 1];
		}
		stack->size--;
	}

	res = 0;
	return res;
}

/** @brief 取出栈顶元素的值
 * 
 * @param stack 栈
 * @param node 保存栈顶元素的值
 * 
 * @retval 0 取出成功
 * @retval 1 取出失败
 */
int stack_top(stackPtr stack, nodePtr node) {
	int res = 1;

	if ( NULL != stack && stack->size > 0) {
		*node = stack->node_arr[0];
		res = 0;
	}

	res = 0;
	return res;

}

/** @brief 输出栈
 * 
 * @param stack 栈
 * 
 * @retval 0 输出成功
 * @retval 1 输出失败
 */
int stack_print(stackPtr stack) {
	int res = 1;

	if ( NULL != stack && stack->size > 0) {
		int i = 0;
		for (i = 0; i < stack->size; i++) {
			nodePtr tmp = &stack->node_arr[i];
			node_print(tmp);
		}

	}
	res = 0;
	return res;
}


bolan.h


/** @file bolan.h
 * 实现 逆波兰算法
 * 
 */

#include"stack.h"

#ifndef BOLAN_H_
#define BOLAN_H_

/** @brief 将一个中缀表达式转换为逆波兰表达式 
 * 
 * @param expPtr 表达式
 * @param stack 保存逆波兰表达式的栈
 * 
 * @retval 0 转换成功
 * @retval 1 转换失败
 */
int bolan_from_exp( char * expPtr, stackPtr stack);

/** @brief 对逆波兰式作逆序处理,并去除#符号
 * 
 * @param stack 后缀栈
 * 
 * @retval 0 执行成功
 * @retval 1 执行失败
 */
int bolan_inverted(stackPtr stack);

/** @brief 计算逆波兰表达式
 * 
 * @param stack 保存逆波兰表达式的栈
 * 
 * @return 计算结果
 */
double bolan_cal( stackPtr stack);

#endif /* BOLAN_H_ */





bolan.c


#include"bolan.h"
#include"stack.h"
#include"node.h"
#include<stdio.h>
#include<stdlib.h>
#include "tools.h"

/** @brief 将一个中缀表达式转换为逆波兰表达式 
 * 
 * @param expPtr 表达式
 * @param stack 保存逆波兰表达式的栈
 * 
 * @retval 0 转换成功
 * @retval 1 转换失败
 */
int bolan_from_exp(char * expPtr, stackPtr stack) {
	int res = 1;
	//临时保存运算符
	stackPtr tmp = stack_create(0);

	//向临时栈中压入#符号
	nodePtr node_sharp = node_create_sharp('#');
	stack_push(tmp, node_sharp);

	//将中缀表达式字符串转换为node数组
	nodePtr node_array = node_create_array(expPtr);
	//node数组长度
	int node_array_len = node_exp_num(expPtr);

	int i = 0;
	//遍历node数组
	for (i = 0; i < node_array_len; i++) {
		nodePtr node_now = &node_array[i];

		if ('0' == node_now->flag) {
			//如果是数字,直接入结果线

			stack_push(stack, node_now);

		} else if (!tools_is_char_operator(node_now->flag)) {
			//如果是运算符,则与运算符栈栈顶元素进行比较
			//取出临时栈栈顶元素的值
			nodePtr node_tt = &tmp->node_arr[0];
			char ch = node_tt->flag;
			nodePtr node_top = node_create_from_char(ch);
			stack_top(tmp, node_top);
			char node_now_ch = node_now->flag;
			char node_top_ch = node_top->flag;

			if (tools_operator_compare(node_now_ch, node_top_ch) > 0) {
				stack_push(tmp, node_now); //将当前运算符进临时栈
			} else {
				while (1) {
					stack_top(tmp, node_top);
					node_top_ch = node_top->flag;
					if (tools_operator_compare(node_now_ch, node_top_ch) <= 0) {
						stack_pop(tmp, node_top); //将临时栈顶元素弹出
						stack_push(stack, node_top); //将弹出的元素入后缀栈
					} else {
						stack_push(tmp, node_now);
						break;
					}

				}
			}

		} else if ('(' == node_now->flag) {
			stack_push(tmp, node_now);

		} else if (')' == node_now->flag) {

			while (1) {
				//弹出临时栈栈顶元素
				nodePtr node_tt = &tmp->node_arr[0];
				char ch = node_tt->flag;
				nodePtr node_top = node_create_from_char(ch);
				stack_pop(tmp, node_top);
				char node_top_ch = node_top->flag;

				//如果是 ( ,则结束
				if ('(' == node_top_ch) {
					break;
				} else {
					//如果不是 ( ,则直接送入后缀栈
					stack_push(stack, node_top);
				}

			}

		} else if ('#' == node_now->flag) {
			nodePtr node_tt = &tmp->node_arr[0];
			char ch = node_tt->flag;
			nodePtr node_top = node_create_from_char(ch);
			stack_top(tmp, node_top);
//			char node_top_ch = node_top->flag;

			while ('#' != node_top->flag) {
				stack_pop(tmp, node_top); //将临时栈顶元素弹出
				stack_push(stack, node_top);
			}
		}
	}

	res = 0;
	return res;
}

/** @brief 对逆波兰式作逆序处理,并去除#符号
 * 
 * @param stack 后缀栈
 * 
 * @retval 0 执行成功
 * @retval 1 执行失败
 */
int bolan_inverted(stackPtr stack) {
	int res = 1;

	int i = 0;
	int j = 0;
	nodePtr node_arr_new = (nodePtr) malloc(sizeof(_node) * stack->size - 1);
	for (i = stack->size - 1; i > 0; i--) {
		node_arr_new[j] = stack->node_arr[i];
		j++;
	}

	stack->node_arr = node_arr_new;
	//去除 #
//	stack->size--;
	res = 0;

	return res;
}

/** @brief 计算逆波兰表达式
 * 
 * @param stack 保存逆波兰表达式的栈
 * 
 * @return 计算结果
 */
double bolan_cal(stackPtr stack) {
	//保存计算结果
	double res = 0;
	//保存结果的栈
	stackPtr stack_tmp = stack_create(0);
	int i = 0;
	nodePtr node_b = node_create_num(0);
	nodePtr node_a = node_create_num(0);
	double a = 0;
	double b = 0;

	for (i = 0; i < stack->size - 1; i++) {
		nodePtr node_t = &stack->node_arr[i];
		if ('0' == node_t->flag) {
			nodePtr node_num = node_create_num(node_t->num);
			stack_push(stack_tmp, node_num);
		} else {
			node_b = node_create_num(0);
			node_a = node_create_num(0);
			stack_pop(stack_tmp, node_b);
			stack_pop(stack_tmp, node_a);
			a = node_a->num;
			b = node_b->num;

			char ch = node_t->flag;
			switch (ch) {
			case '+': {
				a = a + b;
				break;
			}
			case '-': {
				a = a - b;
				break;
			}
			case '*': {
				a = a * b;
				break;
			}
			case '/': {
				a = a / b;
				break;
			}
			}

			node_a = node_create_num(a);
			stack_push(stack_tmp, node_a);

		}
	}

	stack_pop(stack_tmp, node_a);
	res = node_a->num;

	return res;
}


main.c



#include <gtk/gtk.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include"node.h"
#include"stack.h"
#include"bolan.h"
#include "tools.h"


//处理中文乱码
char *_(char * c) {
	return g_convert(c, -1, "UTF-8", "GB2312", NULL, NULL, NULL);
}

char expression[100] = { '\0' };
int i = 0;

/** @brief 创建数字,运算符和等于号部分 
 * 
 * @return 创建的表格容器
 */
GtkWidget * create_table(GtkWidget * entry);

/** @brief 创建平方开方三角函数等扩展功能
 * 
 * @param entry 文本框
 * @return 创建好的表格容器
 */
GtkWidget * create_extends(GtkWidget * entry);

/** @brief 等于单击
 * 
 * 
 * @param button
 * @param data 表达式处理器
 */
void on_button_eq_clicked(GtkWidget * button, gpointer data);

/** @brief 清除按钮,清除本次数字输入,以便重新输入
 * 
 * @param button
 * @param data 表达式处理器 
 */
void on_button_clear_clicked(GtkWidget * button, gpointer data);



/** @brief 数字区数字区除 = 之外的按钮单击
 * 
 * @param button
 * @param data 文本框
 */
void on_button_clicked(GtkWidget * button, gpointer data);

/** @brief 求倒数
 * 
 * @param button
 * @param data
 */
void on_button_reciprocal(GtkWidget * button, gpointer data);

/** @brief x^2
 * 
 * @param button
 * @param data
 */
void on_button_square(GtkWidget * button, gpointer data);

/** @brief x^3
 * 
 * @param button
 * @param data
 */
void on_button_cube(GtkWidget * button, gpointer data);

/** @brief sqrt(x)
 * 
 * @param button
 * @param data
 */
void on_button_sqrt(GtkWidget * button, gpointer data);

/** @brief sin
 * 
 * @param button
 * @param data
 */
void on_button_sin(GtkWidget * button, gpointer data);

/** @brief cos
 * 
 * @param button
 * @param data
 */
void on_button_cos(GtkWidget * button, gpointer data);

/** @brief tan
 * 
 * @param button
 * @param data
 */
void on_button_tan(GtkWidget * button, gpointer data);

/** @brief asin
 * 
 * @param button
 * @param data
 */
void on_button_asin(GtkWidget * button, gpointer data);

/** @brief acos
 * 
 * @param button
 * @param data
 */
void on_button_acos(GtkWidget * button, gpointer data);

/** @brief atan
 * 
 * @param button
 * @param data
 */
void on_button_atan(GtkWidget * button, gpointer data);

int main(int argc, char *argv[]) {
	//主窗体
	GtkWidget *window;
	//主容器 
	GtkWidget * vbox_contain;
	//清除按钮和标签容器
	GtkWidget * hbox_top;
	//标签
	GtkWidget * label;
	//清除按钮
	GtkWidget * button_clear;
	//显示输入和结果
	GtkWidget * entry;
	//主功能区容器
	GtkWidget * hbox_buttom;
	//数字区表格容器
	GtkWidget * table;
	//扩展功能表格容器
	GtkWidget * table_extends;
	

	gtk_init(&argc, &argv);

	//主窗体
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window), _("通信工程14-4班  1406030430  赵鑫"));
	gtk_window_set_default_size(GTK_WINDOW(window), 370, 220);
	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	gtk_container_set_border_width(GTK_CONTAINER(window), 10);

	g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);

	//主容器
	vbox_contain = gtk_vbox_new( FALSE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(vbox_contain), 3);
	gtk_container_add(GTK_CONTAINER(window), vbox_contain);

	//上半部窗口
	hbox_top = gtk_hbox_new( FALSE, 0);
	label = gtk_label_new(_("计算器--gtk002"));
	button_clear = gtk_button_new_with_label(_("清除"));

	gtk_box_pack_start(GTK_BOX(hbox_top), label, FALSE, FALSE, 5);
	gtk_box_pack_start(GTK_BOX(hbox_top), button_clear, FALSE, FALSE, 10);

	gtk_box_pack_start(GTK_BOX(vbox_contain), hbox_top, FALSE, FALSE, 3);

	//显示框
	entry = gtk_entry_new();
	//设置显示框从右向左显示
	gtk_box_pack_start(GTK_BOX(vbox_contain), entry, FALSE, FALSE, 3);

	g_signal_connect(G_OBJECT(button_clear), "clicked",
			G_CALLBACK(on_button_clear_clicked), (gpointer )entry);

	//下半部分主功能区
	hbox_buttom = gtk_hbox_new( FALSE, 0);
	table = create_table(entry);
	table_extends = create_extends(entry);
	gtk_box_pack_start(GTK_BOX(hbox_buttom), table_extends, FALSE, FALSE, 3);
	gtk_box_pack_start(GTK_BOX(hbox_buttom), table, TRUE, TRUE, 3);

	gtk_box_pack_start(GTK_BOX(vbox_contain), hbox_buttom, FALSE, FALSE, 3);

	gtk_widget_show_all(window);

	gtk_main();

	return 0;
}

/** @brief 创建数字区
 * 
 * @return
 */
GtkWidget * create_table(GtkWidget * entry) {
	//表格容器
	GtkWidget * table;

	//数字
	GtkWidget * button_0;
	GtkWidget * button_1;
	GtkWidget * button_2;
	GtkWidget * button_3;
	GtkWidget * button_4;
	GtkWidget * button_5;
	GtkWidget * button_6;
	GtkWidget * button_7;
	GtkWidget * button_8;
	GtkWidget * button_9;

	//小数点
	GtkWidget * button_dot;
	//等于号
	GtkWidget * button_eq;

	//运算符
	GtkWidget * button_sum;
	GtkWidget * button_minus;
	GtkWidget * button_ride;
	GtkWidget * button_divide;

	//创建各个组件并与相关事件处理函数连接起来 
	button_0 = gtk_button_new_with_label("0");
	g_signal_connect(G_OBJECT(button_0), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_1 = gtk_button_new_with_label("1");
	g_signal_connect(G_OBJECT(button_1), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_2 = gtk_button_new_with_label("2");
	g_signal_connect(G_OBJECT(button_2), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_3 = gtk_button_new_with_label("3");
	g_signal_connect(G_OBJECT(button_3), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_4 = gtk_button_new_with_label("4");
	g_signal_connect(G_OBJECT(button_4), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_5 = gtk_button_new_with_label("5");
	g_signal_connect(G_OBJECT(button_5), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_6 = gtk_button_new_with_label("6");
	g_signal_connect(G_OBJECT(button_6), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_7 = gtk_button_new_with_label("7");
	g_signal_connect(G_OBJECT(button_7), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_8 = gtk_button_new_with_label("8");
	g_signal_connect(G_OBJECT(button_8), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_9 = gtk_button_new_with_label("9");
	g_signal_connect(G_OBJECT(button_9), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);

	button_dot = gtk_button_new_with_label(".");
	g_signal_connect(G_OBJECT(button_dot), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_eq = gtk_button_new_with_label("=");
	g_signal_connect(G_OBJECT(button_eq), "clicked",
			G_CALLBACK(on_button_eq_clicked), (gpointer )entry);

	button_sum = gtk_button_new_with_label("+");
	g_signal_connect(G_OBJECT(button_sum), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_minus = gtk_button_new_with_label("-");
	g_signal_connect(G_OBJECT(button_minus), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_ride = gtk_button_new_with_label("*");
	g_signal_connect(G_OBJECT(button_ride), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_divide = gtk_button_new_with_label("/");
	g_signal_connect(G_OBJECT(button_divide), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);

	//创建表格容器 
	table = gtk_table_new(4, 4, TRUE);
//  gtk_table_set_row_spacing(GTK_TABLE(table), 4, 5);
//  gtk_table_set_col_spacing(GTK_TABLE(table), 4, 5);

//将各个组件添加到表格窗口
	gtk_table_attach_defaults(GTK_TABLE(table), button_7, 0, 1, 0, 1);
	gtk_table_attach_defaults(GTK_TABLE(table), button_8, 1, 2, 0, 1);
	gtk_table_attach_defaults(GTK_TABLE(table), button_9, 2, 3, 0, 1);
	gtk_table_attach_defaults(GTK_TABLE(table), button_sum, 3, 4, 0, 1);

	gtk_table_attach_defaults(GTK_TABLE(table), button_4, 0, 1, 1, 2);
	gtk_table_attach_defaults(GTK_TABLE(table), button_5, 1, 2, 1, 2);
	gtk_table_attach_defaults(GTK_TABLE(table), button_6, 2, 3, 1, 2);
	gtk_table_attach_defaults(GTK_TABLE(table), button_minus, 3, 4, 1, 2);

	gtk_table_attach_defaults(GTK_TABLE(table), button_1, 0, 1, 2, 3);
	gtk_table_attach_defaults(GTK_TABLE(table), button_2, 1, 2, 2, 3);
	gtk_table_attach_defaults(GTK_TABLE(table), button_3, 2, 3, 2, 3);
	gtk_table_attach_defaults(GTK_TABLE(table), button_ride, 3, 4, 2, 3);

	gtk_table_attach_defaults(GTK_TABLE(table), button_0, 0, 1, 3, 4);
	gtk_table_attach_defaults(GTK_TABLE(table), button_dot, 1, 2, 3, 4);
	gtk_table_attach_defaults(GTK_TABLE(table), button_eq, 2, 3, 3, 4);
	gtk_table_attach_defaults(GTK_TABLE(table), button_divide, 3, 4, 3, 4);

	return table;
}

/** @brief 创建平方开方三角函数等扩展功能
 * 
 * @param entry 文本框
 * @return 创建好的表格容器
 */
GtkWidget * create_extends(GtkWidget * entry) {

	//表格容器
	GtkWidget * table;

	//三角函数
	GtkWidget * button_sin;
	GtkWidget * button_cos;
	GtkWidget * button_tan;
	GtkWidget * button_asin;
	GtkWidget * button_acos;
	GtkWidget * button_atan;

	//平方开方
	GtkWidget * button_square; //平方
	GtkWidget * button_cube; //三次方
	GtkWidget * button_sqrt; //开方
	GtkWidget * button_reciprocal; //倒数

	//左右括号
	GtkWidget * button_paren_left;
	GtkWidget * button_paren_right;

	//创建各个组件
	button_sin = gtk_button_new_with_label("sin");
	g_signal_connect(G_OBJECT(button_sin), "clicked", G_CALLBACK(on_button_sin),
			(gpointer )entry);
	button_cos = gtk_button_new_with_label("cos");
	g_signal_connect(G_OBJECT(button_cos), "clicked", G_CALLBACK(on_button_cos),
			(gpointer )entry);
	button_tan = gtk_button_new_with_label("tan");
	g_signal_connect(G_OBJECT(button_tan), "clicked", G_CALLBACK(on_button_tan),
			(gpointer )entry);
	button_asin = gtk_button_new_with_label("asin");
	g_signal_connect(G_OBJECT(button_asin), "clicked",
			G_CALLBACK(on_button_asin), (gpointer )entry);
	button_acos = gtk_button_new_with_label("acos");
	g_signal_connect(G_OBJECT(button_acos), "clicked",
			G_CALLBACK(on_button_acos), (gpointer )entry);
	button_atan = gtk_button_new_with_label("atan");
	g_signal_connect(G_OBJECT(button_atan), "clicked",
				G_CALLBACK(on_button_atan), (gpointer )entry);

	button_reciprocal = gtk_button_new_with_label("1/x");
	g_signal_connect(G_OBJECT(button_reciprocal), "clicked",
			G_CALLBACK(on_button_reciprocal), (gpointer )entry);
	button_square = gtk_button_new_with_label("x^2");
	g_signal_connect(G_OBJECT(button_square), "clicked",
			G_CALLBACK(on_button_square), (gpointer )entry);
	button_cube = gtk_button_new_with_label("x^3");
	g_signal_connect(G_OBJECT(button_cube), "clicked",
			G_CALLBACK(on_button_cube), (gpointer )entry);
	button_sqrt = gtk_button_new_with_label("sqrt(x)");
	g_signal_connect(G_OBJECT(button_sqrt), "clicked",
			G_CALLBACK(on_button_sqrt), (gpointer )entry);

	button_paren_left = gtk_button_new_with_label("(");
	g_signal_connect(G_OBJECT(button_paren_left), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);
	button_paren_right = gtk_button_new_with_label(")");
	g_signal_connect(G_OBJECT(button_paren_right), "clicked",
			G_CALLBACK(on_button_clicked), (gpointer )entry);

	//创建表格容器 
	table = gtk_table_new(4, 3, TRUE);

	gtk_table_attach_defaults(GTK_TABLE(table), button_reciprocal, 0, 1, 0, 1);
	gtk_table_attach_defaults(GTK_TABLE(table), button_paren_left, 1, 2, 0, 1);
	gtk_table_attach_defaults(GTK_TABLE(table), button_paren_right, 2, 3, 0, 1);

	gtk_table_attach_defaults(GTK_TABLE(table), button_square, 0, 1, 1, 2);
	gtk_table_attach_defaults(GTK_TABLE(table), button_sin, 1, 2, 1, 2);
	gtk_table_attach_defaults(GTK_TABLE(table), button_asin, 2, 3, 1, 2);

	gtk_table_attach_defaults(GTK_TABLE(table), button_cube, 0, 1, 2, 3);
	gtk_table_attach_defaults(GTK_TABLE(table), button_cos, 1, 2, 2, 3);
	gtk_table_attach_defaults(GTK_TABLE(table), button_acos, 2, 3, 2, 3);

	gtk_table_attach_defaults(GTK_TABLE(table), button_sqrt, 0, 1, 3, 4);
	gtk_table_attach_defaults(GTK_TABLE(table), button_tan, 1, 2, 3, 4);
	gtk_table_attach_defaults(GTK_TABLE(table), button_atan, 2, 3, 3, 4);

	return table;

	return NULL;
}

/** @brief 等于单击
 * 
 * 
 * @param button
 * @param data 表达式处理器
 */
void on_button_eq_clicked(GtkWidget * button, gpointer data) {
	GtkWidget * entry = (GtkWidget*) data;
	tools_delete_spaces(expression);
	tools_add_zero(expression);
	tools_add_sharp(expression);

	stackPtr stack = stack_create(0);
	bolan_from_exp(expression, stack);

	bolan_inverted(stack);

	double res = bolan_cal(stack);
	sprintf(expression, "%lf", res);
	tools_exp_handle_zero(expression);

	gtk_entry_set_text((GtkEntry*) entry, expression);

}

/** @brief 清除按钮,清除本次数字输入,以便重新输入
 * 
 * @param button
 * @param data 表达式处理器
 */
void on_button_clear_clicked(GtkWidget * button, gpointer data) {

	GtkEntry * entry = (GtkEntry*) data;
	gtk_entry_set_text(entry, "");
	for (i = 0; i < 100; i++) {
		expression[i] = '\0';
	}
	i = 0;

}

/** @brief 数字区数字区除 = 之外的按钮单击
 * 
 * @param button
 * @param data 文本框
 */
void on_button_clicked(GtkWidget * button, gpointer data) {
	const gchar * num = gtk_button_get_label((GtkButton*) button);
	GtkWidget * entry = (GtkWidget*) data;
	expression[i] = *num;
	i++;
	gtk_entry_set_text((GtkEntry*) entry, expression);
}

/** @brief 求倒数
 * 
 * @param button
 * @param data
 */
void on_button_reciprocal(GtkWidget * button, gpointer data) {
	GtkWidget * entry = (GtkWidget*) data;
	double res = atof(expression);
	res = 1 / res;

	sprintf(expression, "%lf", res);
	tools_exp_handle_zero(expression);

	gtk_entry_set_text((GtkEntry*) entry, expression);

}

/** @brief x^2
 * 
 * @param button
 * @param data
 */
void on_button_square(GtkWidget * button, gpointer data) {
	GtkWidget * entry = (GtkWidget*) data;
	double res = atof(expression);
	res = res * res;

	sprintf(expression, "%lf", res);
	tools_exp_handle_zero(expression);

	gtk_entry_set_text((GtkEntry*) entry, expression);
}

/** @brief x^3
 * 
 * @param button
 * @param data
 */
void on_button_cube(GtkWidget * button, gpointer data) {
	GtkWidget * entry = (GtkWidget*) data;
	double res = atof(expression);
	res = res * res * res;

	sprintf(expression, "%lf", res);
	tools_exp_handle_zero(expression);

	gtk_entry_set_text((GtkEntry*) entry, expression);
}

/** @brief sqrt(x)
 * 
 * @param button
 * @param data
 */
void on_button_sqrt(GtkWidget * button, gpointer data) {
	GtkWidget * entry = (GtkWidget*) data;
	double res = atof(expression);
	res = sqrt(res);

	sprintf(expression, "%lf", res);
	tools_exp_handle_zero(expression);

	gtk_entry_set_text((GtkEntry*) entry, expression);
}

/** @brief sin
 * 
 * @param button
 * @param data
 */
void on_button_sin(GtkWidget * button, gpointer data) {
	GtkWidget * entry = (GtkWidget*) data;
	double res = atof(expression);
	res = sin(3.1415926 * res / 180.0);

	sprintf(expression, "%lf", res);
	tools_exp_handle_zero(expression);

	gtk_entry_set_text((GtkEntry*) entry, expression);
}

/** @brief tan
 * 
 * @param button
 * @param data
 */
void on_button_cos(GtkWidget * button, gpointer data) {
	GtkWidget * entry = (GtkWidget*) data;
	double res = atof(expression);
	res = cos(3.1415926 * res / 180.0);

	sprintf(expression, "%lf", res);
	tools_exp_handle_zero(expression);

	gtk_entry_set_text((GtkEntry*) entry, expression);
}

/** @brief tan
 * 
 * @param button
 * @param data
 */
void on_button_tan(GtkWidget * button, gpointer data) {
	GtkWidget * entry = (GtkWidget*) data;
	double res = atof(expression);
	res = tan(3.1415926 * res / 180.0);

	sprintf(expression, "%lf", res);
	tools_exp_handle_zero(expression);

	gtk_entry_set_text((GtkEntry*) entry, expression);
}

/** @brief asin
 * 
 * @param button
 * @param data
 */
void on_button_asin(GtkWidget * button, gpointer data) {
	GtkWidget * entry = (GtkWidget*) data;
	double res = atof(expression);
	res = asin(res)*180.0/3.141592;

	sprintf(expression, "%lf", res);
	tools_exp_handle_zero(expression);

	gtk_entry_set_text((GtkEntry*) entry, expression);
}

/** @brief acos
 * 
 * @param button
 * @param data
 */
void on_button_acos(GtkWidget * button, gpointer data) {
	GtkWidget * entry = (GtkWidget*) data;
	double res = atof(expression);
	res = acos(res)*180.0/3.141592;

	sprintf(expression, "%lf", res);
	tools_exp_handle_zero(expression);

	gtk_entry_set_text((GtkEntry*) entry, expression);
}

/** @brief atan
 * 
 * @param button
 * @param data
 */
void on_button_atan(GtkWidget * button, gpointer data){
	GtkWidget * entry = (GtkWidget*) data;
	double res = atof(expression);
	res = atan(res)*180.0/3.141592;

	sprintf(expression, "%lf", res);
	tools_exp_handle_zero(expression);

	gtk_entry_set_text((GtkEntry*) entry, expression);	
}


运行效果:


© 著作权归作者所有

小代码2016
粉丝 45
博文 328
码字总数 153495
作品 0
安阳
程序员
私信 提问
加载中

评论(3)

小代码2016
小代码2016 博主

引用来自“tannotour”的评论

为啥不用qt或c# 3
因为我不会,就算我用qt或者c#做出来了,学妹也看不明白啊
tannotour
tannotour
为啥不用qt或c# 3
sunday12345
sunday12345
学妹搞定了么?
科学计算器--galculator

galculator 是一个基于GTK2/GTK的代数模式、RPN和公式的输入模式3为基础的科学计算器。功能包括算术运算,加上优先处理,全键盘的支持,三角函数,乘积,平方根,自然和常用对数,常数(E,P...

匿名
2012/10/16
1K
0
galculator 2.0 发布,科学计算器

galculator 2.0 支持 GTK 3,修复了很多bug,包括一些新的翻译。 galculator 是一个基于GTK2/GTK的代数模式、RPN和公式的输入模式3为基础的科学计算器。功能包括算术运算,加上优先处理,全键...

oschina
2012/10/16
928
1
pfcalc的图形化前端--Qpfcalc

gpfcalc一个GTK+前端的pfcalc,使用摩擦计算器Darcy-Weisbach方程。它用于计算通过管道或管道流主要的、次要的、和静态的损失。1024管道或管道可以指定水力直径、长度、平整度、流量、温度和...

匿名
2011/09/03
438
0
galculator 2.0.1 发布,桌面科学计算器

galculator 2.0.1 的配置文件改用符合 XDG 规范的路径,修复了 GUI 和解析器方面的几个 bug。 galculator 是一个基于GTK2/GTK的代数模式、RPN和公式的输入模式3为基础的科学计算器。功能包括...

oschina
2012/12/16
726
1
galculator 2.1.1 发布,科学计算器

galculator 2.1.1 修复了构建过程中的一些问题,移植一些废弃的 GUI 元素到最新的 GTK3。 galculator 是一个基于GTK2/GTK的代数模式、RPN和公式的输入模式3为基础的科学计算器。功能包括算术...

oschina
2013/04/29
1K
3

没有更多内容

加载失败,请刷新页面

加载更多

64.监控平台介绍 安装zabbix 忘记admin密码

19.1 Linux监控平台介绍 19.2 zabbix监控介绍 19.3/19.4/19.6 安装zabbix 19.5 忘记Admin密码如何做 19.1 Linux监控平台介绍: 常见开源监控软件 ~1.cacti、nagios、zabbix、smokeping、ope...

oschina130111
今天
13
0
当餐饮遇上大数据,嗯真香!

之前去开了一场会,主题是「餐饮领袖新零售峰会」。认真听完了餐饮前辈和新秀们的分享,觉得获益匪浅,把脑子里的核心纪要整理了一下,今天和大家做一个简单的分享,欢迎感兴趣的小伙伴一起交...

数澜科技
今天
7
0
DNS-over-HTTPS 的下一代是 DNS ON BLOCKCHAIN

本文作者:PETER LAI ,是 Diode 的区块链工程师。在进入软件开发领域之前,他主要是在做工商管理相关工作。Peter Lai 也是一位活跃的开源贡献者。目前,他正在与 Diode 团队一起开发基于区块...

红薯
今天
12
0
CC攻击带来的危害我们该如何防御?

随着网络的发展带给我们很多的便利,但是同时也带给我们一些网站安全问题,网络攻击就是常见的网站安全问题。其中作为站长最常见的就是CC攻击,CC攻击是网络攻击方式的一种,是一种比较常见的...

云漫网络Ruan
今天
12
0
实验分析性专业硕士提纲撰写要点

为什么您需要研究论文的提纲? 首先当您进行研究时,您需要聚集许多信息和想法,研究论文提纲可以较好地组织你的想法, 了解您研究资料的流畅度和程度。确保你写作时不会错过任何重要资料以此...

论文辅导员
今天
8
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部