1 #define _CRT_SECURE_NO_WARNINGS
  2 #include <stdio.h>
  3 #include <stdlib.h>
  4 #include <string.h>
  5 #include <time.h>
  6
  7 #define MAX 111111 //最大记录数
  8
  9 struct dict
 10 {
 11     char *key;//key代表词条，是普通的指针，不是数组，目前还不是字符串，只是char类型的指针变量。
 12     char *content;//content代表词条的翻译，是普通的指针，不是数组，目前还不是字符串，只是char类型的指针变量。
 13 };
 14
 15
 16 void format_string(char *str)//去掉字符串结尾的回车和空格字符
 17 {
 18     size_t i;
 19     for(i = strlen(str) - 1; i >= 0; i--)//从右往左遍历字符串
 20     {
 21         if (str[i] != '\n' && str[i] != ' ' && str[i] != '\r')
 22         {
 23             str[i + 1] = '\0';
 24             break;
 25         }
 26     }
 27 }
 28
 29 //打开字典文件，并读取文件内容
 30 int open_dict(struct dict **p, const char *dict_filename)
 31 {
 32     FILE *pfile = fopen(dict_filename, "r");
 33     if (pfile == NULL)
 34         return 0;//打开文件失败，函数返回0。说明打开的文件不存在。目的是：为了避免乱操作、误操作，导致程序崩溃，这也是程序的健壮性。
 35
 36     //要在该函数open_dict内部给外部main函数的指针p来分配内存，怎么做呢？答：要把外部的指针的地址传递给open_dict，所以open_dict的参数需要用二级指针，到这是c语言常用的小技巧。
 37     //struct dict **p 给二级指针分配内存，用*p一级指针。
 38     *p = (struct dict *)malloc(sizeof(struct dict) * MAX);//固定分配MAX大小内存，执行完这句后，相当于main函数里面的p就指向了堆中的一块有效内存，该堆内存的大小为sizeof(struct dict) * MAX个字节。
 39     memset(*p, 0, sizeof(struct dict) * MAX);//将分配到的堆内存初始化为0
 40
 41     char buf[1024] = { 0 };
 42     size_t len = 0;
 43     int i = 0;//计数器
 44     while (!feof(pfile))//循环读取文件，直到文件末尾
 45     {
 46         memset(buf, 0, sizeof(buf));//读之前先把缓存buf清零(清空)。
 47         fgets(buf, sizeof(buf), pfile);//从文件读取文件一行
 48         len = strlen(buf);//得到读取到的字符串长度
 49         if (len > 0)//如果读到的这一行不是空行，就执行以下代码。
 50         {
 51             //*p相当于堆内存中的一个数组名。(*p)[i]的意思是：数组里面下标为i的结构变量。(*p)[i].key结构变量的成员key。
 52             (*p)[i].key = (char *)malloc(len);//根据字符串长度分配相应的堆内存
 53             memset((*p)[i].key, 0, len);//好习惯：任何分配出来的一块内存后，都要先把它清空(置零)后再使用。
 54             format_string(buf);//去掉字符串结尾的空格和回车
 55             strcpy((*p)[i].key, &buf[1]);//将读取到的内容拷贝到key中
 56             //free((*p)[i].key);//有专门的释放堆内存的函数。
 57         }
 58
 59         memset(buf, 0, sizeof(buf));
 60         fgets(buf, sizeof(buf), pfile);
 61         len = strlen(buf);
 62         if (len > 0)
 63         {
 64             (*p)[i].content = (char *)malloc(len);
 65             memset((*p)[i].content, 0, len);
 66             format_string(buf);
 67             strcpy((*p)[i].content, &buf[6]);
 68             //free((*p)[i].key);//有专门的释放堆内存的函数。
 69         }
 70
 71         i++;//计数器加1
 72     }
 73     fclose(pfile);//关闭字典文件
 74
 75     return i;//返回读取到的字典词条数
 76 }
 77
 78 //根据关键字key,在字典中查找内容
 79 int search_dict(const struct dict *p, int size, const char *key, char *content)
 80 {
 81     int i = 0;
 82     for (i = 0; i < size; i++)//遍历字典
 83     {
 84         //容错代码。
 85         if ((p[i].key == NULL) || (p[i].content == NULL))
 86             continue;
 87
 88         if (strcmp(p[i].key, key) == 0)
 89         {
 90             strcpy(content, p[i].content);
 91             return 1;//找到符合条件记录，返回1
 92         }
 93     }
 94     return 0;//没有找到符合条件记录，返回0
 95 }
 96
 97 //释放内存
 98 void free_dict(struct dict *p, int size)
 99 {
100     int i = 0;
101     for (i = 0; i < size; i++)//循环释放key与content成员内存
102     {
103         if (p[i].key)
104             free(p[i].key);
105         if (p[i].content)
106             free(p[i].content);
107     }
108     free(p);//释放p内存
109 }
110
111 int main(int argc, char *args[])
112 {
113     if (argc < 2)
114     {
115         printf("usage: %s dict-filename\n", args[0]);
116         return 0;//参数不足，程序退出
117     }
118     long start_ms = 0;//记录函数执行的开始时间
119     long end_ms = 0;//记录函数执行的结束时间
120     auto struct dict *p = NULL;
121     start_ms = clock();//得到系统当前时间，单位是ms。是long类型的一个值。
122
123     //要通过在函数open_dict的内部给main函数里面的指针p分配内存，需要传递指针p的地址给该函数open_dict，这是c语言里面一个最基本的技巧。
124     int dict_size = open_dict(&p, args[1]);//根据命令行第一个参数作为字典文件名，打开字典文件
125     if (dict_size == 0)
126         return 0;//打开字典文件失败，程序退出，表示要打开的文件不存在。目的是：为了避免乱操作、误操作，导致程序崩溃，这也是程序的健壮性。
127
128     end_ms = clock();//得到系统当前时间，单位是ms。是long类型的一个值。
129     printf("open_dict used %ld ms\n", end_ms - start_ms);//打印函数执行时间，单位：毫秒，是long类型的一个值。
130
131     char key[1024];
132     char content[1024];
133     while (1)
134     {
135         memset(key, 0, sizeof(key));
136         memset(content, 0, sizeof(content));
137         fgets(key, sizeof(key), stdin);//从键盘得到用户输入
138         format_string(key);//去掉字符串结尾的空格和回车
139         if (strncmp(key, "command=exit", 12) == 0)
140             break;
141
142         start_ms = clock();//得到系统当前时间，单位是ms。是long类型的一个值。
143         //dict_size是读取到的字典词条数。
144         if (search_dict(p, dict_size, key, content))//根据用户输入，在字典中检索
145         {
146             printf("%s\n", content);
147         } else
148         {
149             printf("not found\n");
150         }
151         end_ms = clock();//得到系统当前时间，单位是ms。是long类型的一个值。
152         printf("search_dict used %ld ms\n", end_ms - start_ms);//打印函数执行时间，单位：毫秒
153     }
154
155     start_ms = clock();
156     free_dict(p, dict_size);
157     end_ms = clock();
158     printf("free_dict used %ld ms\n", end_ms - start_ms);//打印函数执行时间，单位：毫秒
159     return 0;
160 }

......
......
//第一次读文件得到文件的词条数(每个循环读两行数据)。
int get_dict_size(FILE *pfile)//得到字典文件中词条总数
{if (pfile == NULL)return 0;int i = 0;char buf[2048];while (!feof(pfile)){fgets(buf, sizeof(buf), pfile);fgets(buf, sizeof(buf), pfile);i++;//读取两行后，计数器加1
    }return i;//执行过该函数后，指针到了文件的末尾了，为了能再次从文件中读出内容，需要在main函数的循环读取文件之前将指针设置在文件的开始位置。如下：//fseek(pfile, 0L, SEEK_SET);//设置读取位置为字典文件的开始位置。
}//打开字典文件，并读取文件内容
int open_dict(struct dict **p, const char *dict_filename)
{FILE *pfile = fopen(dict_filename, "r");if (pfile == NULL)return 0;//打开文件失败，函数返回int dict_size = get_dict_size(pfile);//得到字典文件中词条总数if (dict_size == 0)return 0;//第二次打开文件后根据文件实际的词条数来分配堆内存。*p = (struct dict *)malloc(sizeof(struct dict) * dict_size);//根据字典文件词条总数分配内存memset(*p, 0, sizeof(struct dict) * dict_size);//将分配内存初始化为0char buf[2048] = { 0 };size_t len = 0;int i = 0;fseek(pfile, 0L, SEEK_SET);//设置读取位置为字典文件的开始位置while (!feof(pfile))//循环读取文件，直到文件末尾
    {memset(buf, 0, sizeof(buf));fgets(buf, sizeof(buf), pfile);//读取文件一行len = strlen(buf);//得到读取到字符串长度if (len > 0){(*p)[i].key = (char *)malloc(len);//根据字符串长度分配内存memset((*p)[i].key, 0, len);format_string(buf);//去掉字符串结尾的空格和回车strcpy((*p)[i].key, &buf[1]);//将读取到的内容拷贝到key中
        }memset(buf, 0, sizeof(buf));fgets(buf, sizeof(buf), pfile);len = strlen(buf);if (len > 0){(*p)[i].content = (char *)malloc(len);memset((*p)[i].content, 0, len);strcpy((*p)[i].content, &buf[6]);}i++;}fclose(pfile);//关闭字典文件return i;//返回读取到的字典词条数
}
......
......

......
......
//打开字典文件，并读取文件内容
int open_dict(struct dict **p, const char *dict_filename)
{FILE *pfile = fopen(dict_filename, "r");if (pfile == NULL)return 0;//打开文件失败，函数返回//一开始就分配一个结构体struct dict的堆内存。读完一个词条后再读的时候我再加一个词条的内存。*p = (struct dict *)malloc(sizeof(struct dict));memset(*p, 0, sizeof(struct dict));char buf[2048] = { 0 };size_t len = 0;int i = 0;while (!feof(pfile))//循环读取文件，直到文件末尾
    {memset(buf, 0, sizeof(buf));fgets(buf, sizeof(buf), pfile);//读取文件一行len = strlen(buf);//得到读取到字符串长度if (len > 0){(*p)[i].key = (char *)malloc(len);//根据字符串长度分配内存memset((*p)[i].key, 0, len);format_string(buf);//去掉字符串结尾的空格和回车strcpy((*p)[i].key, &buf[1]);//将读取到的内容拷贝到key中
        }memset(buf, 0, sizeof(buf));fgets(buf, sizeof(buf), pfile);len = strlen(buf);if (len > 0){(*p)[i].content = (char *)malloc(len);memset((*p)[i].content, 0, len);strcpy((*p)[i].content, &buf[6]);}i++;//边读边随时增加struct dict在堆中的数量。*p = (struct dict *)realloc(*p, (1 + i) * sizeof(struct dict));//把新增的堆内存清零(置零)。memset(*p + i, 0, sizeof(struct dict));}fclose(pfile);//关闭字典文件return i;//返回读取到的字典词条数
}
......
......