编译系统设计综合训练 - 任务书 - 2016Spring (1)
毕业设计(论文)任务书-模版【范本模板】
毕业设计（论文）任务书
设计(论文)题目：基于PID的液体恒定控制系统
设计——液位控制
起迄日期：2015年11月4日——2016年5月25日
发任务书日期: 2015年 12月 19日
毕业设计(论文)任务书
5．本毕业设计（论文）课题工作进度计划：
起迄日期工作内容
2015。
11。
04———2015。
11。
28
2015.11。
29——-2015.12.16
2015.12。
17--—2016。
01.10 2016。
02.25---2016。
03。
09
2016。
03.09-—-2016。
04.28
2016。
04.29—-—2016。
05。
09
2016.05。
09---2016.05.13 2016.05。
14———2016.05.21 在毕业设计管理系统里选题
与指导教师共同确定毕业设计课题
查阅指导教师下发的任务书，准备开题报告
提交开题报告、外文参考资料及译文、论文大纲
进行毕业设计(论文），填写中期检查表，提交论文草稿等按照要求完成论文或设计说明书等材料,提交论文定稿
教师评阅学生毕业设计;学生准备毕业设计答辩
参加毕业设计答辩，整理各项毕业设计材料并归档
所在专业审查意见：
负责人：
2015年 12月 17 日。
《编译原理》课程实践环节：程序设计语言Wren的自动排版工具
《编译原理》课程实践环节如果你对本课程实践环节的题目、要求或内容等方面的设计有任何意见或建议，欢迎联系中山大学计算机科学系李文军老师（lnslwj@）。
实验题目：程序设计语言Wren的自动排版工具在正式开始你的实验之前，请务必花足够时间仔细阅读完本文档关于实验的描述与约定！实验目的本实验是一个基于编译原理课程核心教学内容的综合性实验，利用一门简单程序设计语言的处理工具设计与实现，帮助学生通过实践深入理解和牢固掌握编译技术中词法分析、语法分析、语法制导翻译等重要环节。
本实验的主要目标包括：1、 掌握词法分析器的工作原理与构造方法，并能够推广到对文本的串匹配操作等其他同类型应用。
2、 掌握词法分析器自动生成工具lex或类似工具的工作原理与使用方法，学习如何编写一个lex源文件以解决词法分析或模式匹配问题，初步体会软件自动化的基本思路。
3、 掌握递归下降的预测分析方法以及语法制导的翻译技术，学习如何根据BNF语法定义和应用需求设计一个翻译模式，并利用高级程序设计语言的递归机制实现一个翻译模式。
4、 掌握语法分析器自动生成工具yacc或类似工具的工作原理与使用方法，学习如何编写一个yacc源文件以解决语法分析及语法制导翻译问题，进一步加深体会软件自动化的基本思路。
5、 通过加强设计方面的讨论与编程风格的实践，提高对面向对象设计的认识，养成良好的编程习惯，并学会多个工程文档的组织与提交。
程序设计语言Wren程序设计语言Wren 是一门颇为简单的命令式（imperative ）语言，这类风格的语言又称为过程式（procedural ）语言。
Kenneth Slonneger 和Barry Kurtz 设计了这门语言，并以它为实例介绍程序设计语言语法处理与语义处理的形式化途径。
对此有兴趣的同学可参考：Wren 语言的语法定义如下：<program>::= program <identifier> is <block><block>::= <decl_seq> begin <command_seq> end <decl_seq>::= ε | <declaration> <decl_seq><declaration>::= var <variable_list> : <type> ;<type>::= integer | boolean <variable_list>::= <variable> | <variable> , <variable_list><command_seq>::= <command> | <command> ; <command_seq><command>::= <variable> := <expr> | skip| read <variable> | write <integer_expr>| while <bool_expr> do <command_seq> end while| if <bool_expr> then <command_seq> end if| if <bool_expr> then <command_seq> else <command_seq> end if<expr>::= <integer_expr> | <bool_expr><integer_expr>::= <term> | <integer_expr> <weak_op> <term><term>::= <element> | <term> <strong_op> <element><element>::= <numeral> | <variable> | ( <integer_expr> ) | – <element><bool_expr>::= <bool_term> | <bool_expr> or <bool_term><bool_term>::= <bool_element> | <bool_term> and <bool_element><bool_element>::= true | false | <variable> | <comparison>| not ( <bool_expr> ) | ( <bool_expr> )<comparison>::= <integer_expr> <relation> <integer_expr><variable>::= <identifier><relation>::= <= | < | = | > | >= | <><weak_op>::= + | –<strong_op>::= * | /<identifier>::= <letter> | <identifier> <letter> | <identifier> <digit><letter>::= a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z <numeral>::= <digit> | <digit> <numeral><digit>::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |9实验一：熟悉BNF定义Wren语言的BNF定义给出了该语言语法方面的形式化规格说明。
编译原理课程设计LR1分析语法分析器实现（C++）
编译原理课程设计LR1分析语法分析器实现（C++）输⼊的⽂法（第⼀⾏是终结符）将⽂法保存在txt中，命名为text.txt，与LR1.cpp放在同⼀⽬录中即可运⾏。
text.txtabcdeS->aAdS->bAcS->aecS->bedA->e实现代码：LR1.cpp1 #include<fstream>2 #include<iostream>3 #include<string>4 #include<vector>5 #include <algorithm>6#define MAX_Count 1007 #include <set>8 #include <stack>9 #include <iomanip>10 #include <sstream>11 #include <string>12 #include<cstring>13 #include <map>14using namespace std;151617// 重载⼀下+号运算符18 template <typename CSS_LR1>19 vector<CSS_LR1> &operator +(vector<CSS_LR1> &v1,vector<CSS_LR1> &v2)20 {21 v1.insert(v1.end(),v2.begin(),v2.end());22return v1;23 }242526struct VN_Set{27string VN_name;//⾮终结符28set<string> FIRST; //First集合29set<string> FOLLOW;30 };31struct CSS{32string start;//⾮终结符33 vector<string> next; //First集合34 };35struct CSS_LR1{36string start;//⾮终结符37 vector<string> next; //First集合38int num;39 vector<string> tail;40//41// bool operator==(CSS_LR1& rhs) const {42// return (start == rhs.start &&43// next == rhs.next &&44// num == rhs.num &&45// tail == rhs.tail);46// }47bool operator==(const CSS_LR1& rhs) {48return (start == rhs.start &&49 next == rhs.next &&50 num == rhs.num &&51 tail == rhs.tail);52 }5354 };5556int CSSCount = 0;57 CSS css[MAX_Count];//产⽣式58 VN_Set VN_First[MAX_Count];//⾮终结符集的First集合59set<string> VN;// ⾮终结符集合60set<string> VT;//终结符集合61int I_count = 0;//记录LR1项⽬数62 vector<CSS_LR1> I[MAX_Count]; //项⽬集63 map<string,int> mark_Follow;//⽤于标记Follow 防⽌套娃64 map<string,int> GOTO[MAX_Count];65 map<string,string> ACTION[MAX_Count];666768bool cmp_vector(vector<CSS_LR1>&v1, vector<CSS_LR1>&v2)69 {70if(v1.size()!=v2.size()) return false;71for (int i=0; i<v2.size(); i++)72 {73 CSS_LR1 t;74 t = v2[i];75 vector<CSS_LR1>::iterator result = find(v1.begin( ), v1.end( ),t); //查找376if (result == v1.end( )) //没找到77return false;78 }79return true;80 }8182/*83*实现编译原理语法分析中计算⾮终结符的First集Follow集84*/85set<string> get_FIRST(string a){ //求First集合86set<string> T;87for(int i = 0;i<CSSCount;i++){88if(css[i].start==a){ // a->..89for(int j=0;j<css[i].next.size();j++){90if(VT.find(css[i].next[j])!=VT.end()){ //是终结符开头91 T.insert(css[i].next[j]);92// T.erase("*");93break;94 }95else{96if(css[i].next[j]==css[i].start){102if(j!=css[i].next.size()-1)103 T.erase("$");104 }else{105106break;107 }108 }109110111 }112113 }114 }115116return T;117 }118119set<string> get_FOLLOW(string a){120set<string> T;121//cout<<"现在在求"<<a<<" 的Follow"<<endl;122 mark_Follow[a]++;123if(mark_Follow[a]>=2){124return T;125 }126127set<string> temp;128if(a==css[0].start){129 T.insert("#");130 }131for(int i = 0;i<CSSCount;i++){132for(int j =0;j<css[i].next.size();j++){133if(VT.find(css[i].next[j])==VT.end()&&a==css[i].next[j]){ //是⾮终结符，求FOLLOW集合134if(j==css[i].next.size()-1&&a!=css[i].start){//S->...a135set<string> tt = get_FOLLOW(css[i].start);136 T.insert(tt.begin(),tt.end());137 }138for(int k=j+1;k<css[i].next.size();k++){139if(VT.find(css[i].next[k])!=VT.end()){//后⾯⼀个是终结符 S->..av..140 T.insert(css[i].next[k]);141break;142 }143else{144 temp = get_FIRST(css[i].next[k]);145if(temp.find("$")!=temp.end()){//有$ S->..a B..146 T.insert(temp.begin(),temp.end());147 T.erase("$");148if(k==css[i].next.size()-1){ //S->..a B149set<string> tt = get_FOLLOW(css[i].start);150 T.insert(tt.begin(),tt.end());151break;152 }153 }else{154 T.insert(temp.begin(),temp.end());155break;156 }157 }158 }159160 }161 }162163 }164//cout<<a<<" "<<mark_Follow[a]<<endl;165 mark_Follow[a]=0;166return T;167 }168169170void GetFirst_and_Follow(){171set<string>::iterator it;172int count = 0;173 cout<<"========================================="<<endl;174 cout<<'\t' <<"FIRST集合"<<""<<"FOLLOW集合"<<endl;175for(it=VN.begin ();it!=VN.end ();it++)176 {177178 VN_First[count].VN_name = *it;179 VN_First[count].FIRST = get_FIRST(*it);180181 mark_Follow[*it]=0;182 VN_First[count].FOLLOW = get_FOLLOW(*it);183184//-----------输出FIRST--------------------185186 cout<<VN_First[count].VN_name<<'\t';187set<string>::iterator it;188for(it=VN_First[count].FIRST.begin();it!=VN_First[count].FIRST.end();it++){189 cout<<*it<<"";190 }191 cout<<'\t'<<"";192//----------------------------------------193194195196197//------------输出FOLLOW--------------198set<string>::iterator it1;199for(it1=VN_First[count].FOLLOW.begin();it1!=VN_First[count].FOLLOW.end();it1++){200 cout<<*it1<<"";201 }cout<<endl;202203//----------------------204205 count++;206 }cout<<"=========================================";207 cout<<endl<<endl;208 }209210211212213214void input(){215//创建⼀个⽂件输⼊流对象216 ifstream inFile;217//打开⽂件218 inFile.open("test.txt");223 cout << "file doesn't exist" << endl;224225string temp;226 getline(inFile,temp);227for(int j=0;j<temp.length();j++){228 VT.insert(temp.substr(j,1));229 }230set<string>::iterator p;231 cout<<"终结符号:";232for(p = VT.begin();p!=VT.end();p++){233 cout<<*p<<",";234 }cout<<endl;235236int count = 0;//⽂件⾏数237while(getline(inFile,temp)) //按⾏读取⽂件内容238 {239 css[count].start = temp[0] ;240for(int j=3;j<temp.length();j++){241 css[count].next.push_back(temp.substr(j,1));242 }243 VN.insert(css[count].start);//⾮终结符244245 cout<<css[count].start<<"->";246 vector<string>::iterator it;247for(it=css[count].next.begin();it!=css[count].next.end();it++){248 cout<<*it;249 }250 cout<<endl;251252253 count++;254 }255 CSSCount = count;256257258 }259260bool find_in_vector(vector<CSS_LR1> T,CSS_LR1 p){261 vector<CSS_LR1>::iterator it;262for(it=T.begin();it!=T.end();it++){263if(*it==p){264return true;265 }266 }267return false;268 }269270271 vector<CSS_LR1> CLOSURE(CSS_LR1 I){//求闭包272 vector<CSS_LR1> T;273//T.push_back(I);274if(I.num>=I.next.size()) { //规约项⽬A->α.或者接受项⽬275return T;276 }277else{278string temp = I.next[I.num];279if(VT.find(temp)!=VT.end()){ //点后⾯的是终结符 ,移进项⽬ A→α.aβ280return T;281 }282else{ //待约项⽬283for(int i = 0;i<CSSCount;i++){284if(css[i].start==temp){285 CSS_LR1 p;286 p.start = css[i].start;287 p.num = 0;//点在最前⾯288 p.next = css[i].next;289290set<string> f1;291for(int j = I.num+1;j<I.next.size();j++){292set<string> f2;//⽤于暂存first293294if(VT.find(I.next[j])!=VT.end()){295296 f2.insert(I.next[j]);297 }else{298 f2 = get_FIRST(I.next[j]);299 }300301 f1.insert(f2.begin(),f2.end());302if(f2.find("$")==f2.end()){303304break;305 }306 }307308if(f1.size()==0){309 p.tail=I.tail;310 }311else{312 vector<string> first_tail;313if(f1.find("$")!=f1.end()){314 f1.erase("$");315 copy(f1.begin(),f1.end(), back_inserter(first_tail));316 first_tail.insert(first_tail.end(),I.tail.begin(),I.tail.end()); 317 }else{318 copy(f1.begin(),f1.end(), back_inserter(first_tail));319//cout<<first_tail[0]<<endl;320 }321// vector<string>::iterator l;322// for(l=first_tail.begin();l!=first_tail.end();l++){323// cout<<*l<<" ";324// }cout<<endl;325 p.tail=first_tail;326 }327if(!find_in_vector(T,p)){328329 T.push_back(p);330 vector<CSS_LR1> ol = CLOSURE(p);331 vector<CSS_LR1>::iterator z;332for(z=ol.begin();z!=ol.end();z++){333if(find_in_vector(T,*z)){334 }else{335 T.push_back(*z);336 }337 }338339 }344 }345346return T;347 }348349void showI(vector<CSS_LR1> I){//展⽰项⽬集350 vector<CSS_LR1>::iterator it;351for(it=I.begin();it!=I.end();it++){352 CSS_LR1 p = *it;353 cout<<p.start<<"->";354 vector<string>::iterator s;355for(int j = 0;j<p.next.size();j++){356if(j==p.num) cout<<".";357 cout<<p.next[j];358 }if(p.num==p.next.size())cout<<".";359 cout<<",";360for(int k = 0;k<p.tail.size();k++){361 cout<<p.tail[k];362 }cout<<endl;363 }364 }365366void LR1_Analyse(){367 CSS_LR1 p;368//初始项⽬ S’->.S ,#369 p.start = css[0].start+"^";370 p.num = 0;//点在最前⾯371 p.tail.push_back("#");372 p.next.push_back(css[0].start);373374 I[0] = CLOSURE(p);//求闭包后的I[0]375 I[0].insert(I[0].begin(),p);///////////////求闭包遇到了⼀些问题376 I_count=1;377378//计算项⽬集379for(int i=0;i<I_count;i++){//每个项⽬集项⽬集I(i)380381 cout<<"==================="<<endl;382 cout<<"现在在计算项⽬集I"<<i<<endl;383 showI(I[i]);//展⽰项⽬集384 cout<<"==================="<<endl;385386//---------求ACTION的r部分--------------387 vector<CSS_LR1>::iterator t;388for(t=I[i].begin();t!=I[i].end();t++){389 CSS_LR1 t2 = *t;390if(t2.num==t2.next.size()){391int num =0;392for(int xp=0;xp<CSSCount;xp++){393if(css[xp].start==t2.start&&css[xp].next==t2.next){394 num = xp;395break;396 }397 }398399 std::stringstream ss;400 ss<<num;401string s = ss.str();402for(int q = 0;q<t2.tail.size();q++){403 ACTION[i][t2.tail[q]] = "r"+s;404 }405if(t2.num==1&&t2.next[0]==css[0].start){406 ACTION[i]["#"] = "acc";407 }408 }409 }410//--------------------------------------411412413414set<string>::iterator it;415for(it=VN.begin();it!=VN.end();it++){ //每个⾮终结符416//cout<<"项⽬集I"<<i<<"输⼊"<<*it<<endl;417 vector<CSS_LR1> temp;418//cout<<"项⽬集⼤⼩"<<I[i].size()<<endl;419for(int j = 0;j<I[i].size();j++){420 CSS_LR1 lr = I[i][j];421if(lr.num<lr.next.size()&&lr.next[lr.num]==*it){422//cout<<*it<<endl;423 vector<CSS_LR1> t2;424 lr.num++;425 t2 = CLOSURE(lr);426 t2.push_back(lr);427428 temp=temp+t2;429 }430 }431//cout<<"temp.size"<< temp.size()<<endl;432433if(temp.size()>0){434int k;435for(k=0;k<I_count;k++){//找⼀找项⽬集是否已经存在436if(cmp_vector(I[k],temp)){437break;438 }439 }440if(k==I_count){441//产⽣了新的项⽬集442 I[I_count] = temp;443/*444 cout<<"---------------------"<<endl;445 cout<<"新的项⽬集I"<<I_count<<endl;446 cout<<" I"<<i<<" -- "<<*it<<"->"<<"I"<<I_count<<endl<<endl; 447 showI(I[I_count]);//展⽰项⽬集448 cout<<"---------------------"<<endl;449*/450 cout<<" I"<<i<<" -- "<<*it<<"->"<<"I"<<I_count<<endl<<endl; 451 GOTO[i][*it] = I_count;//更新goto表452 I_count++;453 }else{454//项⽬集已经存在，需要⾃⼰指向⾃⼰455 cout<<" I"<<i<<" -- "<<*it<<"->"<<"I"<<k<<endl<<endl;456 GOTO[i][*it] = k;457458 }459460 }465 vector<CSS_LR1> temp;466467for(int j = 0;j<I[i].size();j++){468 CSS_LR1 lr = I[i][j];469470if(lr.num<lr.next.size()&&lr.next[lr.num]==*it){471 vector<CSS_LR1> t2;472 lr.num++;473 t2 = CLOSURE(lr);//闭包求出的结果不包含本⾝474 t2.insert(t2.begin(),lr);/////////求闭包遇到了⼀些问题475//showI(t2);476 temp=temp+t2;477 }478 }479//cout<<"temp.size"<< temp.size()<<endl;480if(temp.size()>0){481int k;482for(k=0;k<I_count;k++){//找⼀找项⽬集是否已经存在483if(cmp_vector(I[k],temp)){484break;485 }486 }487if(k==I_count){488//产⽣了新的项⽬集489 I[I_count] = temp;490/*491 cout<<"---------------------"<<endl;492 cout<<"新的项⽬集I"<<I_count<<endl;493 cout<<" I"<<i<<" -- "<<*it<<"->"<<"I"<<I_count<<endl<<endl;494 showI(I[I_count]);//展⽰项⽬集495 cout<<"---------------------"<<endl;496*/497 cout<<" I"<<i<<" -- "<<*it<<"->"<<"I"<<I_count<<endl<<endl;498 std::stringstream ss;499 ss<<I_count;500string s = ss.str();501 ACTION[i][*it] = "S"+s;//更新AVTION表502 I_count++;503 }else{504//项⽬集已经存在，需要⾃⼰指向⾃⼰505 cout<<" I"<<i<<" -- "<<*it<<"->"<<"I"<<k<<endl<<endl;506 std::stringstream ss;507 ss<<k;508string s = ss.str();509 ACTION[i][*it] = "S"+s;510511 }512513 }514 }515516517 }518519520 }521522void print_line(){523 cout<<"-----------------------------------------------------------------------------"<<endl;524 }525526527528void print_ACTION_GOTO(){529set<string>::iterator it;530 print_line();531 cout<<setw(27) << setiosflags(ios::right) <<"ACTION";532 cout<<setw(20) << setiosflags(ios::left)<<" GOTO"<<endl;533 print_line();534 cout<<setw(8)<<"项⽬集"<<"|";535536for(it=VT.begin();it!=VT.end();it++){537 cout<<setw(8)<<*it<<"|";538 }539 cout<<setw(8)<<"#"<<"|";540for(it=VN.begin();it!=VN.end();it++){541 cout<<setw(8)<<*it<<"|";542 }543 cout<<endl;544for(int j =0;j<I_count;j++){545 cout<<setw(6)<<"I"<<setw(2)<<j<<"|";546for(it=VT.begin();it!=VT.end();it++){547 cout<<setw(8)<<ACTION[j][*it]<<"|";548 }549 cout<<setw(8)<<ACTION[j]["#"]<<"|";550for(it=VN.begin();it!=VN.end();it++){551552if(GOTO[j][*it])//GOTO表为0553 cout<<setw(8)<<GOTO[j][*it]<<"|";554else{555 cout<<setw(8)<<""<<"|";556 }557 }558 cout<<endl;559 }560 print_line();561562 }563564565566//对栈容器进⾏输出,i=0,返回status中的字符串,i=1,返回sign中的字符串，i=2返回inputStr中的字符串567string vectTrancStr(int i,vector<int> status,vector<string> sign){568string buf;569int count = 0;570//输出状态栈571if(i == 0){572 vector<int>::iterator it =status.begin();573//将数字转化为字符串574string str,tempStr;575for(it;it!= status.end();it++){576 stringstream ss;577 ss << *it;578 ss >> tempStr;579 str+=tempStr;580 }581return str;586for(it ; it != sign.end() ;it++){587 buf += *it;588 count++;589 }590 }591592593string str(buf);594return str;595 }596597598599void Input_Analyse(){//输⼊句⼦，开始分析600601 vector<int> status;//定义状态栈602 vector<string> sign;//定义符号栈603604int step = 1; //步骤605string input;606 cout<<"请输⼊分析的字符串(请以#结尾)：";607 cin>>input;//输⼊待分析的句⼦608 input = input+"#";609610 status.push_back(0);//把状态0⼊栈611//把#加⼊符号栈612 sign.push_back("#");613//输出初始栈状态614 cout<<setw(10)<<"步骤"<<setw(10)<<"状态栈"<<setw(10)<<"符号栈"<<setw(10)<<"输⼊串"<<setw(25)<<"动作说明"<<endl;615616int s =0;//初始状态617618int oldStatus;//保存之前的状态619620621string input_s; //获取初始符号622 input_s = input.substr(0,1);623624while(ACTION[s][input_s] != "acc"){//如果action[s][input_s] =="acc" ，则分析成功625//获取字符串626string str = ACTION[s][input_s];627//如果str为空，报错并返回628if(str.size() == 0){629 cout<<"出错";630return ;631 }632//获取S或r后⾯的数字633 stringstream ss;634 ss << str.substr(1);635 ss >> s;//新的状态号636//如果是移进637if(str.substr(0,1) == "S"){638 cout<<setw(10)<<step<<setw(10)<<vectTrancStr(0,status,sign)<<setw(10)<<vectTrancStr(1,status,sign)<<setw(10)<<input<<setw(10)<<"A"<<"CTION["<<status.back()<<","<<input_s<<"]=S"<<s<<","<<"状态"<<s<< 639 sign.push_back(input_s); //输⼊符号⼊栈640 input.erase(0,1);641 status.push_back(s);//将状态数字⼊栈642 }643//如果是规约644else if(str.substr(0,1) == "r"){645string kaitou;//产⽣式的头部646 kaitou = css[s].start;647int pop_num = css[s].next.size();//获取符号栈的出栈次数648649string r;650 stringstream ss;651 ss << s;652 ss >> r;653int oldStatus;//保存之前的状态654int status_size = status.size();655 oldStatus = status[status_size-1-pop_num];656 s=GOTO[oldStatus][kaitou];657 cout<<setw(10)<<step<<setw(10)<<vectTrancStr(0,status,sign)<<setw(10)<<vectTrancStr(1,status,sign)<<setw(10)<<input<<setw(10)<<(string)":产⽣式"+r+(string)"归约,GOTO("<<oldStatus<<","<<kaitou<<")="<<s<< 658//对符号栈进⾏出栈和状态栈进⾏出栈659while(pop_num--){660 sign.pop_back();661 status.pop_back();662 }663664 sign.push_back(kaitou);//再对产⽣式的开始符号⼊栈665 status.push_back(s);//再把新的状态⼊栈666 }667else{668//nothing669 }670671 step++; //步骤数加1672673 s = status.back();//获取栈顶状态674675 input_s = input.substr(0,1);//获取输⼊的字符676 }677 cout<<setw(10)<<step<<setw(10)<<vectTrancStr(0,status,sign)<<setw(10)<<vectTrancStr(1,status,sign)<<setw(10)<<input<<setw(10)<<"A"<<"cc:分析成功"<<endl;678679680 }681int main(){682 input();//输⼊⼆型⽂法683 GetFirst_and_Follow();//求First和Follow集合684 LR1_Analyse();685 print_ACTION_GOTO();//打印ACTION GOTO表686 Input_Analyse();//输⼊句⼦，开始分析687 }LR1.cpp代码的输⼊写的⽐较草率，可以⾃⾏修改⼀下，只要保存到相应的数据结构中，就不影响后⾯的LR1分析。
计算机程序设计实践任务书。
计算机程序设计实践任务书。
第一篇：计算机程序设计实践任务书。
《计算机程序设计实践》任务书时间： 2014年上学期第14-16周；18-19周班级：指导教师：一、实践目的和要求1．巩固C++基础知识，了解基于对话框应用程序、文档/视图应用程序的框架结构及其运行机制，初步掌握创建MFC应用程序的方法、过程。
2．掌握常用控件的重要属性、主要消息、常用成员函数，并能熟练地应用这些控件设计应用程序。
3．了解绘制图形的方法、定时器的使用，鼠标消息处理函数和键盘消息处理函数编写。
4．掌握对话框使用和菜单设计的技术，培养学生独立设计综合程序的能力；同时培养自学能力；训练小论文撰写能力。
二、设计任务从下列5个设计方向中选择一个或多个，将程序所有功能用菜单整合在一个项目中，要求达到预期效果、并写出实践报告。
1.计算程序设计。
如：计算器；一元二次方程的求解；华氏温度和摄氏温度之间转换，十进制与二、八、十六进制之间的转换；求字符的ASCII码、阶乘、最大公约数、最小公倍数；素数、水仙花数、完数、回文数等数的判定等等。
2.文本编辑程序设计。
3.绘图程序设计。
如：吹泡泡程序、曲线等图形绘制。
4.多媒体程序设计。
如：音频播放器、FLASH动画播放器等。
5.信息管理程序设计。
三、考核与成绩评定方式采用百分制，实践课总评成绩取下列3个百分制成绩的加权和：平时考勤和表现成绩×20%+实践报告成绩×20%+设计项目成绩×60%。
其中，每部分成绩满分均为100分。
最后折算为五个等级：优、良、中等、及格和不及格。
四、参考文献[1] 杨长兴，刘卫国.C++程序设计（第二版）.北京：中国水利水电出版社,2012.[2] 刘卫国，杨长兴.C++程序设计实践教程（第二版）.北京：中国水利水电出版社,2012.[3] 张荣梅.Visual C++程序设计案例教程.北京：北京大学出版社,2009.[4] 文东，华进.Visual C++程序设计基础与项目实训.北京：北京科海电子出版社,2009.[5] 杨红云，尹立民.Visual C++程序设计视频教程.北京：北京电子工业出版社,2005.[6] 周进，朱训林.Visual C++实用教程.北京：北京人民邮电出版社,2008.[7]第二篇：《计算机专业程序设计》课程设计任务书 DOC《计算机专业程序设计》课程设计任务书程序设计课程设计是计算机科学与技术专业教学实践环节中一项重要内容，该课程设计旨在：提高和加强学生的计算机应用与软件开发能力；培养学生独立分析问题、解决问题、查阅资料以及自学能力，学习和掌握C++程序设计方法以及上机调试技巧，为今后其它专业课程的学习打下良好的程序设计基础。
Java程序开发实训(实训任务书)(word文档良心出品)
Java程序开发实训——实训任务书主编：季松华目录图书馆管理信息系统开发实训 (3)1.实训任务 (3)2.实训目的 (4)3.实训方式 (5)4.实训条件 (5)5.实训内容及计划 (5)6.实训步骤 (7)6.1子任务一：需求分析与项目设计 (7)6.2子任务二：数据库设计与环境搭建 (8)6.3子任务三：MVC设计与底层代码封装 (9)6.4子任务四：界面设计 (9)6.5子任务五：用户管理子系统 (10)6.6子任务六：图书管理子系统 (10)6.7子任务七：图书借还管理子系统 (11)6.8子任务八：软件测试与项目总结 (11)7.考核标准 (12)8.参考资料 (13)附件软件文档编写向导 (14)图书馆管理信息系统开发实训1.实训任务本次实训计划32学时，完成一个c/s架构的图书馆管理信息系统的设计、编码和测试。
实训的重点是面向对象程序设计、图形界面设计、事件的处理及数据库编程设计。
1.1项目背景XXX学校每学期都要购进大量的书籍，图书馆管理系统是一个学校不可缺少的一部分。
它的操作和管理对于管理者来说，可以使书籍管理工作规范化、系统化、程序化，很重要的是能够为用户提供充足的信息和快捷的查询手段。
因此有必要建立一个图书管理系统，以避免图书管理的随意性，提高信息处理的速度和准确性，能够及时、准确、有效的查询和修改图书情况。
1.2系统架构本系统采用简单的c/s架构，mysql充当数据库服务器，可以同时被多个客户端连接。
1.3功能示例图书管理系统主要有用户管理、图书管理、借阅管理等功能。
图1 图书馆管理系统结构示意图图2 图书馆管理系统功能矩阵&角色权限图2.实训目的通过本次实训使学生系统的掌握软件开发的主要流程，并学会Java语言开发软件项目的方法，掌握软件技术文档的撰写要求。
3.实训方式本次任务共分解成八个子任务，每个子任务分配4个学时。
由教师布置任务，引导学生对任务进行讨论、分析，剖析出任务的要点与难点，针对难点进行演示。
pring课程设计
pring课程设计一、课程目标知识目标：1. 让学生掌握Spring框架的基本概念和核心组件，理解Spring的依赖注入和面向切面编程原理。
2. 使学生能够运用Spring进行Java应用程序开发，掌握配置和使用Spring 容器、编写Spring Bean、整合Spring与其他框架（如MyBatis、Hibernate）的能力。
3. 帮助学生理解Spring MVC的运行机制，学会搭建Spring MVC项目，并能独立完成简单的Web应用开发。
技能目标：1. 培养学生运用Spring框架解决实际问题的能力，提高代码的可维护性和可扩展性。
2. 培养学生阅读和分析Spring源码的能力，提升对框架原理和设计模式的深入理解。
3. 培养学生具备团队协作开发Spring项目的能力，学会使用版本控制工具和项目管理工具。
情感态度价值观目标：1. 培养学生对Spring框架的兴趣和热情，激发学习动力，养成主动探究和解决问题的习惯。
2. 培养学生的团队协作意识，学会尊重他人意见，善于沟通交流，共同完成项目任务。
3. 培养学生具备良好的编程习惯，遵循编码规范，关注软件质量和用户体验。
课程性质：本课程为高年级专业选修课，旨在使学生掌握Spring框架的使用，提高Java企业级开发能力。
学生特点：学生已具备一定的Java基础，熟悉面向对象编程，对框架有初步了解。
教学要求：注重理论与实践相结合，通过案例教学，让学生在实际项目中掌握Spring框架的应用。
同时，注重培养学生的团队协作能力和解决问题的能力。
在教学过程中，关注学生的个性化需求，提供针对性的辅导和指导。
二、教学内容1. Spring框架基础- Spring概述：介绍Spring的发展历程、优势特点。
- Spring核心容器：讲解BeanFactory、ApplicationContext等概念，以及Bean的生命周期。
- 依赖注入：讲解依赖注入的原理、方式，以及相关注解的使用。
javaspring课程设计
javaspring课程设计一、课程目标知识目标：1. 学生能掌握Spring框架的基本原理，理解依赖注入、面向切面编程等核心概念；2. 学生能运用Spring框架构建Java应用程序，实现数据持久化、事务管理等功能；3. 学生了解Spring MVC架构，能独立设计并实现基于Spring MVC的Web 应用程序。
技能目标：1. 学生能熟练使用Spring框架进行项目开发，提高编码效率；2. 学生具备分析项目需求，运用Spring框架进行系统设计的能力；3. 学生能运用Spring MVC搭建Web应用，实现前后端分离，提高项目可维护性。
情感态度价值观目标：1. 学生通过学习Spring框架，培养对新技术的好奇心和探索精神；2. 学生在项目实践中，养成团队协作、沟通表达的良好习惯；3. 学生认识到编程规范和代码质量的重要性，树立良好的编程习惯。
课程性质：本课程为实践性课程，强调理论联系实际，培养学生动手能力。
学生特点：学生具备一定的Java基础，对框架有一定了解，但实际操作能力较弱。
教学要求：结合学生特点，课程设计应注重实践，以项目驱动教学，让学生在实际操作中掌握Spring框架的应用。
同时，注重培养学生的团队协作能力和编程规范。
通过本课程的学习，使学生具备独立开发基于Spring框架的应用程序的能力。
二、教学内容1. Spring框架基础原理- 依赖注入原理及实现方式- 面向切面编程（AOP）概念及应用- Spring核心容器及常用API2. Spring框架数据访问- Spring JDBC Template的使用- Spring事务管理- 整合MyBatis实现数据持久化3. Spring MVC架构- Spring MVC工作原理- 控制器（Controller）的使用- 视图解析器（View Resolver）与视图（View）配置4. 基于Spring MVC的Web应用开发- RESTful API设计与实现- 前后端分离开发模式- 跨域问题解决方案5. Spring框架进阶应用- Spring Boot快速开发- Spring Security安全框架- Spring Cloud微服务架构教学大纲安排：第1周：Spring框架基础原理学习第2周：依赖注入及AOP编程实践第3周：Spring数据访问与事务管理第4周：Spring MVC架构学习与实践第5周：基于Spring MVC的Web应用开发第6周：Spring框架进阶应用学习教学内容与教材章节关联：1. 《Java Spring实战》第1-3章：Spring框架基础原理2. 《Java Spring实战》第4-6章：Spring数据访问与事务管理3. 《Java Spring实战》第7-9章：Spring MVC架构4. 《Java Spring实战》第10-11章：基于Spring MVC的Web应用开发5. 《Java Spring实战》第12章：Spring框架进阶应用三、教学方法本课程采用以下教学方法，旨在激发学生的学习兴趣，提高实践操作能力，培养创新精神和团队协作能力。
Spring5核心原理与30个类手写实战pdf下载
Spring5核心原理与30个类手写实战pdf下载基于编程开发实践，不仅深度解析Spring 5的原理与新特性，更从环境准备、顶层结构设计、数据访问等方面一步步地推导出Spring的设计原理。
在每个知识点上，均以大量的经典代码案例辅助讲解，使理论紧密联系实际。
最后手写30个类，以体会Spring的创作过程，让每一位读者学以致用。
Spring5核心原理与30个类手写实战资料目录第1篇 Spring内功心法第1章软件架构设计原则 21.1 开闭原则 21.2 依赖倒置原则 41.3 单一职责原则 71.4 接口隔离原则 101.5 迪米特原则 121.6 里氏替换原则 141.7 合成复用原则 191.8 设计原则总结 20第2章 Spring中常用的设计模式 212.1 为什么要从设计模式开始 212.1.1 写出优雅的代码 222.1.2 更好地重构项目 242.1.3 经典框架都在用设计模式解决问题 36 2.2 工厂模式详解 362.2.1 工厂模式的由来 362.2.2 简单工厂模式 372.2.3 工厂方法模式 412.2.4 抽象工厂模式 432.2.5 利用工厂模式重构的实践案例 472.3 单例模式详解 532.3.1 单例模式的应用场景 532.3.2 饿汉式单例模式 532.3.3 懒汉式单例模式 542.3.4 反射破坏单例 602.3.5 序列化破坏单例 612.3.6 注册式单例模式 682.3.7 线程单例实现ThreadLocal 742.3.8 单例模式小结 752.4 原型模式详解 752.4.1 原型模式的应用场景 752.4.2 浅克隆 772.4.3 深克隆 792.4.4 克隆破坏单例模式 812.4.5 clone()方法的源码 822.5 代理模式详解 822.5.1 代理模式的应用场景 822.5.2 静态代理 832.5.3 动态代理 882.5.4 代理模式与Spring 1072.5.5 静态代理和动态代理的本质区别 1082.5.6 代理模式的优缺点 1092.6 委派模式详解 1092.6.1 委派模式的定义及应用场景 1092.6.2 委派模式在源码中的体现 1112.7 策略模式详解 .1142.7.1 策略模式的应用场景 1142.7.2 用策略模式实现选择支付方式的业务场景 .114 2.7.3 策略模式在JDK源码中的体现 1222.7.4 策略模式的优缺点 1252.7.5 委派模式与策略模式综合应用 1252.8 模板模式详解 1292.8.1 模板模式的应用场景 1292.8.2 利用模板模式重构JDBC操作业务场景 132 2.8.3 模板模式在源码中的体现 1362.8.4 模板模式的优缺点 1382.9 适配器模式详解1392.9.1 适配器模式的应用场景 1392.9.2 重构第三方登录自由适配的业务场景141 2.9.3 适配器模式在源码中的体现 1492.9.4 适配器模式的优缺点 1532.10 装饰者模式详解 1532.10.1 装饰者模式的应用场景 1532.10.2 装饰者模式和适配器模式对比 1632.10.3 装饰者模式在源码中的应用 1632.10.4 装饰者模式的优缺点 1652.11 观察者模式详解 1652.11.1 观察者模式的应用场景 1652.11.2 观察者模式在源码中的应用 1752.11.3 基于Guava API轻松落地观察者模式 176 2.11.4 观察者模式的优缺点 1772.12 各设计模式的总结与对比 177 2.12.1 GoF 23种设计模式简介 177 2.12.2 设计模式之间的关联关系 178 2.12.3 Spring中常用的设计模式 182 2.13 Spring中的编程思想总结 183 第2篇 Spring环境预热第3章 Spring的前世今生 1863.1 一切从Bean开始 1873.2 Spring的设计初衷 1883.3 BOP编程伊始 1883.4 理解BeanFactory 1893.5 AOP编程理念 189第4章 Spring 5系统架构 1914.1 核心容器 1924.2 AOP和设备支持1924.3 数据访问与集成1934.4 Web组件 1944.5 通信报文 1944.6 集成测试 1944.7 集成兼容 1944.8 各模块之间的依赖关系 194第5章 Spring版本命名规则 1965.1 常见软件的版本命名 1965.2 语义化版本命名通行规则 1975.3 商业软件中常见的修饰词 1975.4 软件版本号使用限定 1985.5 Spring版本命名规则 199第6章 Spring源码下载及构建技巧 2006.1 Spring 5源码下载 2006.2 基于Gradle的源码构建技巧 2016.3 Gradle构建过程中的坑 207第3篇 Spring核心原理第7章用300行代码手写提炼Spring核心原理 210 7.1 自定义配置 2107.1.1 配置application.properties文件 2107.1.2 配置web.xml文件 2107.1.3 自定义注解 2117.1.4 配置注解 2127.2 容器初始化 2137.2.1 实现1.0版本 2137.2.2 实现2.0版本 2167.2.3 实现3.0版本 2237.3 运行效果演示 227第8章一步一步手绘Spring IoC运行时序图 228 8.1 Spring核心之IoC容器初体验 2288.1.1 再谈IoC与DI 2288.1.2 Spring核心容器类图 2298.1.3 Web IoC容器初体验 2328.2 基于XML的IoC容器的初始化 2378.2.1 寻找入口 2388.2.2 获得配置路径 2388.2.3 开始启动 2408.2.4 创建容器 2428.2.5 载入配置路径 2438.2.6 分配路径处理策略 2448.2.7 解析配置文件路径 2478.2.8 开始读取配置内容 2498.2.9 准备文档对象 2508.2.10 分配解析策略 2518.2.11 将配置载入内存 2528.2.12 载入＜bean＞元素 2578.2.13 载入＜property＞元素 2618.2.14 载入＜property＞子元素 2648.2.15 载入＜list＞子元素 2668.2.16 分配注册策略 2678.2.17 向容器注册 2678.3 基于注解的IoC初始化 2708.3.1 注解的前世今生 2708.3.2 定位Bean扫描路径 2718.3.3 读取注解的元数据 2738.3.4 扫描指定包并解析为BeanDefinition 277 8.3.5 注册注解BeanDefinition 2838.4 IoC容器初始化小结 285第9章一步一步手绘Spring DI运行时序图 287 9.1 Spring自动装配之依赖注入 2879.1.1 依赖注入发生的时间 2879.1.2 寻找获取Bean的入口 2889.1.3 开始实例化 2939.1.4 选择Bean实例化策略 2979.1.5 执行Bean实例化 2999.1.6 准备依赖注入 3019.1.7 解析属性依赖注入规则 3069.1.8 注入赋值 3109.2 Spring IoC容器中那些鲜为人知的细节 314 9.2.1 关于延时加载 3149.2.2 关于FactoryBean和BeanFactory 3179.2.3 再述autowiring 322第10章一步一步手绘Spring AOP运行时序图 326 10.1 Spring AOP初体验 32610.1.1 再述Spring AOP应用场景 32610.1.2 AOP中必须明白的几个概念 32710.1.3 使用Spring AOP的两种方式 32910.1.4 切入点表达式的配置规则 33310.2 Spring AOP源码分析 33410.2.1 寻找入口 33410.2.2 选择代理策略 33810.2.3 调用代理方法 34110.2.4 触发通知 347第11章一步一步手绘Spring MVC运行时序图 352 11.1 初探Spring MVC请求处理流程 35211.2 Spring MVC九大组件 35311.2.1 HandlerMapping 35311.2.2 HandlerAdapter 35311.2.3 HandlerExceptionResolver 354 11.2.4 ViewResolver 35411.2.5 RequestToViewNameTranslator 354 11.2.6 LocaleResolver 35411.2.7 ThemeResolver 35511.2.8 MultipartResolver 35511.2.9 FlashMapManager 35511.3 Spring MVC源码分析 35511.3.1 初始化阶段 35611.3.2 运行调用阶段 35911.4 Spring MVC优化建议 367第4篇 Spring手写实战第12章环境准备 37012.1 IDEA集成Lombok插件 37012.1.1 安装插件 37012.1.2 配置注解处理器 37312.1.3 使用插件 37412.2 从Servlet到ApplicationContext 375 12.3 准备基础配置37612.3.1 application.properties配置.377 12.3.2 pom.xml配置 37712.3.3 web.xml配置 37812.3.4 GPDispatcherServlet 378第13章 IoC顶层结构设计 38013.1 Annotation（自定义配置）模块 380 13.1.1 @GPService 38013.1.2 @GPAutowired 38113.1.3 @GPController 38113.1.4 @GPRequestMapping 38213.1.5 @GPRequestParam 38213.2 core（顶层接口）模块 38213.2.1 GPFactoryBean 38213.2.2 GPBeanFactory 38313.3 beans（配置封装）模块 38313.3.1 GPBeanDefinition 38313.3.2 GPBeanWrapper 38413.4 context（IoC容器）模块 38513.4.1 GPAbstractApplicationContext 385 13.4.2 GPDefaultListableBeanFactory 385 13.4.3 GPApplicationContext38513.4.4 GPBeanDefinitionReader 38813.4.5 GPApplicationContextAware 391第14章完成DI模块的功能 39214.1 从getBean()方法开始 39314.2 GPBeanPostProcessor 395第15章完成MVC模块的功能 39615.1 MVC顶层设计 39615.1.1 GPDispatcherServlet 39615.1.2 GPHandlerMapping 40215.1.3 GPHandlerAdapter 40315.1.4 GPModelAndView 40615.1.5 GPViewResolver 40615.1.6 GPView 40715.2 业务代码实现40915.2.1 IQueryService 40915.2.2 QueryService 41015.2.3 IModifyService 41015.2.4 ModifyService 41115.2.5 MyAction 41215.2.6 PageAction 41315.3 定制模板页面41415.3.1 first.html 41415.3.2 404.html 41415.3.3 500.html 41515.4 运行效果演示415第16章完成AOP代码织入 417 16.1 基础配置 .41716.2 完成AOP顶层设计 41816.2.1 GPJoinPoint 41816.2.2 GPMethodInterceptor .419 16.2.3 GPAopConfig 41916.2.4 GPAdvisedSupport 420 16.2.5 GPAopProxy 42216.2.6 GPCglibAopProxy 42316.2.7 GPJdkDynamicAopProxy 423 16.2.8 GPMethodInvocation425 16.3 设计AOP基础实现 42716.3.1 GPAdvice 42716.3.2 GPAbstractAspectJAdvice 427 16.3.3 GPMethodBeforeAdvice 428 16.3.4 GPAfterReturningAdvice 429 16.3.5 GPAfterThrowingAdvice 430 16.3.6 接入getBean()方法 43016.4 织入业务代码43216.4.1 LogAspect 43216.4.2 IModifyService 43316.4.3 ModifyService 43416.5 运行效果演示435第5篇 Spring数据访问第17章数据库事务原理详解 438 17.1 从Spring事务配置说起 438 17.2 事务的基本概念 43917.3 事务的基本原理 43917.4 Spring事务的传播属性 440 17.5 数据库事务隔离级别 44117.6 Spring中的事务隔离级别 441 17.7 事务的嵌套 44217.8 Spring事务API架构图 44417.9 浅谈分布式事务 444第18章 Spring JDBC源码初探 44618.1 异常处理 44718.2 config模块 44818.3 core模块45018.4 DataSource 45618.5 object模块 45718.6 JdbcTemplate 45818.7 NamedParameterJdbcTemplate 458第19章基于Spring JDBC手写ORM框架 459 19.1 实现思路概述45919.1.1 从ResultSet说起 45919.1.2 为什么需要ORM框架 46419.2 搭建基础架构46719.2.1 Page 46719.2.2 ResultMsg 47019.2.3 BaseDao 47119.2.4 QueryRule 47319.2.5 Order.47919.3 基于Spring JDBC实现关键功能 480 19.3.1 ClassMappings 48019.3.2 EntityOperation 48319.3.3 QueryRuleSqlBuilder 48819.3.4 BaseDaoSupport 49819.4 动态数据源切换的底层原理 50719.4.1 DynamicDataSource 50819.4.2 DynamicDataSourceEntry 50919.5 运行效果演示51019.5.1 创建Member实体类 51019.5.2 创建Order实体类 51119.5.3 创建MemberDao 51219.5.4 创建OrderDao 51219.5.5 修改db.properties文件 51419.5.6 修改application-db.xml文件 515 19.5.7 编写测试用例 516第6篇 Spring经验分享第20章 Spring 5新特性总结 52020.1 升级到Java SE 8和Java EE 7 520 20.2 反应式编程模型 52120.3 使用注解进行编程 52120.4 函数式编程 52220.5 使用 REST 端点执行反应式编程 52320.6 支持HTTP/2 52320.7 Kotlin和Spring WebFlux 52320.8 使用Lambda表达式注册Bean 52420.9 Spring Web MVC 支持最新的 API 52420.10 使用JUnit 5执行条件和并发测试 52520.11 包清理和弃用 52620.12 Spring核心和容器的一般更新 52620.13 我如何看Spring 5 527第21章关于Spring的经典高频面试题 52821.1 什么是Spring框架，Spring框架有哪些主要模块52821.2 使用Spring框架能带来哪些好处 52821.3 什么是控制反转（IoC），什么是依赖注入 52921.4 在Java中依赖注入有哪些方式 52921.5 BeanFactory和ApplicationContext有什么区别 530 21.6 Spring提供几种配置方式来设置元数据 53021.7 如何使用XML配置方式配置Spring .53121.8 Spring提供哪些配置形式 53221.9 怎样用注解的方式配置Spring 53321.10 请解释Spring Bean的生命周期 53421.11 Spring Bean作用域的区别是什么 53521.12 什么是Spring Inner Bean 53521.13 Spring中的单例Bean是线程安全的吗 53621.14 请举例说明如何在Spring中注入一个Java集合 53621.15 如何向Spring Bean中注入java.util.Properties 53721.16 请解释Spring Bean的自动装配 53821.17 自动装配有哪些局限性 53821.18 请解释各种自动装配模式的区别 53921.19 请举例解释@Required注解 53921.20 请举例说明@Qualifier注解 54021.21 构造方法注入和设值注入有什么区别 54021.22 Spring中有哪些不同类型的事件 54121.23 和ClassPathResource有什么区别 54221.24 Spring中用到了哪些设计模式 54221.25 在Spring中如何更有效地使用JDBC 54321.26 请解释Spring中的IoC容器 54321.27 在Spring中可以注入null或空字符串吗 543Spring5核心原理与30个类手写实战介绍1996年，Java还只是一个新兴的、初出茅庐的编程语言。
电气控制与PLC(音乐喷泉)综合训练 任务书及答案
学生姓名
学号
专业方向
班级
题目名称
花式喷泉控制系统的PLC控制
一、控制要求
喷泉由中间的大喷泉和旁边两个小喷泉组成，其中小喷泉只有一格喷头，大喷泉由1号中间喷头，2号、3号、4号环形喷头组成。花式喷泉控制系统的示意图如下图所示。
工作流程：
⑴小喷泉工作方式：喷泉装置启动后，开始喷水，直到按下停止按钮；
⑹PLC控制系统设计，绘制PLC的I/O接线图和I/O配制表；
⑺编写梯形图程序和程序说明；
⑻总结及体会；
⑼参考文献；
⑽附录（含所有图纸、程序、器件清单及需要专门说明或论述的问题）。
五、设计进度
⑴明确实训任务、收集查阅资料，第1天；
⑵电气原理图设计和电气设备选择，第2~3天；
⑶PLC控制系统设计，第4~5天；
⑷编写梯形图程序和程序说明，第6~8天；
⑸调试程序，第9~11天；
⑹编写实训设计报告，第12~14天；
⑺实训设计准备及答辩，第15天。
六、参考资料
⑴何波主编.电气控制及PLC应用[M].北京：中国电力出版社，2008
⑵钟肇薪主编.可编控制器原理及应用（第2版）[M].广州：华南理工大学出版社，2008
二、技术参数和数据
⑴电源：三相、交流380V/50HZ
⑵水泵电机：容量为7.5kW、电压为交流380V
⑶大小喷泉阀门：线圈电压为交流220V、吸合功率480W/保持功率120W
三、实训任务和设计内容
⑴分析花式喷泉的工作过程，明确被控对象，绘制花式喷泉控制系统的电气原理图，并对所用的电气元件进行选型；
⑶任振辉主编.电气控制与PLC原理及应用[M].北京：水利水电出版社，2008
实验一
实验一Spring环境配置一、实验目的1、掌握Spring框架的基本结构；2、掌握Spring框架的基本用法；3、掌握Spring配置文件的编写方法；4、理解Spring框架中IOC、DI、容器等核心概念。
二、实验要求1、根据实验步骤中提出的要求，使用Eclipse编写相应的Java程序；2、根据实验步骤中提出的要求，使用Eclipse编译、运行自己所编写的Java程序；3、根据编译与运行过程中所获得的错误信息修改程序直至获得正确的结果；4、记录实验中遇到的各类问题并以及解决办法。
三、实验步骤1、准备工作（1）安装Java JDK与Eclipse开发工具；（2）在任意路径下创建springframework文件夹，然后在该文件夹之下再创建spring与dependency子文件夹；（3）下载Spring框架jar包及其依赖jar包，并将这些jar包分别拷入spring与dependency子文件夹中；（4）启动Eclipse并选择Window —Preferences打开Preferences对话框窗口；选择Java —Build Path —User Libraries 打开User Libraries选项页；在该选项页中新建（New …）两个User Library，一个名为spring，另一个名为dependency，然后分别将Spring框架jar包及其依赖jar包加入（AddJARs …）其内；2、类之间的依赖与耦合（1）假设你在编写一个游戏，游戏中有一个“骑士”角色，骑士需要去完成各种各样的任务，如“营救行动”、“圆桌任务”、“屠龙任务”等等，那么你应该如何去设计骑士类以及这些任务类？（2）写出你的解决方案，并设计一个主类说明这个过程。
（以下给出了部分参考代码，请在其基础上完成）//任务接口public interface Task {void perform();}//骑士类public abstract class Knight {protected String name;protected Task task;public void setTask(Task task) {this.task = task;}public Knight(String name){=name;}public abstract void performTask();}//主类public class BraveKnightMain {public static void main(String[] args) {Task task = new RescueTask("Tom");BraveKnight knight = new BraveKnight("Jerry");knight.setTask(task);knight.performTask();}}3、Spring框架的使用（1）在Eclipse中创建Java工程，工程名为helloapp；（2）在工程上右击右键并选择Properties，弹出工程属性对话框；在对话框中选择Java Build Path —Libraries；使用Add Libraries添加在第1步中所创建的两个User Library，即spring与dependency；（3）在工程中编写以下类以及Spring配置文件；package springlab.hello;public interface Hello {public void sayHello();}package springlab.hello;public class HelloBean implements Hello{private String someone;private String title;private String greetings;public void setGreetings(String greetings) {this.greetings = greetings;}public HelloBean(String title,String someone){this.title = title;this.someone=someone;}public void sayHello() {System.out.println(greetings+", "+title+" "+someone + "!");}}package springlab.hello;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class HelloApp {public static void main(String args[]){ApplicationContext context =new ClassPathXmlApplicationContext("hellospring.xml");Hello hello = (Hello)context.getBean("hello");hello.sayHello();}}<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd"><bean id="hello" class="springlab.hello.HelloBean"><constructor-arg value="Mr." /><constructor-arg value="Lee" /><property name="greetings" value="Good morning"/></bean></beans>（4）上面的XML文件名应是什么？程序的运行结果是什么？如何修改使其输出为“Hello, Miss Green！”4、IOC与DI（1）请指出第2步中的代码有哪些依赖？（2）什么是IOC与DI？（3）请指出第3步中的spring配置文件中使用哪两种注入方式？它们分别会调用什么方法？（4）如何利用Spring中提供依赖注入方式将第2步中的各个类进行解耦？请参照第3步实现，并注意，如果属性是对象的引用请将Spring配置文件中的value改为ref。
项目SOW(工作任务书)模板
项目SOW(工作任务书)模板1.项目背景2.项目目的3.项目范围4.项目计划5.项目资源6.风险管理7.项目交付8.项目验收9.项目总结1.项目背景本项目旨在开发一款新型智能家居产品，以满足现代人们对高品质生活的需求。
随着科技的不断发展，智能家居已经成为人们生活中不可或缺的一部分。
然而，现有的智能家居产品在功能和使用体验方面仍存在一些问题。
因此，本项目的开发将致力于解决这些问题，提供更加智能、便捷和舒适的生活体验。
2.项目目的本项目的目的是开发一款功能全面、易于使用、具有智能化特点的智能家居产品。
该产品将通过智能控制系统，实现家居设备的自动化控制和远程控制，提高生活的便利性和舒适度。
同时，该产品还将具备智能化的安全保护功能，保障用户的家庭安全。
3.项目范围本项目的范围包括智能家居产品的设计、开发、测试和推广等全过程。
具体包括以下方面：硬件设计和制造：包括各种传感器、控制器、执行器等硬件设备的设计和制造。
软件开发：包括智能控制系统、远程控制应用程序等软件的开发和测试。
产品测试和优化：对产品进行实验室测试和用户体验测试，不断优化产品的性能和功能。
推广和销售：通过各种渠道推广产品，并与销售渠道建立合作关系，提高产品的知名度和销售量。
4.项目计划本项目的计划包括以下阶段：立项和需求分析阶段：确定项目目标和需求，制定项目计划。
设计和开发阶段：进行硬件和软件的设计和开发，完成产品的制造和测试。
推广和销售阶段：通过各种渠道推广产品，并与销售渠道建立合作关系，提高产品的知名度和销售量。
5.项目资源本项目需要的资源包括：人力资源：项目经理、硬件工程师、软件工程师、测试工程师等。
物资资源：各种传感器、控制器、执行器等硬件设备。
财务资源：项目资金和预算。
6.风险管理本项目的风险主要包括技术风险、市场风险和财务风险等。
项目团队将采取有效措施，对各种风险进行识别、评估和管理，确保项目的顺利进行。
7.项目交付本项目的交付包括以下内容：智能家居产品的硬件和软件。
Spring框架基础与实战练习题参考答案
Spring框架基础与实战练习题参考答案Spring框架作为一个轻量级的开发框架，具有强大的功能和灵活性，已广泛应用于企业级应用程序的开发中。
下面是一些关于Spring框架的基础与实战练习题的参考答案，希望能帮助你更好地理解和掌握Spring框架。
1. 什么是Spring框架？Spring框架是一个开源的Java平台，用于开发企业级应用程序。
它提供了一系列的功能模块和API，用于处理应用程序的不同方面，如依赖注入、AOP（面向切面编程）、事务管理等。
Spring框架使得应用程序的开发更加简单、高效和可测试。
2. Spring框架的核心功能有哪些？Spring框架的核心功能包括：- 依赖注入（Dependency Injection）：通过配置文件或注解方式将依赖关系注入到对象中，解耦了各个组件之间的依赖。
- AOP（Aspect-Oriented Programming）：通过切面的方式将横切逻辑（如日志、事务管理等）与核心业务逻辑分离开来，提高代码的可维护性和可重用性。
- 面向接口编程：通过接口来定义服务和业务逻辑，提高代码的灵活性和可扩展性。
- 数据访问：提供了对数据库访问的支持，如JDBC、ORM（对象关系映射）等。
- Web开发：提供了对各种Web开发框架的支持，如Spring MVC、Spring Boot等。
3. 请解释一下Spring框架中的依赖注入（DI）是什么意思？依赖注入是Spring框架的核心特性之一。
它指的是将对象之间的依赖关系由框架来处理，而不是由开发人员手动管理。
通过依赖注入，我们可以将对象之间的依赖关系配置到外部的配置文件或通过注解的方式，使得代码更加简洁和可维护。
4. 举例说明Spring框架中的依赖注入（DI）是如何实现的。
例如，我们有一个UserService接口和一个UserDao接口，UserService接口依赖于UserDao接口。
在Spring框架中，我们可以通过以下方式进行依赖注入：首先，在配置文件中定义Bean：```xml<bean id="userDao" class="erDaoImpl" /><bean id="userService" class="erServiceImpl"><property name="userDao" ref="userDao" /></bean>```然后，在UserService的实现类中注入UserDao：```javapublic class UserServiceImpl implements UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {erDao = userDao;}//...}```这样，我们就将UserService依赖的UserDao通过配置文件进行了注入。
C语言课程设计任务书(18份)详细版
C语言课程设计任务书详细版（18份）C语言课程设计任务书1题目：某学院教学信息管理系统功能：1、每一条记录包括一位教师的职工号、姓名、职称、性别、3门主讲课程（课程名称、开课学期、课程性质（学位与非学位课）和教学效果），教学效果综合评分。
2、输入功能：可以一次完成若干条记录的输入。
3、显示功能：完成全部教师记录的显示。
4、查找功能：完成按姓名或课程查找教师的相关记录，并显示。
5、排序功能：按职工号或教学效果综合评分进行排序。
6、插入功能：按教学效果综合评分高低插入一条教师记录。
7、将教师记录存在文件中。
8、应提供一个界面来调用各个功能,调用界面和各个功能的操作界面应尽可能清晰美观!要求：1、用C语言实现系统；2、利用结构体数组实现教学信息的数据结构设计；3、系统具有增加，查询，插入，排序等基本功能；4、系统的各个功能模块要求用函数的形式实现；5、将教学信息存在文件中。
课程设计的最后成果是实验报告一份，内容包括：1、预习报告（题目、流程图、程序的设计思想等）；2、实验总结报告（测试方案、源程序代码（需打印）、调试中问题及解决方案、小结等）。
C语言课程设计任务书2题目：酒店房间登记与计费管理系统功能：1、屏幕上出现一个界面，让操作员能够方便的选择所需要进行的操作，包括登记入住、查询房间的入住情况、查询当前费用、结账退房等操作。
2、对不同标准的房间实施不同的收费标准，也可以按天收费或按小时收费，可根据顾客需要在登记的入住的时候进行选择。
3、在结账退房时，根据入住的时间，计费方式和房间单价计算出总费用。
分步实施：1、初步完成总体设计，搭好框架，确定人机对话的界面，确定函数个数；2、完成最低要求：建立房间列表，完成登记入住、查询房间入住情况功能。
3、进一步要求：完成计费和费用查询功能。
要求：1、用C语言实现系统；2、函数功能要划分好（结构化程序设计）；3、界面友好（良好的人机交互），加必要的注释；4、要提供程序测试方案，程序一定要经得起测试，宁可功能少一些，也要能运行起来，不能运行的程序是没有价值的。
Spring框架参考文档-5.0.0-中文完整版
Spring框架参考文档-5.0.0-中文完整版AuthorsRod Johnson , Juergen Hoeller , Keith Donald , Colin Sampaleanu , Rob Harrop , Thomas Risberg , Alef Arendsen , Darren Davison , Dmitriy Kopylenko , Mark Pollack , Thierry Templier , Erwin Vervaet , Portia Tung , Ben Hale , Adrian Colyer , John Lewis , Costin Leau , Mark Fisher , Sam Brannen , Ramnivas Laddad , Arjen Poutsma , Chris Beams , Tareq Abedrabbo , Andy Clement , Dave Syer , Oliver Gierke , Rossen Stoyanchev , Phillip Webb , Rob Winch , Brian Clozel , Stephane Nicoll , Sebastien Deleuze版本号：5.0.0.RELEASECopyright ? 2004-2016Copies of this document may be made for your own use and for distribution to others, provided that you do not charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether distributed in print or electronically.文档官网：https://docs.spring.io/spring/docs/5.0.0.RELEASE/spring-framework-reference/index.html现在官网的5.0.0已经在2017年9月28日出了release版，为此翻译了5.0.0版本（从4.3.10升级到此版本，如果还在使用4.3.10版本，请看本人的前一个版本），翻译前后历时15天，十多次的修改和校对。
C语言程序设计实训指导书1
重庆正大软件职业技术学院《C语言程序设计》实验（上机）指导书作者：杨业令时间：2008-2版本：V1.0目录实验名称一：C语言程序设计工具的使用 (3)实验名称二：数据类型、定义及赋值 (5)实验名称三：运算符和表达式 (7)验名称四：顺序程序设计 (9)实验名称五：表达式 (12)实验名称六：if语句和switch语句 (14)实验名称七：goto语句和while循环 (16)实验名称八：for循环 (19)实验名称九：一维数组 (22)实验名称十：二维数组与字符数组 (24)实验名称十一：函数 (27)实验名称十二：指针 (30)实验名称十三：指针 (32)实验名称一：C语言程序设计工具的使用一、实验编号：Zb3140094.01二、实验名称：C语言程序设计工具的使用三、课时：2学时四、实验目的：掌握C语言程序设计工具Turboc的使用方法、熟悉C语言程序的操作。
掌握程序的编译过程。
五、实验环境：个人电脑一台、Turboc编译软件。
六、预备知识：需要有C语言的基础知识、C语言的特点。
七、实验内容（步骤）：练习一：#include<math.h>#include<stdio.h>main(){double x,s;printf("input number:\n");scanf("%lf",&x);s=sin(x);printf("sine of %lf is %lf\n",x,s);}练习二：include <stdio.h>void main(){float a,b,c,max=0.0,min=0.0;printf("请输入三个整数:");scanf("%f%f%f",&a,&b,&c);if(a>b){max=a;if(max<c)max=c;};if(a<b){min=a;if(min>c)min=c;};printf("三个数最大的是：%f;\n最小的是：%f\n",max,min);}八、实验要求：熟悉C语言操作环境九、考核标准：是否完成了教材的例子和课后的练习实验名称二：数据类型、定义及赋值一、实验编号：Zb3140094.03二、实验名称：数据类型、定义及赋值三、课时：2学时四、实验目的：理解常量、变量，掌握数据类型的表示及转换。
编译原理作业集-第一章-修订版
第一章引论本章要点：1. 正确理解什么是编译程序；2. 了解编译程序工作的基本过程及各阶段的基本任务；3. 熟悉编译程序的总体结构框图；4. 了解编译程序的构造过程和构造工具。
本章目标：1. 掌握本章的“编译程序”、“交叉编译程序”、“编译前端与编译后端”等基本概念，并能在以后的学习熟练运用；2. 掌握T形图表示。
本章重点：1. 概念比较:①编译程序、解释程序；②诊断编译程序、优化编译程序；③交叉编译程序、可变目标编译程序；④编译前端与编译后端；2. 编译工作过程的五个阶段；3. 编译程序总框；4. 编译程序“移植”。
本章难点1. 编译程序“移植”；作业题及参考答案一、单项选择题：（按照组卷方案，至少8道小题）1. 如果一个编译程序能产生不同于其宿主机的机器代码，则称它为：。
a. 诊断编译程序b. 优化编译程序c. 交叉编译程序d. 可变目标编译程序2. 编译程序将高级语言程序翻译成。
a. 机器语言程序或高级语言程序b. 汇编语言或机器语言程序c. 汇编语言程序或高级语言程序d. 中间语言程序或高级语言程序3. 下面的四个选项中，__________不是编译程序的组成部分。
a. 词法分析程序b. 代码生成程序c. 设备管理程序d. 语法分析程序4. 现代多数实用编译程序所产生的目标代码都是一种可重定位的指令代码，在运行前必须借助于一个把各个目标模块，包括系统提供的库模块连接在一起，确定程序变量或常数在主存中的位置，装入内存中制定的起始地址，使之成为一个可运行的绝对指令代码的程序。
a. 重定位程序；b. 解释程序；c. 连接装配程序；d. 诊断程序；5. 从编译程序的角度说，源程序中的错误通常分为两大类。
a. 词法错误和语法错误；b. 语法错误和语义错误；c. 编辑错误和诊断错误；d. 词法错误和语义错误；6. 下面对编译原理的有关概念正确描述的是：。
a. 目标语言只能是机器语言b. 编译程序处理的对象是源语言。
《C++程序设计》大作业 计网(2014-12)
软件学院大作业任务书课程名称：C++程序设计题目：C++语言综合编程训练专业：计算机网络技术班级：计网142学号：8001614046学生姓名：肖旭臻完成人数： 1起讫日期：2014.12.25~2015.1.10任课教师：李荣鑫职称：部分管主任：完成时间：2015.1.6说明1.本任务书由任课教师填写后，下达到学生。
2.任务完成后，任课教师需填写小结表。
3.任务书、学生成绩与学生完成后的大作业（纸质和电子两种）一并报送各教学研究部审核后转教务办。
4.另附一份全班大作业总结《C++程序设计》编程试题1. 从键盘输入一个圆柱体的半径R 和高H ，计算并输入圆柱体的体积V 。
2. 编写程序，输入一个百分制的成绩，要求输出其对应的等级：90分以上为“优秀”，80~89分为“良好”，70~79为“中等”，60~69为“及格”，60以下为“不及格”。
3. 编写程序，输出一个由*号组成的等腰三角形。
行数n 从键盘输入。
4. 计算S=∑=201!n n (即计算20以内阶乘的和)。
5. 输入两个正整数m 和n ，求其最大公约数和最小公倍数。
6. 打印出所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。
例如：153是一个“水仙花数”，因为153=1的立方＋5的立方＋3的立方。
7. 编写一个判断素数的函数，函数原型为: int IsPrime(int n),要求在主函数中调用该函数，分别实现以下功能：1）输出100~200之间所有素数的和。
2）验证哥德巴赫猜想：任意大的偶数可以分解为两个素数之和。
8. 用递归算法实现函数：int sum( int n ); 其功能是求 1+2+3+…+n 的值并返回。
要求编写主函数main()去调用递归函数sum()。
9. 编写一个计算sin(x)的函数，在主函数中输入x ，调用sin(x)函数计算并输出y 值。
y=)!12()1(!7!5!31sin )12(1753--+-+-=-+n x x x x x x n n 要求：在sin(x)函数内，将级数中各项值累加到和变量s 中去，直到最后一项绝对值小于0.00001为止。
实验4 Spring使用基础
实验4 Spring开发基础一、实验目的1.掌握Spring框架的概念、特点及结构。
2.学会利用MyEclipse开发Spring的过程和方法。
3.熟悉applicationContext.xml配置bean的方法。
4.掌握Spring框架的核心技术IoC（DI）、AOP。
二、实验步骤1.运行MyEclipse建立Web Project（File→New→Web Project），项目名称为ex1，如下图所示，单击Finish按钮完成项目创建。
2.右击项目名ex1，在快捷菜单中选择MyEclipse→Project Facets→InstallSpring Facet，单击Finish按钮，完成配置。
3.通过这些步骤，项目中增加了Spring 3.1.1库，项目src文件夹下添加了applicationContext.xml的配置文件。
请查看这些改变。
4.在项目的src文件夹下面建立test包，在该包下面建立Person接口，内含go方法，再建立类Student和Teacher，分别实现Person接口，代码如下：5.在applicationContext.xml中添加如下两个bean的定义：6.在包test中建立Test类，从应用程序上下文中获得对象，并调用对象方法，其中main方法的代码如下：7.运行主类Test，观察并分析运行结果。
8.通过Set方法注入依赖。
修改Student类和Teacher类，分别在其中添加私有字符串属性name和set、get方法（设置姓名，自动生成set、get方法）,Teacher 类可以不要getName方法，修改go方法，在输出原有字符串前增加name的输出，代码如下：9.修改applicationContext.xml中的两个bean元素，设置name属性值，修改如下：10.再次运行主类Test，观察并分析运行结果。
11.引用其他bean，在Spring容器中将bean注入需要调用的实例。
Java语言课程设计任务书及题目 (2)
Java语言课程设计任务书及题目一、设计目的及要求1.目的(1)复习、巩固Java语言的基础知识，进一步加深对Java语言的理解和掌握。
(2)熟悉JA V A开发环境，掌握JA V A程序的编译和运行；掌握JA V A基本编程技术和方法；掌握GUI图形界面编程技术；了解异常处理机制。
(3)课程设计为学生提供了一个既动手又动脑，独立实践的机会，将课本上的理论知识和实际有机的结合起来，锻炼学生的分析解决实际问题的能力。
提高学生适应实际，实践编程的能力。
(4)培养学生在项目开发中团队合作精神、创新意识及能力。
2.要求(1)对系统进行需求分析及可行性分析系统实现的目的，项目开发的背景，系统要达到的目标，开发系统所用的开发环境，预期使用的用户等。
(2)对系统进行总体设计、分析系统的功能结构模块，并给出系统的功能结构图，分析系统的数据流程图，并给出系统的数据流程图，设计要符合课题要求，实现相应功能；可以加以其他功能或修饰，使程序更加完善、合理。
(3)详细设计：①分析系统实体，画出每个实体的E-R图；②设计所需的数据表，给出所需数据表的字段名称，数据类型，字符长度，字段说明，约束条件；③编码实现每个子功能模块，并进行测试。
(4)系统总结。
3.其它(1)标识符命名遵循命名规范，代码多加注释。
(2)注意各种可能遇到的异常处理，注重提高程序运行效率。
(3)系统设计要实用，编程简练，可用，功能全面。
(4)尽量使用图形界面实现，要符合日常软件使用规范来设计菜单和界面。
(5)说明书、流程图要清楚。
(6)记录设计情况备查，也为编写设计说明书作好准备。
(7)要求采用模块化程序设计方法，及锯齿型书写格式缩进格式，要求上机调试通过和按设计报告格式。
(8)上传课程设计软件代码、课程设计报告，并刻录成光盘交老师保存。
每人上传上述内容的压缩包，文件名形如“2008813018张三.rar”(学号加姓名组成)，光盘也一样，由学习委员统一集中刻录。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
编译系统设计综合训练
实验学时：16学时
适用班级：软件31、32、33、34班
主要内容：实现一个“程序设计语言子集”的编译系统，包括：词法分析、语法分析、语义分析、符号表、出错处理等。
1) 语言成分：
(1) 数据类型：整型、实型、字符型、布尔型；
(2) 简单变量；
(3) 算术表达式（+、++、-、--、×）；
(4) 布尔表达式（∧、∨、┐）；
(5) 语句：
a) 赋值语句（含数组元素引用）；
b) 分支语句（if-then、if-then-else、case）；
c) 循环语句（while-do）；
d) 过程调用语句；
e) 定义语句等。
2) 输入方式：文本文件（如：.txt）。
3) 输出内容：
(1) 如果输入串是合法的程序段，则输出相应中间代码、符号表等相关信息；
(2) 如果输入串是非法的程序段，则指出错误位置及错误原因（如词法错、语
法错、语义错等）。
4) 输出方式：除直接在监视器上显示结果之外，还应将结果输出到文件中。
提交结果：
1) 编译系统设计综合训练报告（电子版+打印版）
包括：该程序设计语言文法的形式化描述（BNF范式）；单词种别定义；程序；
关键算法的文字解释；测试样例（输入、输出）；综合训练总结。
2) 可正确执行的程序。
强调：。