数据结构课设

其他 2019-04-14 17:01:30 阅读次数: 0

                                             计算表达式

设计内容：设计一个程序，把中缀表达式转换成一棵二叉树，然后通过后序（根）遍历计算表达式的值。

设计要求： 对于输入的一个中缀表达式，判断表达式是否合法。（表达式的输入符合四则运算的显示规范）

如果合法，把中缀表达式转换成一棵二叉树。（创建二叉链表，数据结构为二叉链表）

通过后序（根）遍历计算表达式的值，输出运算结果。（表达式求值）

需要注意的是，合法表达式不能为空，可以出现在表达式中的字符有：

运算符“+”、“-”、“*”、“／”； 左右括号“(”、“)”； 整数(可以是多位的)；

（难点：如何识别？） 空格符和制表符。

测试用例：20 + ( 3 * ( 4 + 46 ) – 6 )／2 - 134

预期测试结果：-42

所谓前缀、中缀、后缀，是指运算符相对于运算数的位置而言，看如下例子：

(1 + 2) × 3 - 4   就是中缀表达式
- × + 1 2 3 4     就是前缀表达式
1 2 + 3 × 4 -     就是后缀表达式

所以按照题目的要求我们可以把中缀表达式转化为后缀表达式，然后再进行计算

那么关于中缀表达式的转化方式方法如下:

1 设立运算符栈

2 设立表达式的结束符：'\0'

3 如果当前字符是操作数，则直接发送给后缀表达式

4 如果当前字符串为运算符并且优先级大于栈顶运算符，则进栈；否则，先将栈中的优先级大于或者等于当前的运算符的

运算符依次出栈，并且发送给后缀表达式，再将当前的运算符进栈。

5 如果当前运算符是结束符:'\0',则自栈顶至栈底依次将栈中所有运算符发送给后缀表达式

6 如果当前运算符是"("时则进栈

7 如果当前字符是")"，则从栈顶起，将运算符依次出栈，并且发送给后缀表达式直接直至栈顶的运算符为"（"时为止，再将"("出栈

按照如上所述就可以得到一个后缀表达式。然后后缀表达式的求值过程为；对后缀表达式从左往右依次进行扫描，遇见操作数则暂时保存，遇见运算符及可以进行运算。此时参加运算的两个操作数应该是在它之前刚刚碰到的两个操作数

首先我们先将栈的函数完成

byc.cpp

#include <stdio.h>
#define MAXSIZE 1024//设置最大的长度
typedef char elemptype;


typedef struct SequenStack
{
    elemptype data[MAXSIZE];
    int top;//设置栈顶指针
}SequenStack;


//初始化顺序栈
SequenStack *Init_SequenStack()
{
    SequenStack *S;
    S=(SequenStack *)malloc(sizeof(SequenStack));
    //申请结构体的使用空间
    S->top=-1;
    return S;
}


//判断栈是否是空
int SequenStack_Empty(SequenStack *S)
{
    if(S->top==-1)
        return 1;
    else
        return 0;
}


//判断顺序栈是否是满的
int SequenStack_Full(SequenStack *S)
{
    if(S->to+1==MAXSIZE)
        return 1;
    else
        return 0;
}


//入栈
int Push_SequenStack(SequenStack *S,elemptype x)
{
    if(S->top>=MAXSIZE-1)
        {
            printf("栈满\n");
            return 0;
        }
    S->top++;//如果栈没有满，那就入栈
    S->data[S->top]=x;
    return 1;
}


//出栈
int Pop_SequenStack(SequenStack *S,elemptype *x)
{
    if(S->top==-1)//没有内容无法出栈
        {
            printf("error");
            return 0;
        }
    else
    {
        S->top--;
        *x=S->data[S->top+1];
        return 1;
    }
}


//读取栈顶数据元素
int GetTop_SequenStack(SequenStack *S,elemptype *x)
{
    if(S->top==-1)
        {
            printf("error");
            return 0;
        }
    else
        {
            *x=S->data[S->top];
            return 1;
        }
}

在头文件byc.h中

#include <stdio.h>
#include <cstdlib>
#define MAXSIZE 1024//设置最大的长度
typedef char elemptype;


typedef struct SequenStack
{
	elemptype data[MAXSIZE];
	int top;//设置栈顶指针
}SequenStack;

SequenStack *Init_SequenStack();
int SequenStack_Empty(SequenStack *S);
int SequenStack_Full(SequenStack *S);
int Push_SequenStack(SequenStack *S, elemptype x);
int Pop_SequenStack(SequenStack *S, elemptype *x);
int GetTop_SequenStack(SequenStack *S, elemptype *x);

然后就是main.cpp主函数部分了

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <stdlib.h>
#include "byc.h"
using namespace std;

int changeCharToData(char c);
char changeDataToChar(int x);
void calculate(SequenStack *S, char operato);
int arithmeticalOperate(int operand1, int operand2, char operato);

int evaluatePostfixExpression(char *express);
char *transIntoPostfixExpression(char *express);

int main()
{
	char *infixExpression;//中缀表达式
	char *postfixExpression;//后缀表达式
	int result = 0;//表达式的计算结果
	infixExpression = (char *)malloc(sizeof(char));

	printf("请输入表达式:");//此处输入的是中缀表达式
	cin >> infixExpression;//完成输入
	postfixExpression = transIntoPostfixExpression(infixExpression);//将中缀表达式转化成后缀表达式
	result = evaluatePostfixExpression(postfixExpression);
	printf("表达式的计算结果为:%s=%d\n", infixExpression, result);//最终完成后的输出
	system("pause");
	return 0;
}

//根据后缀表达式express计算表达式的值,并且返回计算的结果
int evaluatePostfixExpression(char *express)
{
	char oprand;//储存后缀表达式的操作数或者运算符
	SequenStack *S;
	char result;         //储存运算结果
	int i;
	S = Init_SequenStack();
	for (i = 0; express[i] != '\0'; i++)
	{
		oprand = express[i];
		if (oprand >= '0'&&oprand <= '9')
		{
			Push_SequenStack(S, oprand);//如果是操作数那么入栈
		}
		else
		{
			calculate(S, oprand);//否则是操作符，则调用calculate()函数求值计算
		}
	}
	//将栈中的存放的表达式计算结果，通过出栈操作，赋值给result变量，返回调用函数
	Pop_SequenStack(S, &result);
	return changeCharToData(result);
}

//将输入的中缀表达式转化成后缀表达式
char *transIntoPostfixExpression(char *express)
{
	char oprand;
	char operato;
	SequenStack *S;//储存运算符
	char *postfixExpress;//后缀表达式的指针
	int offset = 0;
	int i, len;
	S = Init_SequenStack();
	len = strlen(express);
	postfixExpress = (char*)malloc(len * sizeof(char));
	/*
		遍历中缀表达式式，如果字符为数字，直接存入后缀表达式，否则根据运算符的优先级，进行出栈或者入栈
		操作
	*/
	for (i = 0; express[i] != '\0'; i++)
	{
		oprand = express[i];
		switch (oprand)
		{
		case '+':
		case '-':
			//如果为+，-,则将栈中的‘（’前的运算符出栈并且存到后缀表达式中
			while (!SequenStack_Empty(S))
			{
				GetTop_SequenStack(S, &operato);
				if (operato!='(')
				{
					Pop_SequenStack(S, &operato);
					postfixExpress[offset++] = operato;
				}
				else
				{
					break;
				}
			}
			Push_SequenStack(S, oprand);
			break;

			//如果为* /,则将栈顶为*,/的运算符出栈并且存入后缀表达式
		case '/':
		case '*':
			while (!SequenStack_Empty(S))
			{
				GetTop_SequenStack(S, &operato);
				if (operato=='*' || operato=='/')
				{
					Pop_SequenStack(S, &operato);
					postfixExpress[offset++] = operato;
				}
				else
				{
					break;
				}
			}
			Push_SequenStack(S, oprand);
			break;

			//如果是(,则将(入栈
		case '(':
			Push_SequenStack(S, oprand);
			break;

			//如果是），则将栈中的运算符出栈并且存入后缀表达式
		case ')':
			while (!SequenStack_Empty(S))
			{
				GetTop_SequenStack(S, &operato);
				if (operato!='(')
				{
					Pop_SequenStack(S, &operato);
					postfixExpress[offset++] = operato;
				}
				else
				{
					Pop_SequenStack(S, &operato);
					break;
				}
			}
			break;

		default://如果为操作数，则将操作数存入后缀表达式
			postfixExpress[offset++] = oprand;
		}
	}
	while (!SequenStack_Empty(S))
	{
		Pop_SequenStack(S, &operato);
		postfixExpress[offset++] = operato;
	}
	postfixExpress[offset] = '\0';
	return postfixExpress;
}

//将字符串转化成数字
int changeCharToData(char c)
{
	return c - '0';
}

//将数字转化成字符串
char changeDataToChar(int x)
{
	return x + 48;
}

//根据操作符进行求值计算
void calculate(SequenStack *S, char operato)
{
	char operand1, operand2;//两个字符串变量分别用来存储操作数1和操作数2
	int result;
	Pop_SequenStack(S, &operand2);
	Pop_SequenStack(S, &operand1);
	//根据运算符operator调用arithmeticalOperate函数进行四则运算
	result = arithmeticalOperate(changeCharToData(operand1), changeCharToData(operand2), operato);
	Push_SequenStack(S, changeDataToChar(result));
}

//根据操作数和操作符完成四则运算
int arithmeticalOperate(int operand1, int operand2, char operato)
{
	int result;
	switch (operato)
	{
	case '+':result = operand1 + operand2; break;
	case '-':result = operand1 - operand2; break;
	case '*':result = operand1 * operand2; break;
	case '/':result = operand1 / operand2; break;
	}
	return result;
}

或者我们可以采取另外的一种方式

*Push(SC *s,char c)：把字符压栈
*Push(SF *s,float f)：把数值压栈
*Pop(SC *s)：把字符退栈
*Pop(SF *s)：把数值退栈

char Prior[8][8] =
{ // 运算符优先级表 
	// '+' '-' '*' '/' '(' ')' '#' '^' 
	/*'+'*/'>','>','<','<','<','>','>','<', 
	/*'-'*/'>','>','<','<','<','>','>','<', 
	/*'*'*/'>','>','>','>','<','>','>','<', 
	/*'/'*/'>','>','>','>','<','>','>','<', 
	/*'('*/'<','<','<','<','<','=',' ','<', 
	/*')'*/'>','>','>','>',' ','>','>','>', 
	/*'#'*/'<','<','<','<','<',' ','=','<', 
	/*'^'*/'>','>','>','>','<','>','>','>' 
};

运算符的优先级我们已经知道了，所以下面的方式就比较简单了

#include <stdio.h>
#include <bits/stdc++.h>
#include <math.h>
#include <string.h>
#include <iostream>
using namespace std;

char OPSET[8]={'+','-','*','/','(',')','#','^'};//操作符设定 

char Prior[8][8] =
{ // 运算符优先级表 
	// '+' '-' '*' '/' '(' ')' '#' '^' 
	/*'+'*/'>','>','<','<','<','>','>','<', 
	/*'-'*/'>','>','<','<','<','>','>','<', 
	/*'*'*/'>','>','>','>','<','>','>','<', 
	/*'/'*/'>','>','>','>','<','>','>','<', 
	/*'('*/'<','<','<','<','<','=',' ','<', 
	/*')'*/'>','>','>','>',' ','>','>','>', 
	/*'#'*/'<','<','<','<','<',' ','=','<', 
	/*'^'*/'>','>','>','>','<','>','>','>' 
};
typedef struct DealChar
{
	char c; 
	struct DealChar *next; 
}dealchar;  

     //
typedef struct DealFloat
{
	float f; 
	struct DealFloat *next; 
}dealfloat;       //

dealchar *Push(dealchar *s,char c)          //
{
	dealchar *p=(dealchar*)malloc(sizeof(dealchar)); 
	p->c=c; 
	p->next=s; 
	return p; 
}
dealfloat *Push(dealfloat *s,float f)        //
{
	dealfloat *p=(dealfloat*)malloc(sizeof(dealfloat)); 
	p->f=f; 
	p->next=s; 
	return p; 
}
dealchar *Pop(dealchar *s)    //
{
	dealchar *q=s; 
	s=s->next; 
	free(q); 
	return s; 
}
dealfloat *Pop(dealfloat *s)      //
{
	dealfloat *q=s; 
	s=s->next; 
	free(q); 
	return s; 
}

float Operate(float a, char theta, float b)     //计算函数Operate
{
	switch(theta)
	{
	case '+': return a+b; 
	case '-': return a-b; 
	case '*': return a*b; 
	case '/': return a/b; 
	case '^': return pow(a,b); 
	default : return 0; 
	} 
}


int In(char Test,char *TestOp)
{
	int Find=false; 
	for (int i=0; i<8; i++)
	{
		if(Test == TestOp[i])
			Find= true; 
	} 
	return Find; 
} 
int ReturnOpOrd(char op,char *TestOp)
{ 
	for(int i=0; i<8; i++)
	{
		if (op == TestOp[i])
			return i;
	}

}
char precede(char Aop, char Bop)
{ 

	return Prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)]; 

} 



float EvaluateExpression(char* expression)
{ 
	// 算术表达式求值的算符优先算法
	// 设OPTR和OPND分别为运算符栈和运算数栈，OP为运算符集合 
	dealchar *OPTR=NULL;       // 运算符栈，字符元素 
	dealfloat *OPND=NULL;       // 运算数栈，实数元素 
	char TempData[20]; 
	float Data,a,b; 
	char theta,*c,Dr[]={'#','\0'}; 
	OPTR=Push(OPTR,'#'); 
	c=strcat(expression,Dr); 
	strcpy(TempData,"\0");//字符串拷贝函数 
	while (*c!= '#' || OPTR->c!='#')
	{ 
		if (!In(*c, OPSET))
		{ 
			Dr[0]=*c; 
			strcat(TempData,Dr);           //字符串连接函数 
			c++; 
			if (In(*c, OPSET))
			{ 
				Data=atof(TempData);       //字符串转换函数(double) 
				OPND=Push(OPND, Data); 
				strcpy(TempData,"\0"); 
			} 
		} 
		else    // 不是运算符则进栈 
		{
			switch (precede(OPTR->c, *c))
			{
			case '<': // 栈顶元素优先级低 
				OPTR=Push(OPTR, *c); 
				c++; 
				break; 
			case '=': // 脱括号并接收下一字符 
				OPTR=Pop(OPTR); 
				c++; 
				break; 
			case '>': // 退栈并将运算结果入栈 
				theta=OPTR->c;OPTR=Pop(OPTR); 
				b=OPND->f;OPND=Pop(OPND); 
				a=OPND->f;OPND=Pop(OPND); 
				OPND=Push(OPND, Operate(a, theta, b)); 
				break; 
			} //switch
		}
	} //while 
	return OPND->f; 
} //EvaluateExpression 







int main()
{
	char ch='y';
	while(ch=='y')
	{
		char s[128];
		printf("请输入表达式:"); 
		gets(s);
		printf("该表达式的值为:\n");
		printf("%s\b=%g\n",s,EvaluateExpression(s));
		system("pause");
		printf("是否继续y/n:");
		cin>>ch;
		getchar();	
	} 
	return 0;
}

                                                  学生管理系统

一：需求分析
学生信息管理系统是针对学校人事处的大量业务处理工作而开发的管理软件，主要用于学校学生信息管
理，总体任务是实现学生信息关系的系统化、科学化、规范化和自动化，其主要任务是用计算机对学生各种信
息进行日常管理，如查询、修改、增加、删除，另外还考虑到学生选课，针对这些要求设计了学生信息管理系
统。学生信息档案的管理对于学校的管理者来说至关重要，学生信息是高等学校非常重要的一项数据资源，是
一个教育单位不可缺少一部分。特别是近几年来，国家政策的调整，我国高等院校大规模的扩招，给高等院校
的教学管理、学生管理、后勤管理等方面都带来不少的冲击。其包含的数据量大，涉及的人员面广，而且需要
及时更新，故较为复杂，难以单纯地依靠人工管理，而且传统的人工管理方式既不易于规范化，管理效率也不
高，目前我国各类高等院校中还有相当一部分学生档案管理还停留在纸介质的基础上，尤其是中、小学对学生
档案的管理更是落后，这样的管理机制已经不能适应时代发展的要求，其管理方法将浪费许多人力和物力。随
着科学技术的不断提高，计算机科学与技术日渐成熟，计算机应用的普及已进入人类社会生活的各个领域，并
发挥着越来越重要的作用。这种传统的手工管理模式必然被以计算机为物质基础的信息管理方法所取代。
作为计算机应用的一部分，使用计算机对学生档案进行管理，有着手工管理所无法比拟的优点，如：检索
迅速、查找方便、可靠性高、存储量大、保密性好、寿命长、成本低等。这些优点能够极大地提高学生档案管
理的效率，也是学校向科学化、正规化管理发展的必要条件，更是各个高等院校与世界接轨的重要条件
二：程序的主要功能
2、添加功能
添加一个学生的信息，包括学生的姓名、学号、性别、院系、语文、数学、英语、总分
3、删除功能
删除之前再次确认。确认后只需提供该学生学号便可对该职员信息进行删除，如不确认则回到主界面供用户重
新选择功能
4、排序显示功能
以学生的总分、语文、数学、英语成绩升序显示所有学生的详细信息

5、学生查询功能
只需提供该学号、姓名任一项均可跳过输入，便可显示该学生的详细信息
三：程序运行平台
QtCreator
运行程序，进入登录界面如下：

1、点击添加学生信息模块
添加一个学生的信息，包括学生的姓名、学号、性别、院系、语文、数学、英语、总分

2、点击进入排序显示模块
以学生的总分、语文、数学、英语成绩升序显示所有学生的详细信息

3、点击进入查询信息模块
只需要提供：学号、姓名任一项均可跳过输入，便可显示该学生的详细信息

查询后可执行删除功能
删除之前再次确认，如不确认则回到主界面供用户重新选择模块

四、系统总框架图

 程序类的说明
1) baomain函数
baomain函数被 main主函数调用，然后进入主界面显示
2) readFormFile函数
readFormFile函数功能为读取磁盘文件中的学生信息
模块分析
1、添加学生信息模块
先判断磁盘是否已满。如果已满，提示已满并返回选择操作菜单。如未满，则请用户依次输入学生姓名、学
号、性别、院系、语文、数学、英语、总分等各项信息（任一项可暂时空缺）。如添加成功，则提示成功，返
回选择操作菜单；反之，直接返回选择操作菜单。
2、删除学生信息模块
删除前再请用户确认一次是否删除。如果不确认，返回选择操作菜单。如确认，请用户选择需要删除的学生，
再执行删除操作。如删除成功，直接返回选择操作菜单。
3、查询学生信息模块
先判断信息表是否为空。如果为空，提示为空并返回选择操作菜单。如不为空，请用户输入学生信息（只需姓
名、学号任一项）。如果未找到学生，提示未找到，返回选择操作菜单。如找到学生，在屏幕上显示该学生项
的各项信息。
5、 排序显示职员信息模块先判断信息表是否为空。如果为空，提示为空并返回选择操作菜单。如果不为空，
以学生的总分、语文、数学、英语各项（基于用户选择）作为依据进行排序，将排序后的结果显示在界面
上。
比较有特色的函数：
1）baomain函数
1、函数分析
baomain函数被 main主函数调用，然后进入主界面显示
2、函数源代码
2）readFormFile函数
1、函数分析
readFormFile函数功能为读取磁盘文件中的学生信息
2、函数源代码
存在的不足与编程体会：
1）存在的不足
还可以加入更高级的算法进行学生各科成绩信息的排序，同时也可以加入修改学生模块，增添更多的功能。
2）编程体会
1、多写通用公用的类、代码结构要易于维护，修改起来较容易
2、注意编码风格，变量、函数、常量的命名一目了然，方便日后维护
3、整个系统编码一定要有规范，调用函数的代码根据返回的状态做相应的处理，高度模块化，条理清晰，合理
有序
4、要创建更友好的用户界面，让交互数据输入更方便，减少错误输入的影响。在编写交互式程序时，应该事先
预料到用户可能会输入错误，然后设计程序处理用户的错误输入，在用户出错时提醒用户再次输入
5、要切身体会用户的使用环境和需求，增加功能实现，反复改进代码
6、debug的过程很辛苦，要不断模拟用户可能的操作来调试测试程序。要有足够的耐心和心理调节能力，要耐
住寂寞、忍受孤独

项目源码部分：

添加学生：(addstu)
addstu.h
#ifndefADDSTU_H
#defineADDSTU_H
#include<QDialog>
#include<QButtonGroup>
#include<QString>
#include"querystu.h"
namespaceUi{
classaddstu;
}
classaddstu:publicQDialog
{
Q_OBJECT
public:
explicitaddstu(QWidget*parent=0);
~addstu();
voidclearUserInterface();
voidwriteToFile(QStringcnt);
privateslots:
voidon_B_ok_clicked();
voidon_B_no_clicked();
private:
Ui::addstu*ui;
QButtonGroup*GenderGroup;
QButtonGroup*StatusGroup;
};
#endif//ADDSTU_H
addstu.cpp
#include"addstu.h"
#include"ui_addstu.h"
#include<QMessageBox> //提供一个小提示框
/* egQMessageBoxmsgBox;对象
msgBox.setText("")
msgBox.exce();
显示文本
msgBox.setText("大标文");
msgBox.setInformativeText("小标文");
msgBox.setStandardButton(QMessageBox::Save|QMessageBox::Discord|QMessageBox::Cannel);
msgBox.setDefaultButton(QMessageBox::Save);//设置默认的按键
intlet=msgBox.exec();*/
#include<QAbstractButton>
#include<QPushButton>
#include<QString>
#include<QLabel>
#include<QButtonGroup>
#include<QFile>
#include<QTextStream>
#include<QIODevice>//这三个是文件处理的头文件；
#include"querystu.h"
#include<QStringList>
#include<QWidget>
#include<QtWidgets>
addstu::addstu(QWidget*parent):
QDialog(parent),
ui(newUi::addstu)
{
ui->setupUi(this);
}
addstu::~addstu()
{
deleteui;
}
voidaddstu::on_B_ok_clicked()
{
QStringname=this->ui->le_name->text();
QStringid=this->ui->le_id->text();
QStringsex;
QStringchinese=this->ui->le_chinese->text();
if(chinese.length()==1)
chinese="00"+chinese;
elseif(chinese.length()==2)
chinese="0"+chinese;
QStringmath=this->ui->le_math->text();
if(math.length()==1)
math="00"+math;
elseif(math.length()==2)
math="0"+math;
QStringenglish=this->ui->le_english->text();
if(english.length()==1)
english="00"+english;
elseif(english.length()==2)
english="0"+english;
QStringerro=this->ui->le_tot->text();
GenderGroup=newQButtonGroup(this);
GenderGroup->addButton(ui->rbtn_male,0);
GenderGroup->addButton(ui->rbtn_fmale,1);
doublenum1,num2,num3,num4;//将字符串转化成数值，double型
num1=chinese.toDouble();
num2=math.toDouble();
num3=english.toDouble();
num4=num1+num2+num3;
QStringtot=QString::number(num4);//至此转化完毕,并
if(ui->rbtn_male->isChecked())
{
sex="男";
}
else
{
sex="女";
}
QStringdev=this->ui->cbb_yx->currentText();
QStringcontent=name+'\n'+id+'\n'+sex+'\n'+dev+'\n'+chinese+'\n'+math+'\n'+english+'\n'+tot+'\n';
QStringcnt=name+""+id+""+sex+""+dev+""+chinese+""+math+""+english+""+tot+"\n";
intret;
if(name.length()<1||id.length()!=10||erro!="")
{
QMessageBox::critical(this,"错误","信息填写不正确,请重新检查","确定");
}
else
{
ret=QMessageBox::question(this,"确认信息",content,"确定","取消");
}
if(ret==0)
{
clearUserInterface();
writeToFile(cnt);
}
}
voidaddstu::clearUserInterface()
{
this->ui->le_name->clear();
this->ui->le_id->clear();
this->ui->rbtn_male->setChecked(true);
this->ui->cbb_yx->setCurrentIndex(0);
this->ui->le_chinese->clear();
this->ui->le_math->clear();
this->ui->le_english->clear();
this->ui->le_tot->clear();
this->ui->le_name->setFocus();
}
voidaddstu::writeToFile(QStringcnt)
{
QFilefile("stu.txt");
if(!file.open(QIODevice::Append|QIODevice::Text))
{
QMessageBox::critical(this,"错误","保存信息失败，请重新输入","确定");
return;
}
QTextStream out(&file);//输入语句对应 file的文件路径,stu.txt;
out<<cnt;//这两句的作用是将文件的内容写入 stu.txt中;
file.close();
}
voidaddstu::on_B_no_clicked()
{
this->close();
}
addstu.cpp中 OK组代码如下：
QStringname=this->ui->name->text();
QStringid=this->ui->le_id->text();
QMessageBoxmsgBox;
msgBox.setText("确认信息");
msgBox.setInformativeText(name+'\n'+id);
msgBox.setStandardButtons(QMessageBox::Save|QMessageBox::Cannel);
msgBox.setDefaultButton(QMessageBox::Save);
content=name+'\n'+id+'\n'+sex+'\n'+age+'\n'+ins;
if(name.length()<1||id.length!=10)
{
QMessageBox::critical;
intret=msgBox.exec();
}
if(ret==0)
{
clearUserInterface();
writeToFile(cnt);
}
设置按键选项成为中文：
msgBox.addButton("确定",QMessageBox::AcceptRole);
msgBox.addButton("取消",QMessageBox::RejectRole);
//这两行最后的选项是属于类型选项
设置默认的自定义按钮：
QPushButton在#include<QPushButton>中
QMessageBox::information(this,"确认",name+'\n'+id,QMessageBox::OK|QMessageBox::Cannel);
"确认"，"取消"可改为中文的按钮
QMessageBox::critical,warning,question与上格式一样。
clearButton;//清除按钮可用
comboBOx的使用：
QStringsex=this->ui->sexGroup->checkedButton()->text();
//作用获取单选框的文本内容
QList<QAbstractButton*>ins_list;
this->ui->insGroup->button();
//获取下拉列表的内容
this->ui->le_name->clear();
this->ui->le_id->clear();
//实现学号与姓名的清空
this->ui->rbtn_male->setChecked(true);
//使性别选项恢复成男性
this->cbb_age->setCurrentText("17");
//将年龄默认为 17岁，但这样做不太好。(语言不同问题);
this->ui->cbb_age->setCurrentIndex(0);
this->ui->cbb_yx->setCurrentIndex(0);
//恢复默认的选项，即第一个选项
将起点设置位置：
this->ui->name->setFocus();
voidaddstu::writeToFile(QStringcnt)
{
QFilefile("stu.txt");
if(!file.open(QIODevice::Append|QIODevice::Text))
//如果打开不存在自动创建
//以文本的格式写入
{
QMessageBox::critical(=====);
}
QTextStream out(&file);
out<<cnt;
}
baomain.h
#ifndefBAOMAIN_H
#defineBAOMAIN_H
#include<QMainWindow>
#include"addstu.h"
#include"querystu.h"
#include"stuall.h"
namespaceUi{
classbaomain;
}
classbaomain:publicQMainWindow
{
Q_OBJECT
public:
explicitbaomain(QWidget*parent=0);
~baomain();
privateslots:
voidon_rbt_add_clicked();
voidon_rbt_look_clicked();
voidon_rbt_tuichu_clicked();
voidon_rbt_all_clicked();
private:
Ui::baomain*ui;
addstua;
QueryStub;
stuallbao;
};
#endif//BAOMAIN_H
baomain.cpp
#include"baomain.h"
#include"ui_baomain.h"
#include"addstu.h"
#include"querystu.h"
baomain::baomain(QWidget*parent):
QMainWindow(parent),
ui(newUi::baomain)
{
ui->setupUi(this);
}
baomain::~baomain()
{
deleteui;
}
voidbaomain::on_rbt_add_clicked()
{
//addstuw;
//w.exec();//模态视图造成阻塞
this->a.show();
}
voidbaomain::on_rbt_look_clicked()
{
//this->b.readFormfile();
this->b.show();
}
voidbaomain::on_rbt_tuichu_clicked()
{
this->close();
}
voidbaomain::on_rbt_all_clicked()
{
this->b.readFormfile();
this->bao.show();
}
querystu.h
#ifndefQUERYSTU_H
#defineQUERYSTU_H
#include<QDialog>
#include<QString>
#include<QFile>
#include<QList>
#include<QStandardItem>
#include<QStandardItemModel>
#include"addstu.h"
namespaceUi{
classQueryStu;
}
classQueryStu:publicQDialog
{
Q_OBJECT
public:
explicitQueryStu(QWidget*parent=0);
~QueryStu();
intreadFormfile();
voiddoQuery(intindex,QStringcnt);
voiddisplay(introw,QStringListsubs);
QList<QString>stu_lines;
privateslots:
voidon_pb_bao_clicked();
voidon_rbt_back_clicked();
voidon_rbt_shanchu_clicked();
private:
Ui::QueryStu*ui;
QStandardItemModel*model;
};
#endif//QUERYSTU_H
querystu.cpp中
#include"querystu.h"
#include"ui_querystu.h"
#include<QIODevice>
#include<QTextStream>
#include<QMessageBox>
#include<QDebug>
#include<QStringList>
#include<QFile>
intshu;
QStringline1;
QueryStu::QueryStu(QWidget*parent):
QDialog(parent),
ui(newUi::QueryStu)
{
ui->setupUi(this);
if(readFormfile()==-1)
{
QMessageBox::critical(this,"严重错误","文件打开失败,请重试","确定");
this->close();
}
this->model=newQStandardItemModel;
this->model->setHorizontalHeaderItem(0,newQStandardItem(QObject::tr("姓名")));
this->model->setHorizontalHeaderItem(1,newQStandardItem(QObject::tr("学号")));
this->model->setHorizontalHeaderItem(2,newQStandardItem(QObject::tr("性别")));
this->model->setHorizontalHeaderItem(3,newQStandardItem(QObject::tr("院系")));
this->model->setHorizontalHeaderItem(4,newQStandardItem(QObject::tr("语文")));
this->model->setHorizontalHeaderItem(5,newQStandardItem(QObject::tr("数学")));
this->model->setHorizontalHeaderItem(6,newQStandardItem(QObject::tr("英语")));
this->model->setHorizontalHeaderItem(7,newQStandardItem(QObject::tr("总分")));
this->ui->tableView->setModel(model);
}
QueryStu::~QueryStu()
{
deleteui;
}
intQueryStu::readFormfile()
{
QFilefile("stu.txt");
if(!file.open(QIODevice::ReadOnly|QIODevice::Text))
{
return-1;
}
QTextStream in(&file);
while(!in.atEnd())
{
QStringline=in.readLine();
stu_lines.append(line);
}
qDebug()<<stu_lines.length();
file.close();
}
voidQueryStu::on_pb_bao_clicked()
{
intindex=this->ui->cbb_method->currentIndex();
QStringcnt=this->ui->le_cnt->text();
doQuery(index,cnt);
}
voidQueryStu::doQuery(intindex,QStringcnt)
{
inti=0;
introw=0;
for(i=0;i<stu_lines.length();i++)
{
QStringline=stu_lines.at(i);
//line=line.trimmed();//如果字符串结尾是空格,则自动去除;
QStringListsubs=line.split("");//以""作为分格，将一行字符串进行拆分;
switch(index)
{
case1:
if(cnt==subs.at(0))
{
shu=i;
display(row,subs);
}
break;
case2:
if(cnt==subs.at(1))
{
shu=i;
display(row,subs);
}
break;
}
}
}
voidQueryStu::display(introw,QStringListsubs)
{
inti=0;
for(i=0;i<subs.length();i++)
{
this->model->setItem(row,i,newQStandardItem(subs.at(i)));
}
}
voidQueryStu::on_rbt_back_clicked()
{
this->close();
}
voidQueryStu::on_rbt_shanchu_clicked()
{
QFilefile("stu.txt");
if(!file.open(QIODevice::Append|QIODevice::Truncate|QIODevice::Text))
{
QMessageBox::critical(this,"错误","保存信息失败，请重新输入","确定");
return;
}
file.resize(0);
QTextStream out(&file);//输入语句对应 file的文件路径,stu.txt
stu_lines.removeAt(shu);
for(inti=0;i<stu_lines.length();i++)
{
out<<stu_lines.at(i)<<endl;
}
file.close();
QMessageBox::question(this,"删除","删除成功","确定");
file.close();
stu_lines.clear();
readFormfile();
}
stuall.h中
#ifndefSTUALL_H
#defineSTUALL_H
#include<QDialog>
#include"addstu.h"
#include"querystu.h"
#include<QMessageBox>
#include<QAbstractButton>
#include<QPushButton>
#include<QString>
#include<QLabel>
#include<QButtonGroup>
#include<QFile>
#include<QTextStream>
#include<QIODevice>
#include<QStringList>
namespaceUi{
classstuall;
}
classstuall:publicQDialog
{
Q_OBJECT
public:
explicitstuall(QWidget*parent=0);
~stuall();
voidstuallpaixu(intbaoyuchen);
privateslots:
voidon_rbt_tot_clicked();
voidon_rbt_chinese_clicked();
voidon_rbt_math_clicked();
voidon_rbt_english_clicked();
voidon_rbt_return_clicked();
voidon_lowstu_clicked();
private:
Ui::stuall*ui;
QStandardItemModel*model;
QList<QString>stu_all;
QList<QString>stu_allstu;
addstua;
QueryStub;
};
#endif//STUALL_H
stuall.cpp中
#include"stuall.h"
#include"ui_stuall.h"
#include<QMessageBox>
#include<QAbstractButton>
#include<QPushButton>
#include<QString>
#include<QLabel>
#include<QButtonGroup>
#include<QFile>
#include<QTextStream>
#include<QIODevice>//这三个是文件处理的头文件；
#include"querystu.h"
#include<QStringList>
QStringyexunwei;
stuall::stuall(QWidget*parent):
QDialog(parent),
ui(newUi::stuall)
{
ui->setupUi(this);
this->model=newQStandardItemModel;
this->model->setHorizontalHeaderItem(0,newQStandardItem(QObject::tr("姓名")));
this->model->setHorizontalHeaderItem(1,newQStandardItem(QObject::tr("学号")));
this->model->setHorizontalHeaderItem(2,newQStandardItem(QObject::tr("性别")));
this->model->setHorizontalHeaderItem(3,newQStandardItem(QObject::tr("院系")));
this->model->setHorizontalHeaderItem(4,newQStandardItem(QObject::tr("语文")));
this->model->setHorizontalHeaderItem(5,newQStandardItem(QObject::tr("数学")));
this->model->setHorizontalHeaderItem(6,newQStandardItem(QObject::tr("英语")));
this->model->setHorizontalHeaderItem(7,newQStandardItem(QObject::tr("总分")));
this->ui->tableView->setModel(model);
}
stuall::~stuall()
{
deleteui;
}
voidstuall::on_rbt_tot_clicked()
{
stuallpaixu(7);
}
voidstuall::stuallpaixu(intbaoyuchen)
{
intdigit=0;
QFilefile("stu.txt");
if(!file.open(QIODevice::ReadOnly|QIODevice::Text))
{
return;
}
QTextStream in(&file);
while(!in.atEnd())
{
QStringline1=in.readLine();
stu_all.append(line1);
digit++;
}
file.close();
inti=0;
introw=0;
for(i=0;i<digit;i++)
{
QStringline=stu_all.at(i);
QStringListsubs=line.split("");
intj=0;
for(j=0;j<subs.length();j++)
{
this->model->setItem(row,j,newQStandardItem(subs.at(j)));
}
row++;
}
this->ui->tableView->sortByColumn(baoyuchen,Qt::DescendingOrder);
}
voidstuall::on_rbt_chinese_clicked()
{
stuallpaixu(4);
}
voidstuall::on_rbt_math_clicked()
{
stuallpaixu(5);
}
voidstuall::on_rbt_english_clicked()
{
stuallpaixu(6);
}
voidstuall::on_rbt_return_clicked()
{
this->close();
}
voidstuall::on_lowstu_clicked()
{
intdigit=0;
QFilefile("stu.txt");
if(!file.open(QIODevice::ReadOnly|QIODevice::Text))
{
return;
}
QTextStream in(&file);
while(!in.atEnd())
{
QStringline1=in.readLine();
//yexunwei=line1
QStringListsubs=line1.split("");
if(subs.at(4).toDouble()<60||subs.at(5).toDouble()<60||subs.at(6).toDouble()<60)
{
stu_allstu.append(line1);
digit++;
}
}
file.close();
inti=0;
introw=0;
for(i=0;i<digit;i++)
{
QStringline=stu_allstu.at(i);
QStringListsubs1=line.split("");
intj=0;
for(j=0;j<subs1.length();j++)
{
this->model->setItem(row,j,newQStandardItem(subs1.at(j)));
}
row++;
}
this->ui->tableView->sortByColumn(7,Qt::DescendingOrder);
}
main.cpp中
#include"addstu.h"
#include<QApplication>
#include"baomain.h"
intmain(intargc,char*argv[])
{
QApplicationa(argc,argv);
//addstuw;
//w.show();
baomainw;
w.show();
returna.exec();
}
QT中 QString类与字符串之间的相互转化
QStringstr="1234";
floatd=str.toFloat();
doubled=str.toDouble();
intd=str.toInt();
floata=12.34;
数字转化为字符串：
QStringstr=QString::number(a);
#include<QTextStream>
while(!in.atEnd())//判断是否读取完文件。
{
QStringline=in.readLine();
stu_lines.append(line);
}
file.close();

猜你喜欢

转载自blog.csdn.net/qq_41221411/article/details/87374402
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
[编程题]学英语
[codeforces 1288A] Deadline 约数+模
Python的web开发
Docker在Centos 7上的部署
python编码
解决Ubuntu16.04 fatal error: json/json.h: No such file or directory
mysql并发插入
rest接口如何适应jsonp的方案
linux 终端上网设置
高数——等号两边同时求导、积分的解释
每日归档
更多
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022