电子辞典课程设计.doc

电子辞典课程设计

54
2020年4月19日
文档仅供参考，不当之处，请联系改正。

课程名称 Linux下的标准C
设计题目 英汉电子辞典
项目组长 邢美慧
组 员 丁宝 陈飞 郭宗良 欧阳晨阳
指导教师 王建立

年 8 月

目录
一、设计时间 1
二、设计目的 1
三、需求分析 1
3.1 单词查询 1
3.2 建立索引，并使用索引进行单词查询 1
3.3 用户添加新词 1
四、系统分析 2
4.1 功能分析 2
4.1.1 系统功能分析 2
4.1.2 文本查找功能分析 2
4.1.3 建立索引功能分析 2
4.1.4 索引查找功能分析 2
4.1.5 添加新词功能分析 3
4.2 概要设计 3
4.2.1 系统功能结构图 3
4.2.2 文本查找功能图 4
4.2.3 建立索引功能图 5
4.2.4 索引查找功能图 6
4.2.5 添加新词功能图 7
4.3 各模块细化分析 8
4.3.1 内存存储结构 - 哈希表的实现 8
4.3.2 二进制索引文件构造图 9
4.3.3 文本查询细化分析 9
4.3.4 建立索引文件细化分析 12
4.3.5 索引查询细化分析 16
4.3.6 添加新词细化分析 19
五、系统设计 20
5.1 硬件环境 21
5.2 选择语言 21
5.3 功能关系 21
5.4 框架设计 22
5.5 详细设计 23
5.5.1 抽象数据类型 23
5.5.2 函数接口声明 23
六、 编码 27
6.1 模块1代码 28
6.2 模块2代码 28
6.3 模块3代码 36
6.4 模块4代码 39
6.5 主函数代码 41
七、 测试 41
7.1 单元测试 42
7.1.1 模块1测试 42
7.1.2 模块2测试 43
7.1.3 模块3测试 44
7.1.4 模块4测试 46
7.2 集成测试 47
八、使用说明书 48
九、维护 49

一、设计时间
8月18日- 8月25日
二、设计目的
经过本次课程设计，熟悉C语言的程序设计与技巧，进一步提高编写程序，分析程序及上机操作，调试程序的能力，提高动手操作能力及分析问题和解决问题的能力
三、需求分析
3.1 单词查询
给定文本文件“dict.txt”，该文件用于存储词库。词库为“英-汉”，“汉-英”双语词典，每个单词和其解释的格式固定，如下所示：
#单词
Trans:解释1@解释2@…解释n
每个新单词由“#”开头，解释之间使用“@”隔开。一个词可能有多个解释，解释均存储在一行里，行首固定以“Trans：”开头。下面是一个典型的例子：
#abyssinian
Trans:a. 阿比西尼亚的@n. 阿比西尼亚人;依索比亚人
该词有两个解释，一个是“a. 阿比西尼亚的”；另一个是“n. 阿比西尼亚人;依索比亚人”。
要求编写程序将词库文件读取到内存中，接受用户输入的单词，在字典中查找单词，而且将解释输出到屏幕上。用户能够重复输入，直到用户输入“exit”字典程序退出。
程序执行格式如下所示：
./app –text
-text表示使用文本词库进行单词查找。
3.2 建立索引，并使用索引进行单词查询
要求建立二进制索引，索引格式如下图所示。将文本文件“dict.txt”文件转换为上图所示索引文件“dict.dat”，使用索引文件实现单词查找。程序执行格式如下：
./app –index
-index表示使用文本词库dict.txt建立二进制索引词库dict.dat
./app –bin
-bin表示使用二进制索引词库进行单词查找。
3.3 用户添加新词
用户添加的新词存放在指定文件中。如果待查单词在词库中找不到，则使用用户提供的词库。用户的词库使用文本形式保存，便于用户修改。程序执行格式图1-1所示。
./app 词库选择选项 -f 用户词库文件名
词库选项为-test1，或者-test2，表示使用文本词库或者二进制索引词库。-f为固定参数，用来指定用户词库文件名。

四、系统分析
4.1 功能分析
4.1.1 系统功能分析
该项目包含4个主要功能：
使用文本文件进行单词查询；
使用文本文件生成二进制索引文件；
使用二进制索引文件进行单词查询；
用户添加新词；
当用户输入./app -text 执行功能1；
当用户输入./app -index 执行功能2；
当用户输入./app -bin 执行功能3；
当用户输入./app -insert 执行功能4；

4.1.2 文本查找功能分析
当用户从终端输入./app -text后进入该功能模块，系统会提示用户输入要查询的英文单词，当用户键入待查单词后，程序会先从dict.txt文件中查询该单词，若查到，即在终端显示解释；若未查到，再到自定义文本my_dict.txt中查询，若查到，即在终端显示解释；若未查到，则在终端提示“此单词未找到”。用户能够重复查询，直到键入Exit结束整个程序。

4.1.3 建立索引功能分析
当用户从终端输入./app -index后进入该功能模块，系统会生成一个新的二进制文件dict.dat,若原已存在，将会被覆盖，程序将文本文件dict.txt中的内容写进该二进制文件，而且生成一个目录写进该二进制文件，在建立完成后将会提示“建立成功”

4.1.4 索引查找功能分析
当用户从终端输入./app -bin后进入该功能模块，系统会提示用户输入要查询的英文单词，当用户键入待查单词后，程序会从二进制索引文件dict.dat中查询该单词，若查到，即在终端显示解释；若未查到，则在终端提示“此单词未找到”。用户能够重复查询，直到键入Exit结束该程序。

4.1.5 添加新词功能分析
当用户从终端输入./app -insert后进入该功能模块，系统会提示用户要插入的英文单词，当用户键入待插单词后，程序会先在标准文本和自定义文本两个文件中查找该单词，若查到，则提示“该单词已存在，不能添加”；若未查到，则提示用户输入待插单词的所有解释，将单词及解释写进自定义文本my_dict.txt中

4.2 概要设计
4.2.1 系统功能结构图

图-系统功能

4.2.2 文本查找功能图

图 module1.ddd
4.2.3 建立索引功能图

图 module2.ddd
4.2.4 索引查找功能图

图 module3.ddd
4.2.5 添加新词功能图

图 module4.ddd

4.3 各模块细化分析
4.3.1 内存存储结构 - 哈希表的实现

分析：1.将同一个解释的长度和内容组成一个结点；
2.将同一个单词的所有解释存储在一条链表上；
3.将一个单词的长度、内容、解释个数及解释链表的头指针组成一个结点；
4.将所有单词首字母相同的单词结点存储在一条链表上；
5.声明一个结构体数组，数组元素分别存放26个英文字母和26条单词链表 的头指针

图 哈希表存储结构

好处：1.只加载英文部分，加载速度很快
2.锁定在特定链表中查询，查找速度很快

4.3.2 二进制索引文件构造图

4.3.3 文本查询细化分析
4.3.3.1 加载内存

图 load_memory_text.ddd
4.3.3.2 清除字符串后的空格
图 clear_space.ddd

4.3.3.3 在哈希表中查询单词

图search_word_text.ddd
4.3.3.4 在自定义文本中查询单词

图 search_word_mytext.ddd

4.3.4 建立索引文件细化分析

4.3.4.1 建立二进制索引文件

图 build_dat_index.ddd
4.3.4.2 将文本内容写入二进制索引文件

图 write_content_dat_index.ddd
4.3.4.3 将目录写进二进制索引文件

图 write_list_dat_index.ddd
4.3.4.4 将目录开始的索引写进二进制索引文件

图 write_listkey_dat_index.ddd

4.3.4.5 将单词个数写进二进制索引文件

图 write_wordnum_dat_index.ddd
4.3.5 索引查询细化分析
4.3.5.1 加载内存

图 Load_memory_bin.ddd
4.3.5.2 在目录中查询单词

图 search_index_bin.ddd

4.3.5.3 经过索引在正文中查询单词

图 search_word_with_index_bin.ddd
4.3.6 添加新词细化分析
4.3.6.1 将单词及解释写进自定义文本中

图 write_word_mytext_insert.ddd
五、系统设计
5.1 硬件环境
支持Linux下的gcc编译环境
5.2 选择语言
C语言
5.3 功能关系

5.4 框架设计

5.5 详细设计
5.5.1 抽象数据类型
typedef struct trans trans_t;
typedef struct word word_t;
typedef struct first first_t;
typedef struct array array_t;
typedef struct index index_t;
typedef struct indexdata index_data;
/*1.存放解释的结构体*/
struct trans
{
int trans_length;
char trans_name[SIZE];
trans_t *next;
};
typedef trans_t *trans_p;
/*2.存放单词的结构体*/
struct word
{
int word_length;
char word_name[SIZE];
int trans_num;
trans_p head;
word_t *next;
};
typedef word_t *word_p;
/*3.存放哈希数组元素的结构体*/
struct first
{
char ch;
word_p next;
};
typedef first_t *first_p;
/*4.存放指针哈希数组的结构体*/
struct array
{
first_p hash[26];
};
typedef array_t *array_p;
/*5.存放目录的结构体*/
struct index
{
char word_name[SIZE];
long position;
index_t *next;
};
typedef index_t *index_p;
/*6.存放目录数据域的结构体*/
struct indexdata
{
char word_name[SIZE];
long position;
};

5.5.2 函数接口声明
5.5.2.1 模块1
函数原型：void module1(void)
函数参数：void
函数返回值类型：void
函数功能：使用文本词库进行单词查询

函数原型：array_p load_memory_text(char *,array_p)
函数参数：char *，array_p
函数返回值类型：array_p
函数功能：文本词库加载到内存中，采用哈希表结构

函数原型：word_p search_word_text(array_p,char *)
函数参数：array_p，char *
函数返回值类型：word_p
函数功能：哈希表中查找单词

函数原型：word_p search_word_mytext(char *,char *)
函数参数：char *，char *
函数返回值类型：word_p
函数功能：自定义文本词库中查找单词

函数原型：trans_p create_trans_node_text(char *)
函数参数：char *
函数返回值类型：trans_p
函数功能：生成解释结点

函数原型：trans_p insert_trans_node_text(trans_p,trans_p)
函数参数：trans_p，trans_p
函数返回值类型：trans_p
函数功能：解释结点插到解释链表尾部

函数原型：word_p create_word_node_text(char *,trans_p)
函数参数：char *，trans_p
函数返回值类型：word_p
函数功能：生成单词结点

函数原型：word_p insert_word_node_text(word_p,word_p)
函数参数：word_p，word_p
函数返回值类型：word_p
函数功能：单词结点插到单词链表尾部

函数原型：int get_trans_num(trans_p)
函数参数：trans_p
函数返回值类型：int
函数功能：获取某个单词的解释个数

函数原型：void print_hash(array_p)
函数参数：array_p
函数返回值类型：void
函数功能：遍历哈希表

函数原型：void print_word(word_p)
函数参数：word_p
函数返回值类型：void
函数功能：遍历单词链表

函数原型：void clear_space(char *)
函数参数：char *
函数返回值类型：void
函数功能：清除字符串后的空格

5.5.2.2 模块2
函数原型：void module2(void)
函数参数：void
函数返回值类型：void
函数功能：建立二进制索引文件

函数原型：void build_dat_index(array_p,char *)
函数参数：array_p,char *
函数返回值类型：void
函数功能：生成二进制索引文件
函数原型：index_p write_content_dat_index(array_p,char *)
函数参数：array_p,char *
函数返回值类型：index_p
函数功能：将哈希表中的内容写进二进制文件，并保存每个单词所正确索引,生成目录

函数原型：long write_list_dat_index(index_p,char *,long *)
函数参数：index_p,char *,long *
函数返回值类型：long
函数功能：将目录写进dat文件，并保存目录开始的索引和目录中单词的个数

函数原型：void write_listkey_dat_index(long)
函数参数：long
函数返回值类型：void
函数功能：将目录开始的索引写进dat文件

函数原型：void write_wordnum_dat_index(long)
函数参数：long
函数返回值类型：void
函数功能：将目录中单词的个数写进dat文件

函数原型：index_p insert_index_node_index(index_p,index_p)
函数参数：index_p,index_p
函数返回值类型：index_p
函数功能：目录结点插到目录链表头部

5.5.2.3 模块3
函数原型：void module3(void)
函数参数：void
函数返回值类型：void
函数功能：使用二进制索引文件进行单词查询

函数原型：index_p load_memory_bin(char *,index_p)
函数参数：char *,index_p
函数返回值类型：index_p
函数功能：将二进制索引文件中的目录加载到内存中，采用链表结构

函数原型：long search_index_bin(index_p,char *)
函数参数：index_p,char *
函数返回值类型：long
函数功能：目录链表中查找单词对应的索引

函数原型：word_p search_word_with_index_bin(char *,long)
函数参数：char *,long
函数返回值类型：word_p
函数功能：dat中查找某个索引相对应的单词内容及解释

5.5.2.4 模块4
函数原型： void module4(void)
函数参数：void
函数返回值类型：void
函数功能：添加新词到自定义文本中

函数原型：void write_word_mytext_insert(char *,char *)
函数参数：char *,char *
函数返回值类型：void
函数功能：写入新词及其解释到自定义文本

六、 编码
6.1 模块1代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <my_word.h>

/*---------------------------------------------------------------------------*/
/* 模块1： 使用文本词库进行单词查询 */
/*---------------------------------------------------------------------------*/

/*1.使用文本词库进行单词查询*/
void module1(void)
{
int i;
char str[30];
array_p point=(array_p)malloc(sizeof(array_t));
for(i=0;i<26;i++){
point->hash[i]=(first_p)malloc(sizeof(first_t));
point->hash[i]->ch='a'+i;
point->hash[i]->next=NULL;
}
point=load_memory_text("dict.txt",point);

while(1){
printf("Please input word:");
gets(str);
clear_space(str);
if(strcmp(str,"Exit")==0) return ;
else{
word_p result=search_word_text(point,str);
if(result==NULL){
word_p result2=search_word_mytext("my_dict.txt",str);
if(result2==NULL) printf("Sorry,word not found!\n");
else{
trans_p p=result2->head;
while(p!=NULL){
puts(p->trans_name);
p=p->next;
}
}
}else{
trans_p p=result->head;
while(p!=NULL){
puts(p->trans_name);
p=p->next;
}
}
}
}
}

/*2.文本词库加载到内存中，采用哈希表结构*/
array_p load_memory_text(char *filename,array_p point)
{
int i,j,m,c,flag;
FILE *fp;
word_p new_word;
trans_p new_trans,trans_head;

if((fp=fopen(filename,"r"))==NULL){
printf("Sorry,file open failed!\n");
return point;
}
while(1){
char buffer[SIZE]={'\0'},str[SIZE]={'\0'};
flag=0;
if((c=fgetc(fp))==EOF){
fclose(fp);
return point;
}
if(c=='#'){
trans_head=NULL;
i=0,j=0;
while((c=fgetc(fp))!='\n'){
buffer[i++]=c;
}
while((c=fgetc(fp))!='\n'){
if(c!='@') str[j++]=c;
else{
new_trans=create_trans_node_text(str);
trans_head=insert_trans_node_text(trans_head,new_trans);
j=0;
for(m=0;m<SIZE;m++) str[m]='\0';
}
}
new_trans=create_trans_node_text(str);
trans_head=insert_trans_node_text(trans_head,new_trans);
new_word=create_word_node_text(buffer,trans_head);
for(i=0;i<26;i++){
if(buffer[0]==point->hash[i]->ch){
flag=1;
point->hash[i]->next=insert_word_node_text(point->hash[i]->next,new_word);
break;
}
}
if(!flag){
fclose(fp);
return point;
}
}
}
}

/*3.哈希表中查找单词*/
word_p search_word_text(array_p point,char *str)
{
int i;
for(i=0;i<26;i++){
if(str[0]==point->hash[i]->ch){
word_p p=point->hash[i]->next;
while(p!=NULL){
if(strcmp(p->word_name,str)==0) return p;
else p=p->next;
}
return NULL;
}
}
return NULL;
}

/*4.自定义文本词库中查找单词*/
word_p search_word_mytext(char *filename,char *str)
{
int i;
array_p point=(array_p)malloc(sizeof(array_t));
for(i=0;i<26;i++){
point->hash[i]=(first_p)malloc(sizeof(first_t));
point->hash[i]->ch='a'+i;
point->hash[i]->next=NULL;
}
point=load_memory_text(filename,point);
word_p result=search_word_text(point,str);
return result;
}

/*5.生成解释结点*/
trans_p create_trans_node_text(char *str)
{
trans_p new=(trans_p)malloc(sizeof(trans_t));
strcpy(new->trans_name,str);
new->trans_length=strlen(str);
new->next=NULL;
return new;
}

/*6.解释结点插到解释链表尾部*/
trans_p insert_trans_node_text(trans_p head,trans_p newnode)
{
if(head==NULL){
newnode->next=NULL;
head=newnode;
}
else{
trans_p p=head;
while(p->next!=NULL) p=p->next;
newnode->next=NULL;
p->next=newnode;
}
return head;
}

/*7.生成单词结点*/
word_p create_word_node_text(char *str1,trans_p head)
{
word_p newnode=(word_p)malloc(sizeof(word_t));
strcpy(newnode->word_name,str1);
newnode->word_length=strlen(newnode->word_name);
newnode->head=head;
newnode->next=NULL;
newnode->trans_num=get_trans_num(newnode->head);
return newnode;
}

/*8.单词结点插到单词链表尾部*/
word_p insert_word_node_text(word_p head,word_p newnode)
{
if(head==NULL){
newnode->next=NULL;
head=newnode;
}
else{
word_p p=head;
while(p->next!=NULL) p=p->next;
newnode->next=NULL;
p->next=newnode;
}
return head;
}

/*9.获取某个单词的解释个数*/
int get_trans_num(trans_p head)
{
int length=0;
trans_p p=head;
while(p!=NULL){
length++;
p=p->next;
}
return length;
}

/*10.遍历哈希表*/
void print_hash(array_p point)
{
int i;
word_p p;
for(i=0;i<26;i++){
p=point->hash[i]->next;
while(p!=NULL){
puts(p->word_name);
trans_p t=p->head;
while(t!=NULL){
printf("%s;",t->trans_name);
t=t->next;
}
putchar('\n');
p=p->next;
}
}
return ;
}

/*11.遍历单词链表*/
void print_word(word_p head)
{
word_p p=head;
while(p!=NULL){
puts(p->word_name);
trans_p t=p->head;
while(t!=NULL){
printf("%s;",t->trans_name);
t=t->next;
}
putchar('\n');
p=p->next;
}
return;
}

/*12.清除字符串后的空格*/
void clear_space(char *str)
{
if(str[strlen(str)-1]==' '){
str[strlen(str)-1]='\0';
clear_space(str);
}
return ;
}

6.2 模块2代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <my_word.h>

/*---------------------------------------------------------------------------*/
/* 模块2： 建立二进制索引文件 */
/*---------------------------------------------------------------------------*/
/*1.建立二进制索引文件*/
void module2(void)
{
int i;
array_p point=(array_p)malloc(sizeof(array_t));
for(i=0;i<26;i++){
point->hash[i]=(first_p)malloc(sizeof(first_t));
point->hash[i]->ch='a'+i;
point->hash[i]->next=NULL;
}
point=load_memory_text("dict.txt",point);
build_dat_index(point,"dict.dat");
return ;
}

/*2.生成二进制索引文件*/
void build_dat_index(array_p point,char *filename)
{
FILE *fp;
long word_num,start_index;

fp=fopen(filename,"w");
fclose(fp);
index_p head=write_content_dat_index(point,filename);
start_index=write_list_dat_index(head,filename,&word_num);
write_listkey_dat_index(start_index);
write_wordnum_dat_index(word_num);
printf("%ld words has been built finished!\n",word_num);
return ;
}

/*3.将哈希表中的内容写进二进制文件，并保存每个单词所正确索引,生成目录*/
index_p write_content_dat_index(array_p point,char *filename)
{
int i;
FILE *fp;
word_p p;
trans_p t;
index_p new,head;

head=NULL;
if((fp=fopen("dict.dat","ab"))==NULL)
{
printf("Sorry,file open failed!\n");
return NULL;
}else{
for(i=0;i<26;i++){
p=point->hash[i]->next;
while(p!=NULL){
new=(index_p)malloc(sizeof(index_t));
strcpy(new->word_name,p->word_name);
new->position=ftell(fp);
new->next=NULL;
head=insert_index_node_index(head,new);

fwrite(&p->word_length,sizeof(p->word_length),1,fp);
fwrite(p->word_name,sizeof(p->word_name),1,fp);
fwrite(&p->trans_num,sizeof(p->trans_num),1,fp);
t=p->head;
while(t!=NULL){
fwrite(&t->trans_length,sizeof(t->trans_length),1,fp);
fwrite(t->trans_name,sizeof(t->trans_name),1,fp);
t=t->next;
}
p=p->next;
}
}
}
fclose(fp);
return head;
}

/*4.将目录写进dat文件，并保存目录开始的索引和目录中单词的个数*/
long write_list_dat_index(index_p head,char *filename,long *word_num)
{
FILE *fp;
int t;
index_p p=head;
index_data new