編譯原理課程設計怎麼寫

『壹』 急（高懸賞 幫個忙） 求編譯原理課程設計---c語言實現c-的語法分析，在線等

新建一個文本文檔在你工程目錄下，名字起為"輸入.txt",裡面的內容可以為
begin a:=1+7*(6+3);b:=1end#

輸出是在"輸出.txt"中查看，以下為輸出情況：

詞法分析結果如下:
(1, begin)
(10, a)
(18, :=)
(11, 1)
(13, +)
(11, 7)
(15, *)
(27, ()
(11, 6)
(13, +)
(11, 3)
(28, ))
(26, ;)
(10, b)
(18, :=)
(11, 1)
(6, end)
(0, #)
語法分析結果如下:（以四元式形式輸出）
( +, 6, 3, t1)

( *, 7, t1, t2)

( +, 1, t2, t3)

( =, t3, __, a)

( =, 1, __, b)

//提供一個編譯原理的語義分析程序 你可以直接復制 用TC進行調試
#include "stdio.h"
#include "string.h"
#include <malloc.h>
#include <conio.h>
#include "stdlib.h"

char prog[100],token[8],ch;
char *rwtab[6]={"begin","if","then","while","do","end"};
int syn,p,m,n,sum,q;
int kk;
//四元式表的結構如下：
struct
{
char result1[8];
char ag11[8];
char op1[8];
char ag21[8];
}quad[20];

char *factor();
char *expression();
int yucu();
char *term();
int statement();
int lrparser();
char *newtemp();
void scaner();
void emit(char *result,char *ag1,char *op,char *ag2);

void main()
{
FILE *fp1,*fp2;

if((fp1=fopen("輸入.txt","rt"))==NULL)
{
printf("Cannot open 輸入.txt\n");
getch();
exit(1);
}
if((fp2=fopen("輸出.txt","wt+"))==NULL)
{
printf("Cannot create 輸出.txt FILE.strike any key exit");
getch();
exit(1);
}

int j;
q=p=kk=0;
p=0;
//printf("Please Input a String(end with '#'):\n");
while(ch!='#')
{
ch = fgetc(fp1);
if(ch == EOF)
{
printf("文件為空，請檢查後再嘗試!");
return ;
}

prog[p++]=ch;
}
if(prog[p]=='#')
{
printf("輸入的待分析的串不是以'#'結尾,請修改之後再嘗試!\n");
return;
}
p=0;
char buffer1[200] = {0};
sprintf(buffer1,"詞法分析結果如下:\n");
fputs(buffer1,fp2);
//printf("詞法分析結果如下:\n");
do
{
scaner();
switch(syn)
{
case 11:
//printf("(%d,%d)\n",syn,sum);
sprintf(buffer1,"(%d, %d) \n",syn,sum);
fputs(buffer1,fp2);
break;
default:
//printf("(%d,%s)\n",syn,token);
sprintf(buffer1,"(%d, %s)\n",syn,token);
fputs(buffer1,fp2);
break;
}
}while(syn!=0);
printf("\n");

p=0;
char buffer[200]={0};
sprintf(buffer,"語法分析結果如下:（以四元式形式輸出）\n");
fputs(buffer,fp2);
//printf("語法分析結果如下:（以四元式形式輸出）\n");
scaner();//掃描函數
lrparser();
if(q>19)
printf(" to long sentense!\n");
else
{

for (j=0;j<q;j++)
{
//printf("( %s, %s, %s, %s) \n\n",quad[j].op1,quad[j].ag11,quad[j].ag21,quad[j].result1);
sprintf(buffer,"( %s, %s, %s, %s) \n\n",quad[j].op1,quad[j].ag11,quad[j].ag21,quad[j].result1);
fputs(buffer,fp2);
}
}
printf("已把相應的詞法和語法的結果保存到相應的文件中，請查閱!\n");
fclose(fp1);
fclose(fp2);
}
int lrparser()
{
int schain=0;
kk=0;
if (syn==1) //得到begin
{
scaner();//掃描下個字元
schain=yucu();
if(syn==6)//得到end
{
scaner();//掃描下個字元
if((syn==0)&&(kk==0)) //得到#
printf("Success!\n");
}
else
{
if(kk!=1)
printf("short of 'end' !\n");
kk=1;
getch();
exit(0);
}
}
else
{
printf("short of 'begin' !\n");
kk=1;
getch();
exit(0);
}
return (schain);
}
int yucu()
{
int schain=0;
schain=statement();
while(syn==26)
{
scaner();
schain=statement();
}
return (schain);
}
int statement()
{
char tt[8],eplace[8];
int schain=0;
if (syn==10)
{
strcpy(tt,token); //tt中保存的是第一個字元
scaner();
if(syn==18) //檢測到=號
{
scaner();
strcpy(eplace,expression());
emit(tt,eplace,"=","__");
schain=0;
}
else
{
printf("short of sign ':=' !\n");
kk=1;
getch();
exit(0);
}
return (schain);
}
}
char *expression()
{
char *tp,*ep2,*eplace,*tt;
tp=(char *)malloc(12);
ep2=(char *)malloc(12);
eplace=(char *)malloc(12);
tt=(char *)malloc(12);

strcpy(eplace,term());

while((syn==13)||(syn==14))
{
if (syn==13)
strcpy(tt,"+");
else
strcpy(tt,"-");

scaner();
strcpy(ep2,term());
strcpy(tp,newtemp());
emit(tp,eplace,tt,ep2);
strcpy(eplace,tp);
}
return (eplace);
}
char *term()
{
char *tp,*ep2,*eplace,*tt;
tp=(char *)malloc(12);
ep2=(char *)malloc(12);
eplace=(char *)malloc(12);
tt=(char *)malloc(12);

strcpy(eplace,factor());

while((syn==15)||(syn==16))
{
if (syn==15)
strcpy(tt,"*");
else
strcpy(tt,"/");
scaner();
strcpy(ep2,factor());
strcpy(tp,newtemp());
emit(tp,eplace,tt,ep2);
strcpy(eplace,tp);
}
return (eplace);
}
char *factor()
{
char *fplace;
fplace=(char *)malloc(12);
strcpy(fplace,"");

if(syn==10) //得到字元
{
strcpy(fplace,token);
scaner();
}
else if(syn==11) //得到數字
{
itoa(sum,fplace,10);
scaner();
}
else if(syn==27) //得到)
{
scaner();
fplace=expression();
if(syn==28) //得到(
scaner();
else
{
printf("error on ')' !\n");
kk=1;
getch();
exit(0);
}
}
else
{
printf("error on '(' !\n");
kk=1;
getch();
exit(0);
}
return (fplace);
}
//該函數回送一個新的臨時變數名，臨時變數名產生的順序為T1,T2...
char *newtemp()
{
char *p;
char m[8];
p=(char *)malloc(8);

kk++;
itoa(kk,m,10);
strcpy(p+1,m);
p[0]='t';
return(p); //設置中間變數名放在一個字元數組中，字元數組的第一個字元為t第二個字元為m表示的數值
}
void scaner()
{
sum=0;
///for(m=0;m<8;m++)
//token[m++]=NULL;
memset(token,0,8);
m=0;
ch=prog[p++];
while(ch==' ')
ch=prog[p++];
if(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A')))
{
while(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A'))||((ch>='0')&&(ch<='9')))
{
token[m++]=ch;
ch=prog[p++];
}
p--;
syn=10;
token[m++]='\0';
for(n=0;n<6;n++)
if(strcmp(token,rwtab[n])==0)
{
syn=n+1;
break;
}
}
else if((ch>='0')&&(ch<='9'))
{
while((ch>='0')&&(ch<='9'))
{
sum=sum*10+ch-'0';
ch=prog[p++];
}
p--;
syn=11;
}
else switch(ch)
{
case '<':m=0;
ch=prog[p++];
if(ch=='>')
{
syn=21;
}
else if(ch=='=')
{
syn=22;
}
else
{
syn=20;
p--;
}
break;
case '>':m=0;
ch=prog[p++];
if(ch=='=')
{
syn=24;
}
else
{
syn=23;
p--;
}
break;
case ':':m=0;
token[m++] = ch;
ch=prog[p++];
if(ch=='=')
{
syn=18;
token[m++] = ch;
}
else
{
syn=17;
p--;
}
break;

case '+': syn=13;token[0] = ch; break;
case '-': syn=14;token[0] = ch; break;
case '*': syn=15;token[0] = ch;break;
case '/': syn=16;token[0] = ch;break;
case '(': syn=27;token[0] = ch;break;
case ')': syn=28;token[0] = ch;break;
case '=': syn=25;token[0] = ch;break;
case ';': syn=26;token[0] = ch;break;
case '#': syn=0;token[0] = ch;break;
default: syn=-1;break;
}
}
//該函數是生成一個三地址語句送到四元式表中
void emit(char *result,char *ag1,char *op,char *ag2)
{
strcpy(quad[q].result1,result);
strcpy(quad[q].ag11,ag1);
strcpy(quad[q].op1,op);
strcpy(quad[q].ag21,ag2);
q++; //統計有多少個四元式
}

『貳』 編譯原理課程設計－詞法分析器設計（C語言）

#include"stdio.h"/*定義I/O庫所用的某些宏和變數*/

#include"string.h"/*定義字元串庫函數*/

#include"conio.h"/*提供有關屏幕窗口操作函數*/

#include"ctype.h"/*分類函數*/

charprog[80]={''},

token[8];/*存放構成單詞符號的字元串*/

charch;

intsyn,/*存放單詞字元的種別碼*/

n,

sum,/*存放整數型單詞*/

m,p;/*p是緩沖區prog的指針，m是token的指針*/

char*rwtab[6]={"begin","if","then","while","do","end"};

voidscaner(){

m=0;

sum=0;

for(n=0;n<8;n++)

token[n]='';

ch=prog[p++];

while(ch=='')

ch=prog[p++];

if(isalpha(ch))/*ch為字母字元*/{

while(isalpha(ch)||isdigit(ch))/*ch為字母字元或者數字字元*/{

token[m++]=ch;

ch=prog[p++];}

token[m++]='';

ch=prog[p--];

syn=10;

for(n=0;n<6;n++)

if(strcmp(token,rwtab[n])==0)/*字元串的比較*/{

syn=n+1;

break;}}

else

if(isdigit(ch))/*ch是數字字元*/{

while(isdigit(ch))/*ch是數字字元*/{

sum=sum*10+ch-'0';

ch=prog[p++];}

ch=prog[p--];

syn=11;}

else

switch(ch){

case'<':m=0;token[m++]=ch;ch=prog[p++];

if(ch=='>'){

syn=21;

token[m++]=ch;}

elseif(ch=='='){

syn=22;

token[m++]=ch;}

else{

syn=20;

ch=prog[p--];}

break;

case'>':m=0;token[m++]=ch;ch=prog[p++];

if(ch=='='){

syn=24;

token[m++]=ch;}

else{

syn=23;

ch=prog[p--];}

break;

case':':m=0;token[m++]=ch;ch=prog[p++];

if(ch=='='){

syn=18;

token[m++]=ch;}

else{

syn=17;

ch=prog[p--];}

break;

case'+':syn=13;token[0]=ch;break;

case'-':syn=14;token[0]=ch;break;

case'*':syn=15;token[0]=ch;break;

case'/':syn=16;token[0]=ch;break;

case'=':syn=25;token[0]=ch;break;

case';':syn=26;token[0]=ch;break;

case'(':syn=27;token[0]=ch;break;

case')':syn=28;token[0]=ch;break;

case'#':syn=0;token[0]=ch;break;

default:syn=-1;}}

main()

{

printf(" Thesignificanceofthefigures: "

"1.figures1to6saidKeyword "

"2. "

"3.figures13to28saidOperators ");

p=0;

printf(" pleaseinputstring: ");

do{

ch=getchar();

prog[p++]=ch;

}while(ch!='#');

p=0;

do{

scaner();

switch(syn){

case11:printf("(%d,%d) ",syn,sum);break;

case-1:printf(" ERROR; ");break;

default:printf("(%d,%s) ",syn,token);

}

}while(syn!=0);

getch();

}

程序測試結果

對源程序beginx:=9:ifx>9thenx:=2*x+1/3;end#的源文件，經過詞法分析後輸出如下圖5-1所示：

具體的你在修改修改吧

『叄』 編譯原理課程設計

%{

/* FILENAME: C.Y */

%}
#define YYDEBUG_LEXER_TEXT (yylval) /* our lexer loads this up each time */
#define YYDEBUG 1 /* get the pretty debugging code to compile*/
#define YYSTYPE char * /* interface with flex: should be in header file */
/* Define terminal tokens */
/* keywords */
%token AUTO DOUBLE INT STRUCT
%token BREAK ELSE LONG SWITCH
%token CASE ENUM REGISTER TYPEDEF
%token CHAR EXTERN RETURN UNION
%token CONST FLOAT SHORT UNSIGNED
%token CONTINUE FOR SIGNED VOID
%token DEFAULT GOTO SIZEOF VOLATILE
%token DO IF STATIC WHILE
/* ANSI Grammar suggestions */
%token IDENTIFIER STRINGliteral
%token FLOATINGconstant INTEGERconstant CHARACTERconstant
%token OCTALconstant HEXconstant
/* New Lexical element, whereas ANSI suggested non-terminal */
%token TYPEDEFname /* Lexer will tell the difference between this and
an identifier! An identifier that is CURRENTLY in scope as a
typedef name is provided to the parser as a TYPEDEFname.*/
/* Multi-Character operators */
%token ARROW /* -> */
%token ICR DECR /* ++ -- */
%token LS RS /* << >> */
%token LE GE EQ NE /* <= >= == != */
%token ANDAND OROR /* && || */
%token ELLIPSIS /* ... */
/* modifying assignment operators */
%token MULTassign DIVassign MODassign /* *= /= %= */
%token PLUSassign MINUSassign /* += -= */
%token LSassign RSassign /* <<= >>= */
%token ANDassign ERassign ORassign /* &= ^= |= */
%start translation_unit
%%
/* CONSTANTS */
constant:
INTEGERconstant
| FLOATINGconstant
/* We are not including ENUMERATIONconstant here because we
are treating it like a variable with a type of "enumeration
constant". */
| OCTALconstant
| HEXconstant
| CHARACTERconstant
;

string_literal_list:
STRINGliteral
| string_literal_list STRINGliteral
;
/************************* EXPRESSIONS ********************************/
primary_expression:
IDENTIFIER /* We cannot use a typedef name as a variable */
| constant
| string_literal_list
| '(' comma_expression ')'
;
postfix_expression:
primary_expression
| postfix_expression '[' comma_expression ']'
| postfix_expression '(' ')'
| postfix_expression '(' argument_expression_list ')'
| postfix_expression {} '.' member_name
| postfix_expression {} ARROW member_name
| postfix_expression ICR
| postfix_expression DECR
;
member_name:
IDENTIFIER
| TYPEDEFname
;
argument_expression_list:
assignment_expression
| argument_expression_list ',' assignment_expression
;
unary_expression:
postfix_expression
| ICR unary_expression
| DECR unary_expression
| unary_operator cast_expression
| SIZEOF unary_expression
| SIZEOF '(' type_name ')'
;
unary_operator:
'&'
| '*'
| '+'
| '-'
| '~'
| '!'
;
cast_expression:
unary_expression
| '(' type_name ')' cast_expression
;
multiplicative_expression:
cast_expression
| multiplicative_expression '*' cast_expression
| multiplicative_expression '/' cast_expression
| multiplicative_expression '%' cast_expression
;
additive_expression:
multiplicative_expression
| additive_expression '+' multiplicative_expression
| additive_expression '-' multiplicative_expression
;
shift_expression:
additive_expression
| shift_expression LS additive_expression
| shift_expression RS additive_expression
;
relational_expression:
shift_expression
| relational_expression '<' shift_expression
| relational_expression '>' shift_expression
| relational_expression LE shift_expression
| relational_expression GE shift_expression
;
equality_expression:
relational_expression
| equality_expression EQ relational_expression
| equality_expression NE relational_expression
;
AND_expression:
equality_expression
| AND_expression '&' equality_expression
;
exclusive_OR_expression:
AND_expression
| exclusive_OR_expression '^' AND_expression
;
inclusive_OR_expression:
exclusive_OR_expression
| inclusive_OR_expression '|' exclusive_OR_expression
;
logical_AND_expression:
inclusive_OR_expression
| logical_AND_expression ANDAND inclusive_OR_expression
;
logical_OR_expression:
logical_AND_expression
| logical_OR_expression OROR logical_AND_expression
;
conditional_expression:
logical_OR_expression
| logical_OR_expression '?' comma_expression ':'
conditional_expression
;
assignment_expression:
conditional_expression
| unary_expression assignment_operator assignment_expression
;
assignment_operator:
'='
| MULTassign
| DIVassign
| MODassign
| PLUSassign
| MINUSassign
| LSassign
| RSassign
| ANDassign
| ERassign
| ORassign
;
comma_expression:
assignment_expression
| comma_expression ',' assignment_expression
;
constant_expression:
conditional_expression
;
/* The following was used for clarity */
comma_expression_opt:
/* Nothing */
| comma_expression
;
/******************************* DECLARATIONS *********************************/
/* The following is different from the ANSI C specified grammar.
The changes were made to disambiguate typedef's presence in
declaration_specifiers (vs. in the declarator for redefinition);
to allow struct/union/enum tag declarations without declarators,
and to better reflect the parsing of declarations (declarators
must be combined with declaration_specifiers ASAP so that they
are visible in scope).
Example of typedef use as either a declaration_specifier or a
declarator:
typedef int T;
struct S { T T;}; /* redefinition of T as member name * /
Example of legal and illegal statements detected by this grammar:
int; /* syntax error: vacuous declaration * /
struct S; /* no error: tag is defined or elaborated * /
Example of result of proper declaration binding:
int a=sizeof(a); /* note that "a" is declared with a type in
the name space BEFORE parsing the initializer * /
int b, c[sizeof(b)]; /* Note that the first declarator "b" is
declared with a type BEFORE the second declarator is
parsed * /
*/
declaration:
sue_declaration_specifier ';'
| sue_type_specifier ';'
| declaring_list ';'
| default_declaring_list ';'
;
/* Note that if a typedef were redeclared, then a declaration
specifier must be supplied */
default_declaring_list: /* Can't redeclare typedef names */
declaration_qualifier_list identifier_declarator {} initializer_opt
| type_qualifier_list identifier_declarator {} initializer_opt
| default_declaring_list ',' identifier_declarator {} initializer_opt
;

declaring_list:
declaration_specifier declarator {} initializer_opt
| type_specifier declarator {} initializer_opt
| declaring_list ',' declarator {} initializer_opt
;

declaration_specifier:
basic_declaration_specifier /* Arithmetic or void */
| sue_declaration_specifier /* struct/union/enum */
| typedef_declaration_specifier /* typedef*/
;

type_specifier:
basic_type_specifier /* Arithmetic or void */
| sue_type_specifier /* Struct/Union/Enum */
| typedef_type_specifier /* Typedef */
;

declaration_qualifier_list: /* const/volatile, AND storage class */
storage_class
| type_qualifier_list storage_class
| declaration_qualifier_list declaration_qualifier
;

type_qualifier_list:
type_qualifier
| type_qualifier_list type_qualifier
;

declaration_qualifier:
storage_class
| type_qualifier /* const or volatile */
;

type_qualifier:
CONST
| VOLATILE
;

basic_declaration_specifier: /*Storage Class+Arithmetic or void*/
declaration_qualifier_list basic_type_name
| basic_type_specifier storage_class
| basic_declaration_specifier declaration_qualifier
| basic_declaration_specifier basic_type_name
;

basic_type_specifier:
basic_type_name /* Arithmetic or void */
| type_qualifier_list basic_type_name
| basic_type_specifier type_qualifier
| basic_type_specifier basic_type_name
;

sue_declaration_specifier: /* Storage Class + struct/union/enum */
declaration_qualifier_list elaborated_type_name
| sue_type_specifier storage_class
| sue_declaration_specifier declaration_qualifier
;

sue_type_specifier:
elaborated_type_name /* struct/union/enum */
| type_qualifier_list elaborated_type_name
| sue_type_specifier type_qualifier
;

typedef_declaration_specifier: /*Storage Class + typedef types */
typedef_type_specifier storage_class
| declaration_qualifier_list TYPEDEFname
| typedef_declaration_specifier declaration_qualifier
;

typedef_type_specifier: /* typedef types */
TYPEDEFname
| type_qualifier_list TYPEDEFname
| typedef_type_specifier type_qualifier
;

storage_class:
TYPEDEF
| EXTERN
| STATIC
| AUTO
| REGISTER
;

basic_type_name:
INT
| CHAR
| SHORT
| LONG
| FLOAT
| DOUBLE
| SIGNED
| UNSIGNED
| VOID
;

elaborated_type_name:
aggregate_name
| enum_name
;

aggregate_name:
aggregate_key '{' member_declaration_list '}'
| aggregate_key identifier_or_typedef_name
'{' member_declaration_list '}'
| aggregate_key identifier_or_typedef_name
;

『肆』 計算機工程畢業論文精選範文

近年來,隨著全球網際網路技術的普及、計算機技術的迅猛發展、數字技術的瞬息萬變,計算機工程在人們生活、生產中的應用越來越廣泛。下面是我為大家整理的計算機工程畢業論文，供大家參考。

計算機軟體大體分為三類，一種是總述，一種是系統軟體，一種是應用軟體，系統軟體的作用是促使各個硬旁橘體按照一定的規律協調工作，保證計算機處於正常運轉狀態。而應用軟體的作用則是為了實現某種使用願望而開發出來的軟體。

1計算機軟體工程專案管理的基本概念

1.1工程專案管理的含義工程專案管理主要是業主通過委託從事工程專案管理的企業，簽署相關協議，工程專案管理企業有義務和權力代表業主在工程專案進行的情況卜干預和服務。工程專案管理企業可以協助業主同項目工程總承包簽訂一系列鋒昌合同，只是起到輔助性作用，不直接與總承包企業或者施工、勘察、供貨和設計簽署協議或合同，工程專案管理企業有責任在施工過程中監督合同的完成情況。

1.2軟體工程專案的概況

1.2.1管理人員開展有序的專案計劃

企業必須把人員管理放在重要位置，在軟體工程專案的開發上人員的調配問題是保證工程順利進行的重要因素，因此，專案能否成功和工作人員的工作能力、寫作能力息息相關，針對工程專案的操作類別不同，可以分配成各個研究小組，進行科學合理的針對性開發和高效的協作，有利於工程的快速推進和更加完善。小組內的人員根據自身優勢，確定自己的工作內容和工作時間。對專案進行正確的認識和對風險進行評估，與此同時從節約成木的方而出發，形成科學的人力資源調配機制，使專案得以順利開展。

1.2.2質量和配置管理工作

軟體的質量管理工作是整個專案的核心工作，質量管理決定著計算機軟體工程專案管理是否真正的成功，通過一系列保證質量的手段，有計劃的編制、控制和保證專案質量。保證專案質量的方式可以通過定期的進行質量評估得以實現，在日常專案管理中要不斷的對工作進行考查，對於專案不合格的地方要提出意見並且考慮整改措施，不斷完善整個軟體配置管理的記錄工作，使專案的質量能有一定的檢測體系，這樣開發者會對專案工程的質量問題有比較深入的了解。

1.2.3風險評估和管理工作

風險管理大致分為兩種工作，一種是風險識別，另一種是風險評估。得到評估結果以後要針對問題提出相應的解決辦法，定期檢測計算機軟體工程的好處是可以減小產生風險的概率，還可以避免一些因疏忽而產生風險，使專案的損失減少到最低，也減少了因專案風險而造成的一些相關責任人的利益沖突。

2計算機軟體工程專案管理中存在的問題

2.1管理團隊的協作問題

分工合作是我們完成一個專案的基木因素，在軟體開發方而更需要每個人的智慧一起凝聚出果實，共同享受成果，而目前在計算機軟體工程專案管理方而資訊的交流方而存在一些問題，例如分工不清、團隊不合作等問題。

2.2需求分析和實際中的業務存在差距問題

計算機軟體工程專案沒有結合實際的活動需求，也沒有調查有效的資料分析，因此計算機軟體工程專案管理在開發出新的產品以後並沒有取得理想的業務效果。

2.3風險管理的問題

專案的風險工作是企業需要考慮的很重要的問題，如果風險沒有相應科學管理，很容易帶來巨大的損失，但是很多員工並不懂得如何規避風險，缺乏相應的專業知識，更是缺少對風險工作的管理，導致很多企業在風險來臨時無法做出正確行動，造成巨大的經濟損失。

3計算機軟體工程專案管理的對策

3.1對風險管理和工作進度進行有效管理

制定風險管理制度。計算機軟體工程專案管理的工作人員必須具有一定的風險識別意識和相應的遇到風險的專業知識，並且能有效的控制風險的能力。在平時要做好風險評估的管理報告，針對可能發生的風險要及時預測並且做出相應的解決行動。設定專門的人員對計算機軟體工程專案定期進行風險的評估和檢查工作。在整個專案中，根據需要進行多次的風險管理工作，因為風險無時無刻都有可能存在，檢查的目的是盡量減少風險發生，在一般情況卜處理風險的措施一般有三種:減緩、規避和轉移。提高工程的進度，不斷的推進工程的工作效率。要制定詳細的工作計劃表，並且盡可能達到最高的工作目標。工作人員有嚴謹的工作態度和高效的作息時間安排，管理人員要密切關注工程進度，不斷的督促員工完成應做的工作量，有條理、高效的完成對員工的工作任務的監督工作。

3.2建立完善的管理體系針對計算機軟體工程的人員日常管理工作，要建立科學有效的管理方案。合理安排人才資源，確保在進行計算機軟體專案工程時人員調配順利進行。專業知識的培訓對於工作人員來說

是必不可少的，可以極大的豐富計算機軟體工程專案人員的專業水平和實踐能力，減少工作上的失誤，提高工作效率和工作人員的素質。獎罰制度是對企業員工優劣的衡量標准，所以在計算機軟體工程專案管理方而採取獎罰制度可以極大程度上調動員工的積極性，使員工主動為企業創造效益，企業的發展才能有長遠的未來。

3.3建立合作的團隊

在員工內部建立有效的交流機制。員工的內部工作經驗交流是非常重要的，因此要完善溝通方法，開辟多種交流方式和渠道，不斷的增強各個部門的溝通意識，使團隊的力量不斷凝聚起來。明確分工，責任落實到個人。計算機軟體工程管理非常復雜，需要的人員也眾多，因此必須要使每個員工明確自己的工作內容和范圍，清晰的劃分自己所需要負責的區域，清楚自己的責任，這樣能夠確保每一個步驟都井井有條，非常有秩序。調動整個團隊的工作積極性。通過一些活動、獎勵措施等使每一個工作人員全身心的投入到工作中去，願意並想要去做的更好，不斷激發團隊的潛力和員工的協作能力，這樣專案不僅會做的越來越好，員工內部也會越來越和諧並且充滿正能量，企業的效益也會不斷得到提升。

4結語

計算機軟體工程專案管理的工作內容十分的復雜，要保證軟體工程按照工程原計劃進度順利開展工作，並且要節約成木、保證質量，必須熟練對計算機軟體進行操作，在現在的大多數生產計算機軟體的企業中最為重要的就是軟體工程專案的管理效率，軟體工程專案的成功條件是軟體專案要具有科學性和高效性，在此基礎上企業的合理管理也是企業走向成功的關鍵。

1現狀分析

培養高質量的軟體開發人才一直是社會和行業關注的焦點。早在11年前，對於工程教育的迫切性就被人提出來[1]。工程教育本身也作為一個系統問題被討論[2]。現在從國家層面在戰略上建立了軟體學院進行專門培養，各個高校也不斷推出新的課程、新的措施方案。在這一領域雖然比過去似乎已經有了翻天覆地的變化，但來自企業的呼籲似乎一直反映出諸多不盡如人意。更多的思路希望將企業的力量直接引入到教學，比如實訓基地等[3];而國家層面也非常關注實訓[4]。但實際效果可能變得流於表面，因為企業往往難以將核心的工作拿給學生做，而其訓練的專案也並未從更全面系統的角度去設計，其鍛煉效果就有限了。在軟體開發這一領域，由於其具有變化迅速，新技術不斷涌現的特點，導致不少在教育內容上選擇了追逐新技術、新語言、新平台，以能用會用這些流行主流技術為目標。典型的代表就是北大青鳥，有些二本的學生在畢業前專門花錢去青鳥學習，似乎可以看到這種教育的優勢。但另一個矛盾的情況是，往往那些關注員工後勁的公司卻不願意招聘青鳥的學生。如果將目光投向國外的頂級大學，例如斯坦福，其教學上並沒有去「依賴」校企合作，以及很熱門的「實訓」。其核心課程依然是過去的傳統經典課程。以一個研究生為例，一學期能修2門課是正常，3門就很優秀。它並沒有追逐所謂的新技術。但無人質疑其學生的工程能力、科研能力和創造能力。

2什麼是計算機工程能力的核心

什麼才是我們軟體開發教育的核心知識架構，怎樣才能培養學生可持續發展的核心競爭力?我們調查過一些非常高水準的軟體開發者，發現他們往往在底層軟體上持之以恆地進行長時間深刻的鍛煉，然後在未接觸的新領域才能非常迅速地掌握核心。例如，一個非計算機專業的系統分析員曾經「只」在DOS這種原始的作業系統下玩了10年，甚至自己寫過一個漢化的DOS。他只有書本上的一點點網路知識時，就用一兩天時間解決了一個學通訊的研究生1個月都不能解決的網路故障。這是一個典型的例子，他並沒有「實際的」網路經驗，什麼使得他如此輕松地進入了新的領域呢?而另一個曾就職於vmware、google等頂級公司的程式設計師，在Unix下只用C語言做了10年系統級程式設計。當用java，C++甚至是javascript時，其學習時間只是1天，很快就比做了幾年專門java程式設計的程式設計師還精通。如何才是軟體開發人員的本質力量?什麼才能讓他們在變化萬千的新技術面前屹立不倒，乘風破浪?

2.1計算機工程能力

我們認為計算機工程能力包含兩方面的內容:1核心知識架構;2計算機的思維方式。什麼是核心知識架構呢?是反應該領域最基本規律和支撐技術的知識。簡單地說就是傳統的作業系統、編譯、資料庫。作業系統將硬體、軟體、高階語言和匯編融匯在一起，它幾乎包括了軟體工程中所有重要的因素。舉一個簡單的例子，似乎只有面向物件這種「高階東西」才有的虛擬函式運用，其實在Linux中就有相應的虛檔案系統。作業系統是最為復雜的計算機工程之一。編譯融匯了大量的演演算法，而且能讓大家真正看「穿」語言的外表，深入到其內里，體現了最根本的計算機技術。其優化技術，也深刻地和硬體交融在一起，很好體現了底層風范。資料庫，不僅是運用演演算法最多的地方，甚至是超越作業系統的一個復雜的系統，從快取技術到i/o優化，到索引，再到事務處理，無一不是反映計算機最深刻規律。大家可以發現，所謂核心知識架構，都具有兩個特點，反映本質規律，體現軟硬融匯交織。也只有這樣，才能建立下面談到的「計算機思維方式」。

2.2核心知識架構

為什麼我們沒包括一些新興的語言和技術呢?似乎它們很「實用」。而且已經出現的問題是，按照傳統科目和方式學習後，學生在企業什麼都不會。這也正是大家關注工程教育的初衷。為什麼不強調這些新興實用技術的教育還在強調「古老」的「基礎」。計算機領域一個顯著的特點是，表面上知識更新非常快，新技術、語言層出不窮。這很容易導致當我們發現學生能力欠缺時，將問題歸罪於新技術的學習不得力，知識結構老化。但其實目前的問題可以從另外一個角度考慮，是否是基礎教育不得力?分析國外著名大學，如斯坦福、伯克利的課程，我們發現兩個特點:1關鍵的基礎課程，如作業系統、編譯原理、資料庫，始終是其最重要的課程，並沒有過分追逐各種「新潮」技術。2學生一學期能修的課程非常有限，一般為3門課。而國內卻呈現相反的狀況，比如編譯原理被降到了選修課的角色，新潮課程層出不窮，一個學生二年級一學期要修13門課。在這種走馬觀花的狀況下，計算機這種具有強烈「手藝」色彩和工程實踐的學科，被完全紙上談兵化。而一些可憐的實驗內容，還被學生的復制拷貝所湮沒。我們認為，恰恰是這種情況，使得基礎核心知識教育沒有工程化，沒有充分動手，導致了基礎知識教育某種程度上的巨大失敗。從以下鮮明的對比可以窺見問題的端倪:國內學生反映作業系統課程是文科課程只需要背條款考試即可;而相對地，國外著名高校作業系統課程要求學生實現「小」作業系統。國內資料庫只講其應用如大量講解sql等運用，sql即使非計算機專業人士也很容易學習，這也是它被發明的初衷。斯坦福的資料庫課程中有一門需要實現一個資料庫系統。在筆者走訪的計算機工程上優秀的人才，發現其共同的特點就是在諸如作業系統或資料庫上都有很深入的學習經歷，比如前面提及的自己構建過漢化DOS系統，或者在Unix下，做核心以及驅動很多年等。而當他們接觸新技術時，之前深刻的經驗和淬煉的思維就讓他們如虎添翼，快人一等。更有甚者，國外真正的最頂級專家，都是在這些領域有無與倫比水平的專家，從delphi的締造者，轉戰到微軟並入主平台的開發，也可看到雄厚的底層知識和能力的巨大作用。所以「老」知識並不是障礙，而是通向天堂的階梯。究其原因，就涉及到工程能力的第2個方面，計算機思維方式。

2.3計算機思維方式

對非專業人士它是很抽象的概念，而對真正專業人士，這又是一個非常鮮活的概念。這里限於篇幅，我們只舉一個簡單的例子。面對在C++中外部程式碼如何直接修改私有變數的問題，計算機的思維方式就是:物件也是放在記憶體中，只要能拿到物件的地址，並知道物件的布局，那麼就可修改。而沒有建立這種思維的人，就完全被高階語言的語法所左右，無從下手。一句話，無法看到本質，沒有從下而上的底層思維。核心知識課程的有效深入教學和計算機思維方式建立有何直接關系呢?我們認為核心知識因為其反應了計算機本質規律，而且從底層建立起來，所以對其深入掌握運用後，它從開始的逼迫到最後的陶冶，最終潛移默化地讓受眾建立起「計算機思維方式」。而這正是計算機工程師安身立命之本，就如同音樂家有其獨特的音樂思維方式一樣。為什麼諸如java之類的課程於建立計算機基本思維不太合適呢?因為它更高層，無法讓學生看到最下面。而唯有徹底、深刻和系統的底層淬煉，才能真正建立起「計算機思維方式」。

3如何打造強大的計算機工程能力

大家一方面指責基礎課程的「空洞」、「無用」、「陳舊」;另一方面在不斷開設的海量新課和技術中壓得學生更加遠離程式設計，遠離實踐。即使能培養出熟悉某種語言的學生，也無法看到他們和培訓學校有何不同。實訓也似乎沒有根本解決問題，我們在實踐中發現，往往是那些自己醉心於程式設計的學生最後有著卓越的表現。讓基礎知識能支撐和指導實踐，而非僅僅「符號」，並引導學生進行高效的實踐。

3.1「3塊連一線」，4門基礎課程整合打造核心知識架構

我們將4門基本課程進行貫通式整合，著力塑造學生的「計算機思維」。下層的是3門基礎課在上一小節探討了其在工程能力訓練上不可替代的重要地位，對軟體開發環境產生支撐。而軟體開發環境又通過精心的設計和工程實踐，從應用角度將3門課程所學的知識串聯起來。從而將基礎知識和工程開發更有機整合在一起。首先，闡述為什麼將以上課程整合在一起的理由。要回答這個問題，必須先回答什麼東西支撐了優秀程式設計師。在我們的調查人員中，無一例外地都具有很深厚的底層軟體開發背景。有長期從DOS的Hack入手的;有長期從事Unix核心程式設計的;有從Windows的driver起步的;有以反匯編逆向為根基的。長期在最底層的經歷，使他們建立了最真實和能觸控的系統觀，能以計算機的方式思考。所以面臨新技術時，他們能透過新形式很快把握其精髓，深刻地把握其實質。「太陽下面沒有真正的新事物」，例如號稱21世紀最新的重要的軟體技術AOPAspectOrientedProgramming，AOP，其實在20世紀60年代就出現在了匯編一級的軟體技術中，它本質就是鉤子技術的系統化。在底層的軟體世界，我們不僅能夠用到那些所謂的最新的技術，而且能看到其本質我們可能就是用機器碼自己構建出來的，而不被新技術的華麗外衣障目。這些使得具有底層經驗的開發者，更有創造力，更能創造，也更能洞察迷亂後的本質，庖丁解牛，解決那些異常復雜的工程問題。舉一個筆者遇到的真例項子，一個具有深刻底層經驗的程式設計師一直只有C語言和作業系統程式設計經驗和一個只有深刻Java經驗的程式設計師，在同時學習Javascript的閉包概念時，後者一個禮拜都還有些似是而非。前者很快就能自如運用，且最後指點了後者1個小時，後者頓時豁然開朗。這是典型的「新」與「老」，上層和底層經驗在面對新事物時的對比。既然底層軟體賦予我們如此強大的能力，那麼哪些是底層軟體呢?大家公認，作業系統、編譯和資料庫由來就是計算機工程自身的根基。所以，我們必須將這3門課涉及的知識好好淬煉。而如何將3門課的知識和我們日常的軟體開發聯絡起來呢?如何用它們指導平時程式的開發呢我們大多數是開發使用者級軟體，不會開發核心軟體，因此許多人認為幾乎整個在核心中的作業系統對使用者級軟體開發無從指導?另一門課，《軟體開發環境》解決了這一問題。它有一條主線，通過反匯編將C語言和匯編串聯起來，讓系統級的知識從高階語言的面紗下展現出來。同時用逆向工程這把庖丁之刃，將編譯、連結、面向物件等軟體開發中的重要知識塊剖剔，讓底層與上層貫通一氣。而逆向的技術技巧，本身也是非常高階的軟體開發技術。因此，我們用「3塊連一線」來總結4門課的關系是最好不過了。為什麼不納入語言課程，比如C/C++語言?從我們的工程經驗來看，語言只是計算機原理和思想的載體，是表述方式而已。為了表述形式而專門花大力氣是不值得的。比如，國外的著名大學很多都不開設語言課，在其他課程作業中必須用C語言程式設計，學生們就在那裡鍛煉了。真正的語言的力量並非來自語言本身，而是底層知識為支撐的專案鍛煉。我們的思路是以構建式完成大量的完整系統的編寫，這樣就很好鍛煉了軟體開發和工程能力。同時，「軟體開發環境」本身從逆向層面也對語言有了深刻的剖析，這是純粹的語言課難以完成的。另外，從大綱安排上，我們在大一就會讓學生用C語言來初步接觸程式編寫，這時並不適合放入太高階主題。而在教學中，語言的力量已經滲透到一個個工程構建中，隨風潛入夜了。為什麼不納入演演算法課程?從某種程度上，「程式就是演演算法與資料結構嗎」?我們認為在系統中運用演演算法，演演算法才具有生命力。而編譯、作業系統、資料庫以及我們專門設立的一些課程設計將全面運用各種演演算法和資料結構。在實戰中運用並學習提升才是王道。這也正是構建式學習的精髓所在，這也正是探索式學習培養學生的創造能力的精髓所在。演演算法課已經為我們准備了元件，就看你怎麼去組裝甚至改造。

3.2以構建主義的思路，深度實踐的風格改革課程

前面我們論述了底層知識架構的重要性，那麼怎麼來將它們實際地建立在學生的工程實踐中呢?簡單地說就是「構建一個具體而微的系統」。講作業系統就構建一個小作業系統，講編譯原理就構建一個我譯器。同時，設計一些跨度較大的課程設計覆蓋這些課程的一些重點內容。構建完整系統本身就可真實淬煉工程能力，而這些內容的復雜性、難度以及運用知識點的廣度，本身就超越了簡單的企業實訓專案，在培養人才方面具有系統性、完整性、挑戰性獨特優點。我們需要的是運用團隊的思路和現代軟體工程的手段，將其開發過程管理發起來，從而熟悉企業級開發的工具鏈，將軟體工程學到的知識貫通到實作中。這也回答了「和以前相似的強調基礎課程教育，什麼特點使得我們的做法能獲得強大的工程能力?」這一問題。以前更多注重理論知識的學習，而現在的做法是回歸計算機工程的自身科學規律———實踐為王。

3.3改革考核評價標准，充分強調動手實踐

以前我們一直是卷面考試，實驗分數只是象徵性的點綴。這本身違反了計算機工程的特點。只有改變評價考核標准，才能真正驅動學生充分鍛煉工程。在課程軟體開發環境中，我們採取了平時的考試結合期末考試的方式，而兩者均為軟體編寫。期末考試在實驗室上機編撰指定題目。不強調對一些函式名等死知識點的記憶，可以用線上幫助。這本身也符合軟體開發的規律。

4結束語

我們在計算機工程教育上試圖做一些回歸本質的工作，也取得了一些效果。比如在軟體開發環境中，學生普遍認為:「似乎將3年學的程式課全學習了，收獲很大」。更有同學，在外企公司的面試中，直接運用了課堂上的知識，這在傳統的教學環節中是難以獲取的。但整個工作尚在起步階段，所以仍有很多工作需要做，許多環節需要優化。我們希望在以後的工作中更深入探索工程教育的規律和本質。

『伍』 編譯原理的難點

1.錯誤認識: 很多人以為編譯原理只能應用在寫程序語言的編譯器上,覺得用處不大,學習興趣不高.而且可能覺得寫編譯器就必須完全手工來寫.
2.自動機理論: 象NFA,DFA之類,比較抽象,要費些腦子,特別如果學離散數學時沒有學自動機理論的話,更是需要多花點時間.
3.集合論的推演: 主要是一些閉包運算之類,數學基礎不好的話,學起來也會感到吃力.
4.LR文法: 主要是又引入了自動機