c语言基础学习12_项目实战：快译通字典

  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);//将分配内存初始化为0

    char 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;//返回读取到的字典词条数
}
......
......