表达式求值c语言acm（表达式求值c语言代码加减）

本篇文章给大家谈谈表达式求值c语言acm，以及表达式求值c语言代码加减对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、c语言 后面两个表达式求值及具体过程2、求一个C语言算术表达式求值程序3、C语言代码补全：前缀表达式求值4、数据结构c语言版表达式求值标准程序5、c语言后缀表达式求值详细程序，可运行的6、C语言编一个实现简单的算术表达式求值的代码。

c语言 后面两个表达式求值及具体过程

程序运行时 首先在内存（RAM）中为 各个变量申请内存 通过变量名 对变量进行查询 ；可以简单的理解为内存中 存在了 四个变量 a,b,c,d 并且进行了初始化工作（初始化：定义变量并且赋初值） 因为都是整形变量（int）所以每个变量都站两个字节 ，程序开始运行 ==》 ++a 表示 变量 a 首先进行自增运算（每次加1）然后在参加到其他运算中来 ，那么a– 则表示 变量a首先进行运算然后在进行自减操作（每次减1） 这段程序运行后 a = 2 ;b=2;c=2;d=4. 结果为3 。 很久没用 VC或者TC了 建议自己编程运行下

求一个C语言算术表达式求值程序

我的能运行!!但表达式末尾加要加#

例如2+3要打2+3#

#includecstdio

#includemalloc.h

#define NULL 0

typedef struct node{

char date;

struct node *next;

}SNode;

SNode *InitStack(){

SNode *top;

top=(SNode *)malloc(sizeof(SNode));

top-next=NULL;

return top;

}

void PushOptr(SNode *top,char x){

SNode *p;

p=(SNode *)malloc(sizeof(SNode));

p-date=x;

p-next=top-next;

top-next=p;

}

char PopOptr(SNode *top){

SNode *p;

char x;

if(top==NULL)

return NULL;

p=top-next;

x=p-date;

top-next=p-next;

free(p);

return x;

}

void PushOpnd(SNode *top,char x){

SNode *p;

p=(SNode *)malloc(sizeof(SNode));

p-date=x;

p-next=top-next;

top-next=p;

}

char PopOpnd(SNode *top){

SNode *p;

char x;

if(top==NULL)

return NULL;

p=top-next;

x=p-date;

top-next=p-next;

free(p);

return x;

}

char GetTop(SNode *top){

return (top-next)-date;

}

int In(char c){

int n;

switch(c){

case ‘+’:

case ‘-‘:

case ‘*’:

case ‘/’:

case ‘(‘:

case ‘)’:

case ‘#’:n=1;break;

default:n=0;break;

}

return n;

}

char Precede(char x,char y){

int i,j;

int form[7][7]={{1,1,-1,-1,-1,1,1},{1,1,-1,-1,-1,1,1},{1,1,1,1,-1,1,1},{1,1,1,1,-1,1,1},{-1,-1,-1,-1,-1,0,2},{1,1,1,1,2,1,1},{-1,-1,-1,-1,-1,2,0}};

switch(x){

case ‘+’:i=0;break;

case ‘-‘:i=1;break;

case ‘*’:i=2;break;

case ‘/’:i=3;break;

case ‘(‘:i=4;break;

case ‘)’:i=5;break;

case ‘#’:i=6;break;

}

switch(y){

case ‘+’:j=0;break;

case ‘-‘:j=1;break;

case ‘*’:j=2;break;

case ‘/’:j=3;break;

case ‘(‘:j=4;break;

case ‘)’:j=5;break;

case ‘#’:j=6;break;

}

if(form[i][j]==1)

return ”;

else

if(form[i][j]==-1)

return ”;

else

return ‘=’;

}

int Operate(char x,char z,char y){

int a=x-‘0’,b=y-‘0’;

switch(z){

case ‘+’:return a+b;

case ‘-‘:return a-b;

case ‘*’:return a*b;

case ‘/’:return a/b;

}

}

char Eval_Exp(){

char a,b,c,r,f,z;

int result;

SNode *top[2];

top[0]=InitStack();

PushOptr(top[0],’#’);

top[1]=InitStack();

c=getchar();

while(c!=’#’||(GetTop(top[0]))!=’#’){

if(!In(c)){

PushOpnd(top[1],c);

c=getchar();

}

else{

r=Precede(GetTop(top[0]),c);

switch(r){

case ”:PushOptr(top[0],c);

c=getchar();

break;

case ‘=’:PopOptr(top[0]);

c=getchar();

break;

case ”:b=PopOptr(top[0]);

a=PopOpnd(top[1]);

z=PopOpnd(top[1]);

result=Operate(z,b,a);

f=result+’0′;

PushOpnd(top[1],f);

break;

}

}

}

return f;

}

void main(){

char result;

result=Eval_Exp();

printf(“%d\n”,result-‘0’);

}

C语言代码补全：前缀表达式求值

#includestdio.h

#includestdlib.h

#define MAXNUM 100

typedef struct Node //定义存储中缀表达式的结点类型

{int data;

int data1;

char data2;

struct Node *next;

}Lnode;

typedef struct Node2 //定义存储前缀表达式的结点类型

{int data;

int data1;

char data2;

struct Node2 *next;

struct Node2 *prior;

}Lnode2;

typedef int selemtype1; //定义运算数栈的结点

typedef struct //定义运算数栈的类型

{selemtype1 *base;

selemtype1 *top;

}sqstack1;

void InitStack1(sqstack1 s) //新建一个空运算数栈

{s.base=(selemtype1 *)malloc(MAXNUM*sizeof(selemtype1));

s.top=s.base;

if(!s.base) printf(“出错：申请空间失败！\n”);

}

void Push1(sqstack1 s,selemtype1 e) //运算数栈，入栈：插入元素e为新的栈顶元素

{ if(s.top-s.base=MAXNUM)

printf(“出错：表达式过长！1\n”);

*s.top++ =e;

}

void GetTop1(sqstack1 s,selemtype1 e) //运算数栈，用e返回栈顶元素 {e=*(s.top-1);

}

void Popopnd1(sqstack1 s,selemtype1 e) //运算数栈，退栈：删除栈顶元素，并用e返回其值

{e=*–s.top;

}

int stackempy1(sqstack1 s) //运算数栈，若为空栈返回1，否则返回0 {if(s.top==s.base) return 1;

else return 0;

}

typedef char selemtype2; //定义运算符栈的结点类型

typedef struct //定义运算符栈类型

{selemtype2 *base;

selemtype2 *top;

}sqstack2;

void InitStack2(sqstack2 s) //新建一个空运算符栈

{s.base=(selemtype2 *)malloc(MAXNUM*sizeof(selemtype2));

s.top=s.base;

if(!s.base) printf(“出错：申请空间失败！\n”);

}

void Push2(sqstack2 s,selemtype2 e) //运算符栈，入栈：插入元素e为新的栈顶元素

{ if(s.top-s.base=MAXNUM)

printf(“出错：表达式过长！2\n”);

*s.top++ =e;

}

void GetTop2(sqstack2 s,selemtype2 e) //运算符栈，用e返回栈顶元素 {e=*(s.top-1);

}

void Popopnd2(sqstack2 s,selemtype2 e) //运算符栈，退栈：删除栈顶元素，并用e返回其值

{e=*–s.top;

}

int stackempy2(sqstack2 s) //运算符栈，若为空栈返回1，否则返回0 {if(s.top==s.base) return 1;

else return 0;

}

数据结构c语言版表达式求值标准程序

思路：中缀表达式－后缀表达式－求值

参考代码：

#include iostream

#include cstdio

#include vector

#include cstdlib

#include cstring

#include iterator

#include algorithm

// 堆栈的数组实现，数组的大小固定。

templateclass T

class stack

{

private:

T *s; // 数组的首地址（栈底）

size_t N; // 指向栈顶第一个空闲块

const size_t size; // 堆栈的大小，固定不变

public:

stack(size_t n) : size(n)

{

s = new T[n]; // 可能抛出异常

N = 0; // 设置栈顶指针

}

~stack()

{

delete [] s;

}

bool empty() const

{

return N == 0;

}

bool full() const

{

return N == size;

}

void push(const T object)

{

if (full())

{

throw “error: stack is full !”;

}

s[N++] = object;

}

T pop()

{

if (empty())

{

throw “error: stack is empty !”;

}

return s[–N];

}

T peek() const

{

if (empty())

{

throw “error: stack is empty !”;

}

return s[N-1];

}

friend std::ostream operator(std::ostream os, const stackT stk)

{

for (size_t i = 0; i stk.N; i++)

{

std::cout stk.s[i] ” “;

}

return os;

}

};

// 堆栈的链表实现

templateclass T

class STACK

{

private:

typedef struct node

{

T item;

node *next;

node(T x, node *t = NULL) : item(x), next(t) {}

}*link;

link head; // 指向栈顶第一个有效对象

public:

STACK(size_t n)

{

head = NULL;

}

~STACK() // 也可以用pop的方法删除，但效率低

{

link t = head;

while (t != NULL)

{

link d = t;

t = t-next;

delete d;

}

}

bool empty() const

{

return head == NULL;

}

bool full() const

{

return false;

}

void push(const T object)

{

head = new node(object, head);

}

T pop()

{

if (empty())

{

throw “error: stack is empty !”;

}

T v = head-item;

link t = head-next;

delete head;

head = t;

return v;

}

T peek() const

{

if (empty())

{

throw “error: stack is empty !”;

}

return head-item;

}

friend std::ostream operator(std::ostream os, const STACKT stk)

{

for (link t = stk.head; t != NULL; t = t-next)

{

std::cout t-item ” “;

}

return os;

}

};

// 中缀表达式转化为后缀表达式，仅支持加减乘除运算、操作数为1位十进制非负整数的表达式。

char* infix2postfix(const char *infix, char *postfix)

{

const size_t N = strlen(infix);

if (N == 0 || postfix == NULL)

{

return postfix;

}

stackchar opcode(N); // 堆栈存放的是操作符

for (size_t i = 0; i N; i++)

{

switch (infix[i])

{

case ‘(‘: // 直接忽略左括号

break;

case ‘)’: // 弹出操作符

*postfix++ = opcode.pop();

*postfix++ = ‘ ‘;

break;

case ‘+’:

case ‘-‘:

case ‘*’:

case ‘/’:

opcode.push(infix[i]); // 压入操作符

break;

default:

if (isdigit(infix[i])) // 如果是数字，直接输出

{

*postfix++ = infix[i];

*postfix++ = ‘ ‘;

}

}

}

return postfix;

}

// 后缀表达式转化为中缀表达式，仅支持加减乘除运算、操作数为1位十进制非负整数的表达式。

char* postfix2infix(const char *postfix, char *infix)

{

const size_t N = strlen(postfix);

if (N == 0 || infix == NULL)

{

return infix;

}

*infix = ‘\0’; // 初始化输出字符串为空串

std::vectorstd::string v;

// 初始化，将所有有效字符放入容器

for (size_t i = 0; i N; i++)

{

if (isdigit(postfix[i]) || postfix[i] == ‘+’

|| postfix[i] == ‘-‘ || postfix[i] == ‘*’ || postfix[i] == ‘/’)

{

v.push_back(std::string(1, postfix[i]));

}

}

// 处理每一个操作符

for (std::vectorstd::string::iterator b = v.begin(); b v.end(); b++)

{

if (*b == “+” || *b == “-” || *b == “*” || *b == “/”)

{

copy(v.begin(), v.end(), std::ostream_iteratorstd::string(std::cout, “\n”));

std::cout “————————————————” std::endl;

std::string opcode = *(b);

std::string oprand1 = *(b – 2);

std::string oprand2 = *(b – 1);

b = v.erase(b – 2, b + 1); // 删除原来的三个表达式，用一个新的表达式替换

b = v.insert(b, std::string(“(“) + oprand1 + opcode + oprand2 + std::string(“)”));

}

}

for (std::vectorstd::string::iterator b = v.begin(); b v.end(); b++)

{

strcat(infix, (*b).c_str());

}

return infix;

}

// 计算后缀表达式的值，仅支持加减乘除运算、操作数为非负整数的表达式。

int postfix_eval(const char * postfix)

{

const size_t N = strlen(postfix);

if (N == 0)

{

return 0;

}

STACKint operand(N); // 堆栈存放的是操作数

for (size_t i = 0 ; i N; i++)

{

switch (postfix[i])

{

int op1, op2;

case ‘+’:

op1 = operand.pop();

op2 = operand.pop();

operand.push(op1 + op2);

break;

case ‘-‘:

op1 = operand.pop();

op2 = operand.pop();

operand.push(op1 – op2);

break;

case ‘*’:

op1 = operand.pop();

op2 = operand.pop();

operand.push(op1 * op2);

break;

case ‘/’:

op1 = operand.pop();

op2 = operand.pop();

operand.push(op1 / op2);

break;

default:

if (isdigit(postfix[i])) // 执行类似atoi()的功能

{

operand.push(0);

while (isdigit(postfix[i]))

{

operand.push(10 * operand.pop() + postfix[i++] – ‘0’);

}

i–;

}

}

std::cout operand std::endl; // 输出堆栈的内容

}

return operand.pop();

}

// 本程序演示了如何后缀表达式和中缀表达式的相互转换，并利用堆栈计算后缀表达式。

// 转换方向：org_infix — postfix — infix

int main(int argc, const char *argv[])

{

// const char *org_infix = “(5*(((9+8)*(4*6))+7))”; // section 4.3

const char *org_infix = “(5*((9*8)+(7*(4+6))))”; // exercise 4.12

std::cout “原始中缀表达式：” org_infix std::endl;

char *const postfix = new char[strlen(org_infix) + 1];

infix2postfix(org_infix, postfix);

std::cout “后缀表达式：” postfix std::endl;

char *const infix = new char[strlen(postfix) + 1];

postfix2infix(postfix, infix);

std::cout “中缀表达式：” infix std::endl;

std::cout “计算结果是：” postfix_eval(postfix) std::endl;

std::cout “计算结果是：” postfix_eval(“5 9*8 7 4 6+*2 1 3 * + * + *”) std::endl; // exercise 4.13

delete []infix;

delete []postfix;

return 0;

}

c语言后缀表达式求值详细程序，可运行的

#include iostream

#include string.h

using namespace std;

template class T

class Stack

{

private:

T *s;

int maxlength;

int top;

public:

Stack(int max)

{

maxlength=max;

s=new T[max];

top=-1;

}

bool isFull()

{

return top==maxlength-1;

}

bool isEmpty()

{

return top==-1;

}

T getTopElement()

{

return s[top];

}

void push(T x)

{

if(isFull())

return;

s[++top]=x;

}

T pop()

{

if(isEmpty())

return ‘!’;

T tmp=s[top];

top–;

return tmp;

}

void clear()

{

top=-1;

}

void  traverse()

{

for (int i=0;i=top;i++)

{

couts[i]” “;

}

coutendl;

}

};

class Calculator

{

private:

char *f;

int maxlength;

Stackdouble *s;

Stackchar *t;

int getP(char t)

{

switch(t)

{

case ‘+’:

return 0;

break;

case ‘-‘:

return 0;

break;

case ‘*’:

return 1;

break;

case ‘/’:

return 1;

break;

}

return -1;

}

double getResult(char *f)

{

s-clear();

int l=strlen(f);

for(int i=0;il;i++)

{

if(f[i]=’0’f[i]=’9′)

s-push(f[i]-‘0’);

else

{

double x2=s-pop();

double x1=s-pop();

switch(f[i])

{

case ‘+’:

s-push(x1+x2);

break;

case ‘-‘:

s-push(x1-x2);

break;

case ‘*’:

s-push(x1*x2);

break;

case ‘/’:

s-push(x1/x2);

break;

}

}

//s-traverse();

}

double res=s-pop();

return res;

}

public:

Calculator(int max)

{

maxlength=max;

s=new Stackdouble(max);

t=new Stackchar(max);

}

double run(char *input)

{

char *opt=new char[maxlength];

char *inp=new char[strlen(input)+2];

int cnt=0,l=strlen(input)+2;

for(int i=0;il-2;i++)

inp[i]=input[i];

inp[l-2]=’#’;

inp[l-1]=0;

coutinpendl;

t-push(‘#’);

for(int i=0;il;i++)

{

if(inp[i]=’0’inp[i]=’9′)

opt[cnt++]=inp[i];

else

{

if(t-getTopElement()==’#’ || getP(t-getTopElement())getP(inp[i]) || inp[i]=='(‘)

t-push(inp[i]);

else if(inp[i]==’#’)

{

while(!t-isEmpty()t-getTopElement()!=’#’)

opt[cnt++]=t-pop();

}

else if(inp[i]==’)’)

{

while(!t-isEmpty()t-getTopElement()!='(‘)

opt[cnt++]=t-pop();

t-pop();

}

else if(getP(t-getTopElement())=getP(inp[i]))

{

while(!t-isEmpty()

getP(t-getTopElement())=getP(inp[i])

t-getTopElement()!='(‘)

opt[cnt++]=t-pop();

t-push(inp[i]);

}

}

cout”stack:T:\t”;

t-traverse();

}

opt[cnt]=0;

coutoptendl;

return getResult(opt);

}

};

int main()

{

Calculator c(30);

int a[2005];

freopen(“rpncalc.in”,”r”,stdin);

freopen(“rpncalc.out”,”w”,stdout);

cina;

coutc.run(“a”)endl;

}

C语言编一个实现简单的算术表达式求值的代码。

这个是个简单的学生管理系统,我们学校的程序大作业就是做这个…呵呵,希望能帮到你

#includestdio.h /*引用库函数*/

#includestdlib.h

#includectype.h

#includestring.h

typedef struct /*定义结构体数组*/

{

char num[10]; /*学号*/

char name[20]; /*姓名*/

int score; /*成绩*/

}Student;

Student stu[80]; /*结构体数组变量*/

int menu_select() /*菜单函数*/

{

char c;

do{

system(“cls”); /*运行前清屏*/

printf(“\t\t****Students’ Grade Management System****\n”); /*菜单选择*/

printf(“\t\t | 1. Input Records |\n”);

printf(“\t\t | 2. Display All Records |\n”);

printf(“\t\t | 3. Sort |\n”);

printf(“\t\t | 4. Insert a Record |\n”);

printf(“\t\t | 5. Delete a Record |\n”);

printf(“\t\t | 6. Query |\n”);

printf(“\t\t | 7. Statistic |\n”);

printf(“\t\t | 8. Add Records from a Text File|\n”);

printf(“\t\t | 9. Write to a Text file |\n”);

printf(“\t\t | 0. Quit |\n”);

printf(“\t\t*****************************************\n”);

printf(“\t\t\tGive your Choice(0-9):”);

c=getchar(); /*读入选择*/

}while(c’0’||c’9′);

return(c-‘0’); /*返回选择*/

}

int Input(Student stud[],int n) /*输入若干条记录*/

{int i=0;

char sign,x[10]; /*x[10]为清除多余的数据所用*/

while(sign!=’n’sign!=’N’) /*判断*/

{ printf(“\t\t\tstudent’s num:”); /*交互输入*/

scanf(“\t\t\t%s”,stud[n+i].num);

printf(“\t\t\tstudent’s name:”);

scanf(“\t\t\t%s”,stud[n+i].name);

printf(“\t\t\tstudent’s score:”);

scanf(“\t\t\t%d”,stud[n+i].score);

gets(x); /*清除多余的输入*/

printf(“\t\t\tany more records?(Y/N)”);

scanf(“\t\t\t%c”,sign); /*输入判断*/

i++;

}

return(n+i);

}

void Display(Student stud[],int n) /*显示所有记录*/

{

int i;

printf(“\t\t\t———————————–\n”); /*格式头*/

printf(“\t\t\tnumber name score\n”);

printf(“\t\t\t———————————–\n”);

for(i=1;in+1;i++) /*循环输入*/

{

printf(“\t\t\t%-16s%-15s%d\n”,stud[i-1].num,stud[i-1].name,stud[i-1].score);

if(i1i%10==0) /*每十个暂停*/

{printf(“\t\t\t———————————–\n”); /*格式*/

printf(“\t\t\t”);

system(“pause”);

printf(“\t\t\t———————————–\n”);

}

}

printf(“\t\t\t”);

system(“pause”);

}

void Sort_by_num(Student stud[],int n) /*按学号排序*/

{ int i,j,*p,*q,s;

char t[10];

for(i=0;in-1;i++) /*冒泡法排序*/

for(j=0;jn-1-i;j++)

if(strcmp(stud[j].num,stud[j+1].num)0)

{strcpy(t,stud[j+1].num);

strcpy(stud[j+1].num,stud[j].num);

strcpy(stud[j].num,t);

strcpy(t,stud[j+1].name);

strcpy(stud[j+1].name,stud[j].name);

strcpy(stud[j].name,t);

p=stud[j+1].score;

q=stud[j].score;

s=*p;

*p=*q;

*q=s;

}

}

int Insert_a_record(Student stud[],int n) /*插入一条记录*/

{char x[10]; /*清除多余输入所用*/

printf(“\t\t\tstudent’s num:”); /*交互式输入*/

scanf(“\t\t\t%s”,stud[n].num);

printf(“\t\t\tstudent’s name:”);

scanf(“\t\t\t%s”,stud[n].name);

printf(“\t\t\tstudent’s score:”);

scanf(“\t\t\t%d”,stud[n].score);

gets(x);

n++;

Sort_by_num(stud,n); /*调用排序函数*/

printf(“\t\t\tInsert Successed!\n”); /*返回成功信息*/

return(n);

}

int Delete_a_record(Student stud[],int n) /*按姓名查找，删除一条记录*/

{ char s[20];

int i=0,j;

printf(“\t\t\ttell me his(her) name:”); /*交互式问寻*/

scanf(“%s”,s);

while(strcmp(stud[i].name,s)!=0in) i++; /*查找判断*/

if(i==n)

{ printf(“\t\t\tnot find!\n”); /*返回失败信息*/

return(n);

}

for(j=i;jn-1;j++) /*删除操作*/

{

strcpy(stud[j].num,stud[j+1].num);

strcpy(stud[j].name,stud[j+1].name);

stud[j].score=stud[j+1].score;

}

printf(“\t\t\tDelete Successed!\n”); /*返回成功信息*/

return(n-1);

}

void Query_a_record(Student stud[],int n) /*查找并显示一个记录*/

{ char s[20];

int i=0;

printf(“\t\t\tinput his(her) name:”); /*交互式输入*/

scanf(“\t\t\t%s”,s);

while(strcmp(stud[i].name,s)!=0in) i++; /*查找判断*/

if(i==n)

{ printf(“\t\t\tnot find!\n”); /*输入失败信息*/

return;

}

printf(“\t\t\this(her) number:%s\n”,stud[i].num); /*输出该学生信息*/

printf(“\t\t\this(her) score:%d\n”,stud[i].score);

}

void Statistic(Student stud[],int n) /*新增功能，输出统计信息*/

{ int i,j=0,k=0,sum=0;

float aver; /*成绩平均值*/

for(i=0;in;i++) /*循环输入判断*/

{

sum+=stud[i].score;

if(stud[j].scorestud[i].score) j=i;

if(stud[k].scorestud[i].score) k=i;

}

aver=1.0*sum/n;

printf(“\t\t\tthere are %d records.\n”,n); /*总共记录数*/

printf(“\t\t\tthe hignest score:\n”); /*最高分*/

printf(“\t\t\tnumber:%s name:%s score:%d\n”,stud[j].num,stud[j].name,stud[j].score);

printf(“\t\t\tthe lowest score:\n”); /*最低分*/

printf(“\t\t\tnumber:%s name:%s score:%d\n”,stud[k].num,stud[k].name,stud[k].score);

printf(“\t\t\tthe average score is %5.2f\n”,aver); /*平均分*/

}

int AddfromText(Student stud[],int n) /*从文件中读入数据*/

{ int i=0,num;

FILE *fp; /*定义文件指针*/

char filename[20]; /*定义文件名*/

printf(“\t\t\tInput the filename:”);

scanf(“\t\t\t%s”,filename); /*输入文件名*/

if((fp=fopen(filename,”rb”))==NULL) /*打开文件*/

{ printf(“\t\t\tcann’t open the file\n”); /*打开失败信息*/

printf(“\t\t\t”);

system(“pause”);

return(n);

}

fscanf(fp,”%d”,num); /*读入总记录量*/

while(inum) /*循环读入数据*/

{

fscanf(fp,”%s%s%d”,stud[n+i].num,stud[n+i].name,stud[n+i].score);

i++;

}

n+=num;

fclose(fp); /*关闭文件*/

printf(“\t\t\tSuccessed!\n”);

printf(“\t\t\t”);

system(“pause”);

return(n);

}

void WritetoText(Student stud[],int n) /*将所有记录写入文件*/

{

int i=0;

FILE *fp; /*定义文件指针*/

char filename[20]; /*定义文件名*/

printf(“\t\t\tWrite Records to a Text File\n”); /*输入文件名*/

printf(“\t\t\tInput the filename:”);

scanf(“\t\t\t%s”,filename);

if((fp=fopen(filename,”w”))==NULL) /*打开文件*/

{

printf(“\t\t\tcann’t open the file\n”);

system(“pause”);

return;

}

fprintf(fp,”%d\n”,n); /*循环写入数据*/

while(in)

{

fprintf(fp,”%-16s%-15s%d\n”,stud[i].num,stud[i].name,stud[i].score);

i++;

}

fclose(fp); /*关闭文件*/

printf(“Successed!\n”); /*返回成功信息*/

}

void main() /*主函数*/

{

int n=0;

for(;;)

{

switch(menu_select()) /*选择判断*/

{

case 1:

printf(“\t\t\tInput Records\n”); /*输入若干条记录*/

n=Input(stu,n);

break;

case 2:

printf(“\t\t\tDisplay All Records\n”); /*显示所有记录*/

Display(stu,n);

break;

case 3:

printf(“\t\t\tSort\n”);

Sort_by_num(stu,n); /*按学号排序*/

printf(“\t\t\tSort Suceessed!\n”);

printf(“\t\t\t”);

system(“pause”);

break;

case 4:

printf(“\t\t\tInsert a Record\n”);

n=Insert_a_record(stu,n); /*插入一条记录*/

printf(“\t\t\t”);

system(“pause”);

break;

case 5:

printf(“\t\t\tDelete a Record\n”);

n=Delete_a_record(stu,n); /*按姓名查找，删除一条记录*/

printf(“\t\t\t”);

system(“pause”);

break;

case 6:

printf(“\t\t\tQuery\n”);

Query_a_record(stu,n); /*查找并显示一个记录*/

printf(“\t\t\t”);

system(“pause”);

break;

case 7:

printf(“\t\t\tStatistic\n”);

Statistic(stu,n); /*新增功能，输出统计信息*/

printf(“\t\t\t”);

system(“pause”);

break;

case 8:

printf(“\t\t\tAdd Records from a Text File\n”);

n=AddfromText(stu,n); /*新增功能，输出统计信息*/

break;

case 9:

printf(“\t\t\tWrite to a Text file\n”);

WritetoText(stu,n); /*循环写入数据*/

printf(“\t\t\t”);

system(“pause”);

break;

case 0:

printf(“\t\t\tHave a Good Luck,Bye-bye!\n”); /*结束程序*/

printf(“\t\t\t”);

system(“pause”);

exit(0);

}

}

}

关于表达式求值c语言acm和表达式求值c语言代码加减的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。