中南大学C++课程设计报告-职工工资信息管理系统

中南大学课程设计报告

课程名称：高级程序设计实践（C++）

指导老师： 李刚

专 业：

班 级：

学 号：

姓 名：

2015年6月27日

目录

第一章 总体设计································ 1

1.1 C++课程设计要求及题目······································· 1

1.2 设计分析··················································· ········· 1

第二章 详细设计·································3

2.1 程序的结构··················································· ····· 3

2.2 相关模块·························································· 3

第三章 运行结果及操作方法······················23

第四章 心得体会································28

第一章 总体设计

1.1 C++课程设计要求及题目

职工工资信息管理系统：

设计一个职工信息管理案例，实现不同类别职工的工资数据。职工的种类包括：正式职

工和临时工。定义一个基本的职工类，基本信息包括：编号、姓名、性别、年龄、家庭住址、基本职务工资。派生出正式职工类，增加的属性包括：岗位津贴、养老金、住房公积金、所得税、医疗保险、所得税，实发工资；临时工增加的属性包括：奖金、所得税、实发工资。

1. 正式职工：实发工资=基本职务工资+岗位津贴-养老金-住房公积金-所得税-医疗保险；

2. 临时工：实发工资=基本职务工资+奖金-所得税；

基本功能与技术要求：

1、数据文件管理功能：利用输入输出流创建新文件、打开文件、保存文件。

2、计算与统计功能：采用静态数据成员与成员函数完成记录中相关数据的统计；

1）能够打开已存在的数据表文件，对数据表中与某关键字匹配的相关记录进行数据统计（包括：工资总额、平均值、不同价格区间的图书）

2）计算每个职工的实发工资。

3、记录管理功能：利用继承与派生思想创建不同的类；记录的管理采用链表或者指针数组实现；采用抽象类、虚函数等实现对象与函数的动态关联，体现多态性。

1）输入／添加/插入记录：利用重载运算符“>>”完成对任意一条记录输入、添加或插入数据表中，并保存到数据文件中。

2）查询、显示记录：能够打开已存在的数据表文件，根据用户要求按所给记录关键字查询一个或多个相关联记录的各项信息。利用重载运算符“

3）修改记录：能够打开已存在的数据表文件，并对确定的任意记录进行修改，在修改过程中，应显示记录信息，给出确认提示，并对更新的记录信息进行文件保存。

4）删除记录：能够打开已存在的数据表文件，可以删除数据表中的任一记录，要求具备逻辑删除（具有恢复功能）和物理删除功能，并对新的数据表信息进行文件保存。

1.2 设计分析

根据基本功能与技术要求，程序要实现对职工数据文件管理功能，计算与统计功能，记

录管理功能。因此，程序中需要构造很多实现这些目的的函数来一一完成题目要求。其次，职工又分为，正式职工和非正式职工，而且两者的基本信息有不同的，也有相同的，所以应该根据题目要求定义一个基类，即基本职工类。它的私有数据包括编号，姓名，性别，年龄，家庭住址，基本职务工资，并对它们初始化。然后又派生了两个类，分别代表正式职工和非正式职工。

正式职工：在基类的基础上增加了岗位津贴，养老金，住房公积金，所得税，医疗保险，

所得税和实发工资，并进行初始化。

临时职工：在基类的基础上增加了奖金，所得税，实发工资，并对他们进行初始化。

最后，构造不同的函数来实现不同的功能，比如添加，修改，保存，删除，恢复等一系

列功能，最后完成主函数，最后对程序代码进行优化，完成程序的设计。

第二章 详细设计

2.1 程序的结构

程序的前半部分, 定义了基类basic ，对编号，姓名，性别，年龄，，家庭住址，基本职

务工资这些数据进行了初始化，把它们封装起来，然后利用继承和派生思想，分别对正式职工和非正式职工创建了派生类，把它们独有的数据初始化并保存封装。接下来，又创建了一个类link ，用于链接数据库文件。前半部分主要是类的创建，继承，派生，对职工的属性进行封装，初始化，以便后面调用。

程序的中间部分，主要构造了一系列函数，对前面类中初始化的数据进行操作，首先构

造了正式职工类插入新结点函数，接下来是，正式职工类输入新纪录的函数，非正式职工类插入新结点函数，非正式职工类输入新纪录的函数，输入函数，正式职工工资信息输出函数，非正式职工工资信息输出函数，输出函数，修改函数，删除函数，恢复函数，统计函数。依次完成了职工信息的输入，输出，保存，修改，删除，恢复。

程序的后半部分，是主函数部分，定义了存储正式和非正式职工结点的类指针，定义了

程序运行界面，在循环系统中依此调用了链接函数，输入函数，输出函数，查找函数，删除函数，恢复函数，修改函数，统计函数和文件保存函数。

2.2 相关模块

（一）基类—基本职工类

对编号，姓名，性别，年龄，基本工资，住址初始化，设置默认参数，并将姓名，性别，

年龄，基本工资，住址定义为保护数据。

源程序：

class basic //基本职工类

{

public:

int id; //职工编号

basic *next; //利用basic 创建指向basic 类对象的指针，

basic() //构造函数初始化，设置默认参数

{

this->id = 0; //编号

this->name="未注明"; //姓名 //this指针是指向本类对象的指针

this->sex = "未注明"; //性别

this->age = 0; //年龄

this->s = 0; //基本工资

this->add = "未注明"; //住址

this->next=NULL; //指针变量next 是空的

}

void set() //输入函数

{

cout

cin>>id;

cout

cin>>name;

cout

cin>>sex;

cout

cin>>age;

cout

cin>>s;

cout

cin>>add;

}

void display() //输出函数

{

cout

cout

cout

printf("| %5d| %13s| %5s| %5d| %9d| %17s|\n",id,name.c_str(),sex.c_str(),age,s,add.c_str());

cout

} /*%md,m为指定的输出字段的宽度。如果数据的位数小于m ，则左端补以空格，若大于m ，则按实际位数输出。

当调用库函数，要输入的是string 类型参数，而库函数内部实现用的是C 语言的char ，因此需要将string 对象，

转化为char 对象，而c_str()提供了这样一种方法。*/

virtual void infromfile(ifstream &); //从文件读取(in from file),virtual 虚函数的作用是实现多态性(例子定义了四个类A 、B 、C 、D ，其中B 、C 继承了A ，而D 继承了

B 、C 。然后我们用A 类，定义了四个指针分别指向不同的对象，这时指针根据不同的类对象正确输出，这就是所说的多态性。)

virtual void writetofile(ofstream &); //写入到文件, 参数是ostream 类的地址，用来支持写入到磁盘里

protected:

string name;

string sex;

int age;

int s;//salary

string add;

};

（二）派生类—正式职工类

首先，定义了链表后驱指针，然后，对私有数据：岗位津贴，养老金，住房公积金，所得税，医疗保险，所得税，实发工资初始化，设置默认参数，并保存。

源程序：

class formal:public basic

{

public:

char type; //类型(type):正式，临时等；见派生类—正式职工类

formal *next; //定义链表的后驱指针

formal() //初始化

{

this->type = 'f'; //f表示formal(正式)

this->jintie = 0;

this->yanglao = 0;

this->zhufang= 0;

this->shui1 = 0;

this->yiliao = 0;

this->shui2= 0;

this->shifaoff= 0;

this->next = NULL;

}

void set_f() //输入数据

{

type = 'f';

cout

cin>>jintie;

cout

cin>>yanglao;

cout

cin>>zhufang;

cout

cin>>shui1;

cout

cin>>yiliao;

cout

cin>>shui2;

shifaoff=s+jintie+yanglao+zhufang+yiliao-shui1-shui2;

cout

}

void dispay_f()

{

cout

cout

cout

printf("| %9d| %9d| %11d| %7d| %9d| %8d| %9d|\n",jintie,yanglao,zhufang,shui1,yiliao,shui2,shifaoff);

cout

}

void infromfile(ifstream&); //从文件读取，同上

void writetofile(ofstream&); //写入到文件

int shifaoff; //把实发工资设为公用数据

private:

int jintie; //岗位津贴

int yanglao ; //养老保险

int zhufang; //住房公积金

int shui1; //所得税

int yiliao; //医疗保险

int shui2; //所得税

};

（三）派生类—临时职工类

首先定义非正式职工信息链表后驱指针，对其私有数据：奖金，所得税，实发工资，初始化，设置默认参数，并保存。

源程序：

class informal : public basic

{

public:

char type;

informal *next; //定义临时职工信息链表的后驱指针

informal()

{

this->type = 'i';//见派生类—正式职工类

this->jiang= 0;

this->shui3=0;

this->shifaofi=0;

this->next = NULL;

}

void set_i()

{

type = 'i';

cout

cin>>jiang;

cout

cin>>shui3;

shifaofi=s+jiang-shui3;

cout

cout

cout

}

void display_i()

{

cout

--------"

cout

cout

--------"

printf("| %14d| %14d| %16d|\n",jiang,shui3,shifaofi);

}

void infromfile(ifstream &); //从文件读取, 同上上

void writetofile(ofstream &); //写入到文件

int shifaofi;//同上

private:

int jiang;//奖金

int shui3;//所得税

};

（四）构造链接函数

用于链接数据库文件

源程序：

class link //link类，用于链接数据库文件

{

public:

string printmenu(void); //menu=菜单

private:

string newdata(void); //newdata+新数据

string opendata(void); //公开数据

};

（五） 构造输入函数

选择要输入的职工类别，依此输入编号，姓名，性别，年龄，住址，基本工资，输入y 继续输入该职工类职工信息，输入其他字符，结束当前职工类信息的输入。

源程序：

//构造输入函数

formal *insert_f(formal *head,formal *pn) //正式职工类插入(insert)新结点函数，就是可以输入新数据，参数是指向类对象的指针变量

{ //每个结点中的指针域指向下一个结点,head 是“头指针”，指向第一个结点，表示链表的开始, 而最后一个指针的指针域为NULL(空地址) ，表示链表的结束。

formal *pc,*pa;

pc=pa=head;

if(head==0) //如果没有第一个结点

{

head=pn; //最后一个指针变量跟head 没区别

pn->next=0; //所以，最后一个指针变量指向的下一个指针(结点) 不存在 return head;

}

if(pn->id id) //，pn 是最后一个指针变量，如果新结点编号小于最小的编号(注意:这里head 不停地更新到小的编号)

{

pn->next=head; //那么新的指针变量变为头指针，用于下次的比较，表明head 指针不断地被赋给编号小的结点，

head=pn;

return head;

}

while(pc->next!=0&&pn->id>=pc->id) // 找到编号最大的结点的指针变量pa {

pa=pc;

pc=pc->next;

}

if(pn->id >= pc->id)//pn成为编号小的结点的指针变量

{

pc->next=pn;

pn->next=0;

}

else

{

pn->next=pc;

pa->next=pn;

}

return head;

}

formal *input_f(formal *head) //正式职工类输入新记录的函数参数和返回值相通，参数为指向类对象的指针变量

{

formal *fo,*p;//定义指向类对象的指针变量

char k;

do

{

system("cls");//执行控制台命令cls ，就是CMD 下面的cls ，功能是清屏，清除敲入回车键前所有显示的信息

fo= new formal();//把新的构造函数赋给指针变量

cout

fo->set(); //调用fo 指向的set 函数，fo 指向的是正式职工类的输入函数 fo->set_f(); //本行+钱一行为获取新信息，set()在20几行 p=insert_f(head,fo); //调用插入结点函数把刚输入的信息插入到链表中 n1++; //正式职工结点数

cout

cin>>k;//输入char 类型字符，是y 或者n

}

while(k=='y' || k=='Y');//输入Y 继续插入数据，输入其他任意键返回 return p;

}

informal *insert_i(informal *head,informal *pn) //临时职工类插入新结点函数 {

informal *pc,*pa;

pc=pa=head;

if(head==0)

{

head=pn;

pn->next=0;

return head;

}

if(pn->id id)

{

pn->next=head;

head=pn;

return head;

}

while(pc->next!=0&&pn->id>=pc->id)

{

pa=pc;

pc=pc->next;

}

if(pn->id >= pc->id)

{

pc->next=pn;

pn->next=0;

}

else

{

pn->next=pc;

pa->next=pn;

}

return head;

}

informal *input_i(informal *head) //临时职工类输入新记录的函数

{

informal *inf,*p;

char k;

do

{

system("cls");

inf= new informal();

cout

inf->set();

inf->set_i(); //获取新信息

p=insert_i(head,inf); //调用插入结点函数

n2++; //临时职工结点数

cout

cin>>k;

}

while(k=='y' || k=='Y'); //输入Y 继续插入数据，输入其他任意键返回 return p;

}

int input(formal *head_f,informal *head_i) //输入函数，两个参数

{

int k=0;

for(;;)

{

system("cls");

cout

cin>>k;

switch(k)

{

case 1 : head_f = input_f(head_f); break;//调用输入新记录的函数，并把返回值赋给指针变量head_f

case 2 : head_i = input_i(head_i);break;

default:return 1;

}

}

}

（六）构造输出函数

用于把输入的职工信息显示在电脑屏幕上，以便核对，纠正，数据统计。

源程序：

void output_f(formal *head) //正式职工工资信息输出函数

{

formal *p;

p = head->next; //把编号最小的结点的指针变量赋给下一个结点的指针变量，上面已把head 调成指向编号最小的结点的函数

while(p != NULL)//当下一个指针存在

{

p->display(); //输出基本(姓名等) 信息

p->dispay_f();//输出工资信息

p = p->next; //循环

}

}

void output_i(informal *head) //非正式职工工资信息输出函数

{

informal *p;

p = head->next;

while(p != NULL)

{

p->display();

p->display_i();

p = p->next;

}

}

int output(formal *head_f,informal *head_i) //输出函数，两个参数

{

system("cls");

if(head_f->next==NULL)

cout

else{

cout

output_f(head_f);}//调用上面的函数，说明在主函数中只有调用本函数即可，本函数再调用上面的输出函数

if(head_i->next==NULL)

cout

else{

cout

output_i(head_i);}

system("pause"); //ystem("pause")就是从程序里调用“pause ”命令； // 而“pause ”这个系统命令的功能很简单，就是在命令行上输出一行类似于“Press any key to exit”的字，等待用户按一个键，然后返回。

return 1;

}

（七）修改函数（对输入的信息修改）

选择要修改的职工类别（1，正式职工 2，非正式职工 3，返回），输入要修改的职工编号，然后重新输入此职工的信息。

源程序：

formal *edit_f(formal *head) //修改正式职工信息

{

formal *p;

int num;

if(head==0)

{

cout

system("pause");//功能同上

return 0;

}

cout

cin>>num;

p=head;

while(num!=p->id)

{

if(p->next==0) break;

p=p->next;

}

if(p->id==num)

{

cout

p->set(); //调用p 指向的结点的输入函数 //基本信息

p->set_f(); //工资信息

system("pause");//功能同上

}

else

{

cout

system("pause");

return head;

}

return head;

}

informal *edit_i(informal *head) //修改非正式职工信息

{

informal *p;

int num;

if(head==0)

{

cout

system("pause");

return 0;

}

cout

cin>>num;

p=head;

while(num!=p->id)

{

if(p->next==0) break;

p=p->next;

}

if(p->id==num)

{

cout

p->set();

p->set_i();

system("pause");

}

else

{

cout

system("pause");

return head;

}

return head;

}

int edit(formal *head_f,informal *head_i) //修改函数，两个参数，调用上面两个函数

{

int k=0;

system("cls");//清屏

for(;;)

{

cout

cin>>k;

switch(k)

{

case 1 : head_f = edit_f(head_f); break; //功能同上

case 2 : head_i = edit_i(head_i);break;

default:return 1;

}

}

}

（8）查找函数（从输入的信息中查找需要的信息）

选择要查找的职工类别，（1，正式职工 2，非正式职工 3，返回），然后输入要查找的职工编号，此职工的信息将被查找出来。

源程序：

int find(formal *head_f,informal *head_i)//查找函数（按照编号查找），两个参数 {

formal *ps;informal *pt;//指向类对象的指针变量

int fid;

system("cls");

ps = new formal();pt = new informal(); //ps，pt 指向所有的新增构造函数 ps = head_f; pt = head_i; //ps指向头指针，不是直接查找，而是一个个地找 cout

cin>>fid;//输入要查找的编号

if(ps==NULL){}

else

{

while(ps->id!=fid)//当id 数存在且不是第一个就执行while 语句，说明有两个以上时执行。

{

if(ps->next == NULL) break; //如果ps 指向的id 是最后一个id ，break 跳出while

ps = ps->next;//如果if 不成立 不停地向下找，直到ps-》=fid }

}

if(pt == NULL){}

else

{

while(pt->id!=fid)

{

if(pt->next == NULL) break;

pt = pt->next;

}

}

if(ps->id == fid)

{

ps->display();

ps->dispay_f();

}

else if(pt->id == fid)

{

pt->display();

pt->display_i();

}

else

{

cout

}

system("pause");

return 1;

}

（9）删除函数（删除不需要的信息）

选择要删除的职工类别（1，正式职工 2，非正式职工 3，返回），输入要删除的职工编号。此职工信息将被删除。

源程序：

formal *revertf;

formal *del_f(formal *head_f,int num) //删除正式职工信息

{

formal *p1,*p2,*p3;

if(head_f==0)

{

cout

goto end;

}

p1=head_f;

while(num!=p1->id)

{

if(p1->next==0)break;

p2=p1;

p1=p1->next;

}

if(num==p1->id)

{

p3=p1;

if(p1==head_f) head_f=p1->next;

else p2->next=p1->next;

n1--;

coutid

}

else{

cout

}

end:

return(head_f);

}

informal *reverti;

informal *del_i(informal *head_i,int num) //删除非正式职工信息

{

informal *p1,*p2,*p3;

if(head_i==0)

{

cout

goto end;

}

p1=head_i;

while(num!=p1->id)

{

if(p1->next==0)break;

p2=p1;

p1=p1->next;

}

if(num==p1->id)

{

p3=p1;

if(p1==head_i) head_i=p1->next;

else p2->next=p1->next;

n2--;

coutid

reverti=insert_i(reverti,p3);

}

else{

cout

}

end:

return(head_i);

}

int del(formal *head_f,informal *head_i)//删除函数, 两个参数

{

int did;

system("cls");

cout

cin>>did;

del_f(head_f,did); //在正式职工类链表中删一遍

del_i(head_i,did); //同样在非正式职工类链表中再删一遍

system("pause");

return 1;

}

（10）恢复函数（恢复误删的信息）

选择要恢复的职工信息类别，输入职工编号。

源程序：

formal *rev_f(formal *head) //正式职工类恢复函数

{

formal *p;

int num=0;

if(revertf==0) goto end;

cout

cin>>num;

p=revertf;

while(p!=0)

{

if(p->id==num) break;

p=p->next;

}

n1++;

head=insert_f(head,p);

end:return(head);

}

informal *rev_i(informal *head) //非正式职工类恢复函数

{

informal *p;

int num=0;

if(reverti==0) goto end;

cout

cin>>num;

p=reverti;

while(p!=0){

if(p->id==num) break;

p=p->next;

}

n2++;

head=insert_i(head,p);

end:return(head);

}

int rev(formal *head_f,informal *head_i)///////////////////////恢复函数, 两个

参数

{

int t;

system("cls");

cout

cin>>t;

if(t==1)

{

rev_f(head_f); //在正式职工类链表中恢复

cout

}

if(t==2)

{

rev_i(head_i); //在非正式职工类链表中恢复

cout

}

system("pause");

return 1;

}

（11）统计函数（对输入德信息统计，计算平均值，总和）

对输入的职工信息进行统计分析，求出平均值，总和。

源程序：

formal *tong_f(formal *head_f)//正式职工类统计函数

int zong=0,ave=0;

formal *p;

p=head_f->next;

while(p!=0)

{

zong+=p->shifaoff;

p=p->next;

}

ave=zong/n1;

cout

cout

coutreturn head_f;

}

informal *tong_i(informal *head_i)//非正式职工类统计函数

{

int zong2=0,ave2=0;

informal *p;

p=head_i->next;

while(p!=0)

{

zong2+=p->shifaofi;

p=p->next;

}

ave2=zong2/n2;

cout

cout

coutreturn head_i;

}

int tongji(formal *head_f,informal *head_i)//统计函数，两个参数

{

system("cls");

if(head_f->next==NULL)

cout

else tong_f(head_f);

if(head_i->next==NULL)

cout

else tong_i(head_i);

system("pause");

return 1;

（12）文件保存函数（将文件保存到电脑）

源程序：

database() //文件保存函数

{

ofstream fout(database.c_str(),ios::out);

while(p!=NULL)

{

p->writetofile(fout);

p=p->next;

}

cout

system("pause");

}

string link::opendata(void)//打开已有数据库文件

{

string name;

char filedir[50];

int i;

FILE *dir;

system("cls");

for(i=0;i

cout

for(i=0;i

cout

dir=fopen("dir.txt","r");

system("dir *.data /b> dir.txt");

while(fgets(filedir,30,dir)!=NULL)

{for(i=0;i

fclose(dir);

cout

for(i=0;i

cout

for(i=0;i

cout

cin>>name;

ifstream fin(name.c_str(),ios::in);

if(fin) printf("打开成功！");

else printf("打开失败。");

system("pause");

fin.close();

return(name);

}

（13）主函数

源程序：

int main()

{

int n1=0;

int n2=0;

int k=0;

char type;

formal *head_f;informal *head_i; //定义存储正式 非正式职工头结点的类指

针

head_f = new formal(); //动态创建派生的正式职工类

head_i = new informal(); //动态创建派生的非正式职工类

string database;

link o_link;

ifstream fin(database.c_str(),ios::in);

basic *head=NULL,*p;

if(fin>>type)

{

if(type=='f') head=new formal;

else head=new informal;

head->infromfile(fin);

p=head;

while(fin>>type)

{

if(type=='f') p->next=new formal;

else p->next=new informal;

p=p->next;

p->infromfile(fin);

}

}

for(;;)

{

cout

****************"

cout

cout

cout

cout

*"

cout

cout

cout

cout

cout

cout

cout

cout

*********************************************************"

cin>>k;

switch(k) //选择功能

{

case 1:database=o_link.printmenu();break;//调用链接函数 case 2:input(head_f,head_i);break; //调用输入函数

case 3:output(head_f,head_i);break; //调用输出函数

case 4:find(head_f,head_i);break; // 调用查找函数

case 5:del(head_f,head_i);break; //调用删除函数

case 6:rev(head_f,head_i);break; //调用恢复函数

case 7:edit(head_f,head_i);break; //调用修改函数

case 8:tongji(head_f,head_i);break; //调用统计函数

case 9:save(head,database);break; //调用保存文件函数

case 0:exit(0);

}

system("cls");

}

return 0;

};

第三章 运行结果及操作方法

输入（

0-9）选择要执行的操作，进入下一个界面。

选择1，进入下面文件新建界面，然后选择1，新建文件

2，打开文件

选择2进入职工信息输入及添加界面选择要输入职工信息类别，然后输入职工信息。输入

y 继续输入当前类别下的信息，输入其他结束当前输入返回首页。

选择

3进入职工信息显示界面

选择

4进入职工信息查找界面，输入要查找的职工编号

选择

5进入职工信息删除界面选择要删除的职工信息，

选择6

进入职工信息恢复界面，选择要恢复的职工编号。

选择7进入职工信息修改界面，选择要修改的职工信息类别，然后选择要修改的职工

编号，重新输入该职工的所有信息，完成职工信息修改。

输入

8进入职工信息统计界面

选择9保存文件。

第四章 心得体会

经过持续很多周的课程设计，我受益匪浅，只有一个不足之处，那就是没有为本程序花费太多的时间，没有及时调试，及时发现问题。以前学的知识点都局限于课本内容，本以为学会课本就能自己写出程序，后来经过课程设计我发现，课本上的内容只是编程序的工具而已，编好一个好程序不仅需要丰厚的知识点，还需要灵活的思维能力，而本次课程设计让我懂得了这个道理并且为我锻炼编程思想创造了机会。刚看到题目，觉得题目很难，后来一行一行地写代码，逐渐发现编程序其实很好。虽然错误百出，但是我心里很高兴。

所以，我认为这门课更要注重于实践，我们不能只局限于课本，应该亲手操作，亲眼看看运行结果，然后调试。这有这样，我们才能在学习更上一层楼。我们学语言的目的就是编程，只有会编程，能编出好程序的人才能说是优秀的，因此，我会不断努力，不断地编程序。

另外，刚开始写的时候感觉还是有一定的困难，想过放弃，然后给老师一个解释。但是最后看着其他同学都在忙着编程序，而且都接近于成功，我就鼓起勇气继续编程序，最后编完了。这就说明，在编程序的时候难免会遇到很多的问题，这是我们不应该放弃，不应该偷懒，不应该找各种不正当的理由，应该坚持编下去。就算错误百出，我们不应该烦恼，应该及时发现问题，及时解决问题。

最后，感谢老师的细心指导和评价！

2015.06.27