英语学习系统VSCode

最新推荐文章于 2024-09-25 09:27:18 发布

一只不会编程的程序猿呀

最新推荐文章于 2024-09-25 09:27:18 发布

阅读量78

点赞数

文章标签：学习 vscode ide

本文链接：https://blog.csdn.net/m0_61392182/article/details/132914701

版权

#undef UNICODE
#undef _UNICODE
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>//随机数函数
#include<Windows.h>//语音函数
#include<math.h>
#include<easyx.h>//easy图像库
#include <conio.h>
#include<graphics.h>//图形库
#include<mmsystem.h>//包含多媒体接口
#include <sapi.h>//TTS语音
#pragma comment(lib,"Winmm.lib")//加载音频
#pragma comment(lib,"ole32.lib") //CoInitialize CoCreateInstance需要调用ole32.dll
#pragma comment(lib,"sapi.lib") //sapi.lib在SDK的lib目录,必需正确配置调用语音识别和语音合成
char mingzi[20];//一个登陆时注册时的全局变量
char shuru[8]; //一个登陆时注册时的全局变量
int q;//测试用全局变量,答案对应的系数
int f;//一些函数的返回值用
int ceshishu=1;//做过的题目的初值序号定为1
int filetype;//测试文件类型全局变量
int score;//定义一个全局变量统计全局的分数
int timu;//测试用题目数量所用全局变量
int shiyongshuming();//使用说明函数
void zhujiemian();//主界面
int read(char* word);//语音
int fnextline(FILE* fp);
void Register();//注册
void Loading();//登录
int Menu();//主菜单
int chakanyicuodanci();//查看易错单词
int seejiemian();//单词预览前面界面
void delword(); //单词删除
void addword();//单词增加
void viewword();//浏览单词
int perwordbank();//个人化单词本
int foresee(FILE* fp1, int type);//单词预览及进行测试
int RandInt(int i, int j); //随机数
void CntoEn();//测试单词(根据中文写英文）
void EntoCn();//单词选择(根据英文选择中文）
int word_test(); //单词测试
char* InttoChar(int num, char* p);//把int型转换为char型
int CntoEn1(int filetype, char* Ques, char* A, char* B, char* C, char* D, int* Ans);//根据中文选择英文函数
int EntoCn1(int filetype, char* Ques, char* A, char* B, char* C, char* D, int* Ans);//根据英文选择中文函数
int chose(int filetype, int questype, char* Ques, char* A, char* B, char* C, char* D, int* Ans);//单词测试选择题函数
int inquire(FILE* fp1, char* in); //单词查询
int score1();//分数记录函数
char* InttoChar(int num, char* p);//把把int型转换为char型（打印成绩时调用）
int findword(FILE* fp1);//单词查询备用
int scan4charnum(char* num);
struct word
{
   char zhongwen[150];
   char yingwen[150];
   int g;
};//定义一个单词信息结构体
struct stu //定义删除函数的单词信息结构体
{
   int j;
   char px[500];
   char zw[500];
};
struct yhsj //定义用户登录信息结构体
{
   char name[20];
   char password[8];
   int dkts;
};
struct ceshi {
   char zhongwen[150];
   char yingwen[150];
   int g;
};
int read(char* word)
{
   ISpVoice* pVoice = NULL; //建立声音对象
   //COM初始化：
   if (FAILED(::CoInitialize(NULL)))
       return FALSE;
   //获取ISpVoice接口：
   WCHAR a[52]; //宽字符类型
   a[0] = ' ';
   for (int i = 0; i < 50; i++)
   {
       a[i+1] = word[i];
   }

   HRESULT hr = CoCreateInstance(CLSID_SpVoice, NULL, CLSCTX_ALL, IID_ISpVoice, (void**)&pVoice);
   if (SUCCEEDED(hr))
   {
       hr = pVoice->Speak(a, 0, NULL);
       pVoice->Release();
       pVoice = NULL;
   }

   //千万不要忘记：
   ::CoUninitialize(); //释放COM资源
   return TRUE;

}
int shiyongshuming()//使用说明函数
{
   initgraph(640, 480);
   IMAGE img;
   setbkcolor(WHITE);//设置底色
   settextstyle(30, 0, "宋体");
   settextcolor(BLACK);
   setbkcolor(WHITE);//设置底色
   loadimage(&img, _T("tupian4.png"));
   putimage(0, 0, &img);
   RECT r1 = { 550, 440, 610, 470 };
   drawtext(_T("继续"), &r1, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   MOUSEMSG m;
   while (1)
   {
       m = GetMouseMsg();
       FlushMouseMsgBuffer();
       if (m.x >= 550 && m.x <= 610 && m.y >= 440 && m.y <= 470)//登陆函数作用域
       {
           setlinecolor(BLUE);
           rectangle(550, 440, 610, 470);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               zhujiemian();
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(550, 440, 610, 470);
       }
   }
   return 1;
}
unsigned int scannum()//一个扫描函数
{

   unsigned int i = 0;
   char m[10] = { '\0' };
   for (int n = 0; n < 10; n++)
   {
       scanf_s("%c", &m[n],10);
       if (m[n] < '0' || m[n] > '9')
       {
           if (m[n] == '\n')
           {
               if (n == 0)
                   i = -1;
               break;
           }
           else
               printf("input error");
       }

       i = 10 * i + m[n] - '0';
   }
   return i;
}
int fnextline(FILE* fp)//将文件指针跳转到下一行开头
{
   int f;
   char c;
   do
   {
       f=fscanf(fp, "%c", &c);
       if (feof(fp))//(0==fscanf(fp, "%c", &c))
           return -1;
   } while (c != '\n');//逐字符扫描，直到换行或文件结束
   return 0;
}
void zhujiemian()
{
   int event = 0;
   initgraph(640, 480); //生成一个640*480的绘图环境
   IMAGE img;
   setbkcolor(WHITE);//设置底色
   loadimage(&img, _T("tupian3.jpg")); //_T()是一个宏定义，用于将字符串转换为宽字符字符串
   putimage(0, 0, &img); //坐标位置的图片信息
   LOGFONT f; //LOGFONT 结构体中，该结构体包含了字体的名称、大小、粗细、斜体等信息
   gettextstyle(&f); //获取字体样式
   f.lfHeight = 50;               // 设置字体高度为 48
   _tcscpy(f.lfFaceName, _T("楷体")); //设置字体为宋体
   f.lfQuality = ANTIALIASED_QUALITY; // 设置输出效果为抗锯齿
   settextstyle(&f); // 设置字体样式
   settextcolor(BLACK); //设置字体颜色
   outtextxy(180, 100, "背单词软件"); //指定坐标位置输出文本内容
   outtextxy(205, 150, "欢迎使用");
   RECT r1 = { 0, 200, 300, 400 }; //定义矩形r1，分别表示左上角坐标为(0,200)，右下角坐标为(300,400)的矩形
   RECT r2 = { 300, 200, 600, 400 }; //定义矩形r2，分别表示左上角坐标为(300,200)，右下角坐标为(600,400)的矩形
   drawtext(_T("登录"), &r1, DT_CENTER | DT_VCENTER | DT_SINGLELINE); //用于在指定的矩形区域内绘制文本，第一个参数是要绘制的文本内容，第二个参数是矩形区域的位置和大小，
   drawtext(_T("注册"), &r2, DT_CENTER | DT_VCENTER | DT_SINGLELINE); //第三个参数是绘制文本的格式，包括居中对齐、垂直对齐和单行显示等
   settextstyle(30, 0, "宋体"); //settextstyle函数用于设置文字的字体、大小和风格 0表示普通字体
   outtextxy(180, 450, "若没有账户请先注册"); //指定坐标位置输出文本内容
   MOUSEMSG m; //定义一个鼠标结构
   while (1)
   {
       m = GetMouseMsg(); //获取当前鼠标信息
       FlushMouseMsgBuffer(); //清空消息缓冲区
       if (m.x >= 100 && m.x <= 200 && m.y >= 250 && m.y <= 350)//登陆函数作用域，检测鼠标是否在屏幕上的一个矩形区域内
       {
           setlinecolor(BLUE); //绘图中线条的颜色变为蓝色
           rectangle(100, 275, 200, 325); //蓝色矩形
           if (m.uMsg == WM_LBUTTONDOWN) //左键按下
           {
               closegraph(); //关闭图形
               Loading();
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(100, 275, 200, 325);
       }
       if (m.x >= 400 && m.x <= 500 && m.y >= 275 && m.y <= 325)//注册函数鼠标作用域
       {
           setlinecolor(BLUE);
           rectangle(400, 275, 500, 325);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               Register();
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(400, 275, 500, 325);
       }

   }
}
void Register() //用户名注册
{
   int dk = 1; //打卡数
   char yonghuming1[20], mima1[8], mima2[8], mima3[8], mm[8]; //用户名，第一次设的密码，第一次确认的密码，第一次确认密码错误时第二次确认的密码，最终存入文件的密码。
   FILE* fp;
   fp = fopen("zhuce.txt", "w+");
   if (!fp)
   {
       printf("file error\n");
       exit(1);
   };
   printf("请注册你的用户名(用户名不超过20位字符与数字):\n");
   scanf_s("%s", yonghuming1, 20);
   printf("请输入密码（密码不超过8位字符与数字）:\n");
   scanf_s("%s", mima1, 8);
   printf("请确认密码:\n");
   scanf_s("%s", mima2, 8);
   if (!strcmp(mima1, mima2)) //如果第一次输入的密码与确认的密码一致则注册成功。
   {
       strcpy_s(mm, mima1);
       fprintf(fp, "%s %s %d\n", yonghuming1, mm, dk); //用户名与密码还有初始打卡数存入文件。
       fclose(fp);//关闭文件
       printf("注册成功!\n");
       printf_s("请按任意键进入登录\n");
       f=getchar();//停顿
       f=getchar();//停顿
       system("cls");
       Loading();//进入登陆函数
   }
   else
   {
       printf("请再次确认密码:\n");
       scanf_s("%s", mima3,8);
       if (!strcmp(mima1, mima3)) //若第一次不一致则需第二次确认一致。
       {
           strcpy_s(mm, mima1);
           fprintf(fp, "%s %s %d\n", yonghuming1, mm, dk); //用户名与密码还有初始打卡数存入文件。
           fclose(fp);//关闭文件
           printf("恭喜你，注册成功！\n");
           printf_s("请按任意键进入登录\n");
           f=getchar();//停顿
           f=getchar();//停顿
           system("cls");
           Loading();//进入登陆函数
       }
       else
       {
           printf("注册失败!\n");
           printf("请按任意键退出系统：");
           f=getchar(); //密码两次确认不一致则注册失败直接退出。
           exit(1);
       }
   }
}
void Loading() //登录
{
   int f;
   int ch = 0; //中间变量，用来判断用户名是否存在。
   struct yhsj static yhxx[1000]; //定义结构体数组，用来存储用户信息
   int i = 0; //循环变量
   FILE* fp; //定义文件指针
   fp = fopen("zhuce.txt", "r");//以只读的形式打开用户数据文件
   if (!fp)
   {
       printf("file error!\n");
       exit(1);
   } //若打开失败，则退出程序
   printf("请输入用户名登录:\n");
   scanf_s("%s", mingzi, 20); //将用户输入的信息存储到字符数组中
   f = fscanf(fp, "%s%s%d", &yhxx[i].name, &yhxx[i].password, &yhxx[i].dkts);
   while (!feof(fp))
   {
       i++;
       f = fscanf(fp, "%s%s%d", &yhxx[i].name, &yhxx[i].password, &yhxx[i].dkts);
   } //将文件里所有的用户信息读入结构体
   fclose(fp); //关闭文件
   for (i = 0; i < 1000; i++)
   {
       if (!strcmp(mingzi, yhxx[i].name)) //判断用户数据文件里是否有与之相配的用户名
       {
           ch = 1; //若存在该用户名，则将ch赋值为1；
           printf("请输入密码：\n");
           scanf_s("%s", shuru, 8);
           if (!strcmp(shuru, yhxx[i].password)) //将用户输入的密码与用户数据文件中的密码比对
           {
               printf("登录成功！（请按回车进入主菜单）\n");
               f = getchar(); //停顿
               f = getchar(); //停顿
               system("cls");
               Menu();
           }
           else
           {
               printf("密码错误，请重新输入：\n");
               scanf_s("%s", shuru, 8);
               if (!strcmp(shuru, yhxx[i].password)) //再次进行密码比对
               {
                   printf("登录成功！（请按回车进入主菜单）\n");
                   f = getchar();
                   f = getchar();
                   system("cls");
                   Menu();
               }
               else
               {
                   printf("输入错误次数过多，为保护用户安全，再次输入时将退出系统，再见！\n");
                   f = getchar();
                   f = getchar();
                   exit(1); //密码输入次数超限，停顿后直接结束程序。
               }
           }
       }
   }
   if (ch == 0) //用户数据文件里找不到该用户名，引导进行用户注册
   {
       int y;
       printf("无此用户名，请注册！\n");
       y = getchar();
       y = getchar();
       printf_s("请按回车符返回注册！");
       while (1)
       {
           if (getchar() == '\n')
           {
               Register();
               break;
           }
           else
           {
               printf_s("温馨提示：请按回车返回注册！");
           }
       }
       exit(1);
   }
}
int Menu()//菜单函数
{
   initgraph(640, 480);//创建一个图形窗口
   IMAGE img;
   setbkcolor(WHITE);//设置底色
   settextcolor(RED);
   loadimage(&img, _T("tupian3.jpg"));
   putimage(0, 0, &img);//加载图片到窗口
   settextstyle(50, 0, "楷体");
   RECT r0 = { 0,0,600,50 };
   drawtext(_T("背单词系统程序"), &r0, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   settextstyle(40, 0, "宋体");
   settextcolor(BLACK);
   RECT r1 = { 0, 40, 300, 140 };
   RECT r2 = { 0, 180, 300, 280 };
   RECT r3 = { 0, 350, 300, 450 };
   RECT r4 = { 320, 40, 550, 140 };
   RECT r5 = { 320, 180, 550, 280 };
   RECT r6 = { 320, 350, 550, 450 };
   drawtext(_T("单词查询"), &r1, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   drawtext(_T("单词预览学习"), &r2, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   drawtext(_T("背单词模式"), &r3, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   drawtext(_T("个人单词本"), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   drawtext(_T("成绩记录"), &r5, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   drawtext(_T("复习计划"), &r6, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   MOUSEMSG m;
   FILE* fp1 = fopen("word.txt", "r");
   FILE* fp2 = fopen("dictionary.txt", "r+");
   while (1)
   {
       m = GetMouseMsg();
       FlushMouseMsgBuffer();
       if (m.x >= 70 && m.x <= 230 && m.y >= 70 && m.y <= 110)//登陆函数作用域
       {
           setlinecolor(RED);
           rectangle(70, 70, 230, 110);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               while (findword(fp2)) {}
               {
                   fclose(fp2);
                   fseek(fp2, 0L, 0);
                   Menu();
               }

           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(70, 70, 230, 110);
       }
       if (m.x >= 30 && m.x <= 270 && m.y >= 210 && m.y <= 250)//单词预览学习
       {
           setlinecolor(RED);
           rectangle(30, 210, 270, 250);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               while (seejiemian()) {};
               break;
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(30, 210, 270, 250);
       }
       if (m.x >= 50 && m.x <= 250 && m.y >= 380 && m.y <= 420)//单词测试鼠标选择
       {
           setlinecolor(RED);
           rectangle(50, 380, 250, 420);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               while (word_test()) {};
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(50, 380, 250, 420);
       }
       if (m.x >= 335 && m.x <= 535 && m.y >= 70 && m.y <= 110)//个人单词本点击
       {
           setlinecolor(RED);
           rectangle(335, 70, 535, 110);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               while (perwordbank()) {};

}

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(335, 70, 535, 110);
       }
       if (m.x >= 355 && m.x <= 515 && m.y >= 210 && m.y <= 250)//登陆函数作用域
       {
           setlinecolor(RED);
           rectangle(355, 210, 515, 250);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               while (score1()) {};
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(355, 210, 515, 250);
       }
       if (m.x >= 355 && m.x <= 515 && m.y >= 380 && m.y <= 420)//单词测试鼠标选择
       {
           setlinecolor(RED);
           rectangle(355, 380, 515, 420);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               while (chakanyicuodanci());
               break;
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(355, 380, 515, 420);
       }
   }

   return 1;
}
void delword()//单词删除
{
   system("cls");
   int f;
   printf_s("单词删除\n");
   int ch = 0, count = 0, count1 = 0; //定义整型数
   char del[20] = { 0 }; //定义字符数组，用来存储用户输入的（需要删除的）内容
   struct stu static dcsj[1000] = { '\0' };//定义结构体数组，用来存储单词数据
   int i = 0;
   FILE* fp1;
   fp1 = fopen("perword.txt", "r+"); //文件指针指向个人词库
   if (!fp1) //判断文件是否成功打开
   {
       printf("file error\n");
       exit(1);
   }
   f = fscanf(fp1, "%d %s %s ", &dcsj[i].j, dcsj[i].px, dcsj[i].zw); //将文件中的单词数据读出并存储到结构体数组
   while (!feof(fp1))
   {
       i++;
       f = fscanf(fp1, "%d %s %s ", &dcsj[i].j, dcsj[i].px, dcsj[i].zw);
       count = i;
   }
   printf("请输入你要删除的单词（中文或英文）：\n");
   scanf_s("%s", del, 20); //读取用户需要删除的单词
   for (i = 0; i < count + 1; i++) //判断文件中有没有用户想要删除的单词
   {
       if (!strcmp(del, dcsj[i].px)) //进行英文比对
       {
           ch = 1; //改变ch的值，便于之后判断是否找到该单词
           printf("已找到该单词并删除!\n");
           count1 = i; //记录单词在结构体数组中的位置
           break; //若找到单词则退出for循环
       }
       if (!strcmp(del, dcsj[i].zw)) //进行中文比对
       {
           ch = 1;
           printf("已找到该单词并删除!\n");
           count1 = i;
           break;
       }
   }
   if (ch == 0) //若找不到该单词，则运行此步骤
   {
       printf("查不到该单词！\n");
       printf_s("将要返回主菜单！");
       printf("请按回车返回菜单！\n");
       f = getchar();
       f = getchar();
       perwordbank();
   }
   dcsj[count].j = 0; //对结构体数组进行赋值，便于之后for循环的终止
   for (i = count1; i < count; i++) //从要删除的单词的位置开始，进行for循环，依次将单词“往前移”，覆盖要删除的单词
   {
       dcsj[i] = dcsj[i + 1];
   }
   i = 0; //对i进行重新赋值
   fclose(fp1);
   fp1 = fopen("perword.txt", "w");
   printf_s("删除后的单词为：\n");
   while (dcsj[i].j != 0) //输出更新后的单词
   {
       fprintf(fp1, "%d %s %s \n", i + 1, dcsj[i].px, dcsj[i].zw);
       printf("%d %s %s\n", i + 1, dcsj[i].px, dcsj[i].zw);
       i++;
   }
   fclose(fp1);
   printf_s("请按回车返回上一级菜单！\n");
   f = getchar();
   f = getchar();
   perwordbank();//在此使用递归，没有别的更好的办法了
}
void addword()//单词增加
{
   system("cls");
   int f;
   int i = 0, n = 0;
   char en[20] = { '\0' }, cn[40] = { '\0' }, rev[60] = { '\0' };
   FILE* fp1; //定义文件指针
   fp1 = fopen("perword.txt", "r+"); //文件指针指向文件
   if (!fp1) //判断文件是否成功打开
   {
       printf("file error\n");
       exit(1);
   };
   fseek(fp1, -4L, 2);//定位到倒数1字节
   i = -1;
   do
   {
       i++;
       f = fscanf(fp1, "%c", &rev[i]);
       fseek(fp1, -2L, 1);
   } while (rev[i] != '\n');
   f = fscanf(fp1, "%d", &n);//记录最后的编号
   n++;
   system("cls");
   printf("请输入你要增加的单词。例：\napple 苹果\n");
   f = scanf("%s %s", en, cn);
   fseek(fp1, 0L, 2);//定位到最后
   fprintf(fp1, "%d %s %s\n", n, en, cn);//写入单词
   fclose(fp1); //关闭文件
   printf_s("添加成功！\0");
   printf_s("请按回车返回上一级菜单");
   f = getchar();
   f = getchar();
   perwordbank();//返回上一级菜单
   return;
}
void viewword()
{
   system("cls");
   printf("输入本次浏览的单词数并按回车（0为返回）\n");
   int i = scannum();
   FILE* fp1; //定义文件指针
   fp1 = fopen("perword.txt", "r"); //文件指针指向文件,以只读的形式打开
   if (!fp1) //判断文件是否成功打开
   {
       printf("file error\n");
       exit(1);
   };
   int n;
   char en[20];
   char cn[40];
   while (i > 0)
   {
       for (int j = 0; j < i; j++)
       {
           fscanf(fp1, "%d %s %s", &n, en, cn);
           fnextline(fp1);
           if (feof(fp1))
           {
               i = 0;
               printf("浏览完毕，按回车返回上一级菜单\n");
               getchar();
               getchar();
               perwordbank();//返回个人单词本函数
               break;
           }

           printf("%d %s %s\n", n, en, cn);
       }
       int m = scannum();
       if (m != -1)
           i = m;
   }
   fclose(fp1);

   return;
}
int perwordbank()//个人化单词本
{
   initgraph(640, 480);//创建一个图形窗口
   IMAGE img;
   setbkcolor(WHITE);//设置底色
   loadimage(&img, _T("tupian3.jpg"));
   putimage(0, 0, &img);//加载图片到窗口
   settextstyle(40, 0, "宋体");
   RECT r1 = { 200,20,400,100 };
   RECT r2 = { 200, 140, 400, 220 };
   RECT r3 = { 200, 240, 400, 320 };
   RECT r4 = { 200,340,400,420 };
   settextcolor(BLACK);
   drawtext(_T("单词删除"), &r1, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   drawtext(_T("单词增加"), &r2, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   drawtext(_T("单词浏览"), &r3, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   drawtext(_T("返回"), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   settextstyle(50, 0, "楷体");
   settextcolor(RED);
   outtextxy(20, 30, "个");
   outtextxy(20, 100, "人");
   outtextxy(20, 170, "单");
   outtextxy(20, 240, "词");
   outtextxy(20, 310, "本");
   MOUSEMSG m;
   while (1)
   {
       m = GetMouseMsg();
       FlushMouseMsgBuffer();
       if (m.x >= 220 && m.x <= 380 && m.y >= 40 && m.y <= 80)//删除单词鼠标点击
       {
           setlinecolor(RED);
           rectangle(220, 40, 380, 80);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               delword();
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(220, 40, 380, 80);
       }
       if (m.x >= 220 && m.x <= 380 && m.y >= 160 && m.y <= 200)//增加单词点击
       {
           setlinecolor(RED);
           rectangle(220, 160, 380, 200);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               addword();//跳转对应添加单词的子函数
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(220, 160, 380, 200);
       }
       if (m.x >= 220 && m.x <= 380 && m.y >= 260 && m.y <= 300)//浏览单词鼠标选择
       {
           setlinecolor(RED);
           rectangle(220, 260, 380, 300);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               viewword(); //跳转对应浏览单词的子函数
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(220, 260, 380, 300);
       }
       if (m.x >= 260 && m.x <= 340 && m.y >= 360 && m.y <= 400)//个人单词本点击
       {
           setlinecolor(RED);
           rectangle(260, 360, 340, 400);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               Menu();//菜单函数
               return 0;

}

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(260, 360, 340, 400);
       }
   }
   return 1;
}
int seejiemian()
{
   initgraph(640, 480);
   IMAGE img;
   loadimage(&img, _T("tupian3.jpg"));
   putimage(0, 0, &img);
   setbkcolor(WHITE);//设置底色
   settextstyle(30, 0, "宋体");
   settextcolor(BLACK);
   RECT r2 = { 200 ,80,460,120 };
   drawtext(_T("从头开始预览"), &r2, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r3 = { 200,180,460,220 };
   drawtext(_T("接着上次预览"), &r3, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r4 = { 240,280,340,320 };
   drawtext(_T("返回"), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   int type = 0;
   FILE* fp1 = fopen("word.txt", "r+");//直接词库进行测试
   settextstyle(50, 0, "楷体");
   settextcolor(RED);
   outtextxy(500, 80, "选");
   outtextxy(500, 140, "择");
   outtextxy(500, 200, "预");
   outtextxy(500, 260, "览");
   outtextxy(500, 320, "位");
   outtextxy(500, 380, "置");
   while (1)
   {
       MOUSEMSG m;
       m = GetMouseMsg();
       FlushMouseMsgBuffer();
       if (m.x >= 220 && m.x <= 430 && m.y >= 80 && m.y <= 120)
       {
           setlinecolor(RED);
           rectangle(220, 80, 430, 120);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               type = 0;//从头开始预览
               closegraph();
               foresee(fp1, type);
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(220, 80, 430, 120);
       }
       if (m.x >= 220 && m.x <= 430 && m.y >= 180 && m.y <= 220)
       {
           setlinecolor(RED);
           rectangle(220, 180, 430, 220);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               type = 1;//接着上次开始预览
               closegraph();
               foresee(fp1, type);
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(220, 180, 430, 220);
       }
       if (m.x >= 240 && m.x <= 340 && m.y >= 280 && m.y <= 320)//返回
       {
           setlinecolor(RED);
           rectangle(240, 280, 340, 320);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               Menu();//返回菜单
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(240, 280, 340, 320);
       }
   }
   return 0;
}
int foresee(FILE* fp1, int type)//type 0从头开始，type 1 接上次结束
{
   printf("输入本次浏览的单词数并按回车（输入0终止）\n");
   char c;
   scanf_s("%c", &c,1);
   if (c != '\n')
       ungetc(c, stdin);
   int i = scannum();
   int j;
   int n, n1 = 0;
   FILE* fp2;
   if (type == 1)
   {
       fp2 = fopen("test.txt", "r+");//以写形式打开
       int num;

       while (feof(fp2)==0)
       {

           fscanf(fp2, "%d", &num);
           fnextline(fp2);
       }
       while (num > 0)
       {
           fnextline(fp1);
           num--;
       }
   }
   else if (type == 0)
   {
       fp2 = fopen("test.txt", "w+");//以写形式创建
   }
   else
   {
       printf("函数调用不规范");
       return -1;
   }
   fseek(fp2, 0L, 2);
   char en[20];
   char cn[40];
   while (i > 0)
   {
       for (j = 0; j < i; j++)
       {

           if ((0 == fscanf(fp1, "%d %s %s", &n, en, cn)) || (n == n1))
           {
               printf("词库浏览完毕");
               i = 0;
               break;
           }
           fnextline(fp1);
           n1 = n;
           printf("%d %s %s\n", n, en, cn);
           fprintf(fp2, "%d %s %s\n", n, en, cn);
       }
       int m;
       m = scannum();
       if (m != -1)
           i = m;
   }
   fclose(fp2);
   printf("0.返回 1.测试\n");
   int k;
   scanf("%c", &c);
   if (c != '\n')
       ungetc(c, stdin);
   system("cls");
   scanf_s("%d", &k);
   if (k == 1)
   {
       word_test();
   }
   Menu();
   return 0;
}
int RandInt(int i, int j) //随机数函数，为根据英文选择中文模块提供随机数
{
   int l;
   int* k;
   srand((unsigned int)time(0));//随机数初始化
   k = (int*)malloc(sizeof(int));//分配动态内存
   //printf("%d", unsigned int(&l));
   l = (unsigned long int(rand() + (unsigned int(&l) + (unsigned int(k))))) % (j - i + 1) + i;
   free(k);
   return l;
}
void CntoEn() // 根据中文选择英文
{
   initgraph(640, 480);
   IMAGE img;
   loadimage(&img, _T("tupian3.jpg"));
   putimage(0, 0, &img);
   setbkcolor(WHITE);//设置底色
   settextstyle(30, 0, "宋体");
   settextcolor(BLACK);
   RECT r1 = { 0,30,100,60 };
   drawtext(_T("中文："), &r1, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   rectangle(100, 25, 500, 65);
   RECT r2 = { 0,80,100,120 };
   drawtext(_T("A："), &r2, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r3 = { 0,140,100,180 };
   drawtext(_T("B："), &r3, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r4 = { 0,200,100,240 };
   drawtext(_T("C："), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r5 = { 0,260,100,300 };
   drawtext(_T("D："), &r5, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r6 = { 280,410,370,440 };
   drawtext(_T("返回"), &r6, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r7 = { 280,350,370,380 };
   drawtext(_T("下一个"), &r7, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r8 = { 400,350,640,380 };
   drawtext(_T("查询效果"), &r8, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   FILE* fp2;
   fp2 = fopen("test.txt", "r+");//以写形式打开
   FILE* fp3;
   fp3 = fopen("correct.txt", "w+");//以更新模式打开
   int filetype = 0;
   int Ans;
   srand((unsigned int)time(0));//随机数初始化
   char Ques[150] = { '\0' }, A[150] = { '\0' }, B[150] = { '\0' }, C[150] = { '\0' }, D[150] = { '\0' };
   CntoEn1(filetype, Ques, A, B, C, D, &Ans);
int j = 130;
   settextstyle(20, 0, "宋体");
   outtextxy(120, 450, "注：继续背诵表示用户未答题或者是选择错误");
   outtextxy(j, 30, Ques);//第一次打印出问题
   outtextxy(j, 85, A);//打印出选项，以下也是如此
   outtextxy(j, 150, B);
   outtextxy(j, 205, C);
   outtextxy(j, 265, D);
   srand((unsigned int)time(0));//随机数初始化
   while (1)
   {
       MOUSEMSG m;
       m = GetMouseMsg();
       FlushMouseMsgBuffer();
       if (m.x >= 0 && m.x <= 100 && m.y >= 80 && m.y <= 120)//选项
       {
           setlinecolor(RED);
           rectangle(0, 80, 100, 120);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               q = 1;
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(0, 80, 100, 120);
       }
       if (m.x >= 0 && m.x <= 100 && m.y >= 140 && m.y <= 180)//B选项
       {
           setlinecolor(RED);
           rectangle(0, 140, 100, 180);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               q = 2;
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(0, 140, 100, 180);
       }
       if (m.x >= 0 && m.x <= 100 && m.y >= 200 && m.y <= 240)//C选项
       {
           setlinecolor(RED);
           rectangle(0, 200, 100, 240);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               q = 3;
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(0, 200, 100, 240);
       }
       if (m.x >= 0 && m.x <= 100 && m.y >= 260 && m.y <= 300)//D选项
       {
           setlinecolor(RED);
           rectangle(0, 260, 100, 300);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               q = 4;
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(0, 260, 100, 300);
       }
       if (m.x >= 280 && m.x <= 370 && m.y >= 410 && m.y <= 440)//返回
       {
           setlinecolor(RED);
           rectangle(280, 410, 370, 440);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               fclose(fp3);
               word_test();//返回上一级菜单
               break;
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(280, 410, 370, 440);
       }
       if (m.x >= 280 && m.x <= 370 && m.y >= 350 && m.y <= 380)//下一题
       {
           setlinecolor(RED);
           rectangle(280, 350, 370, 380);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               for (int k = 0; k < 150; k++)
               {
                   Ques[k] = { '\0' }; A[k] = { '\0' }; B[k] = { '\0' }; C[k] = { '\0' }; D[k] = { '\0' };
               }
               settextcolor(BLACK);
               clearrectangle(130, 80, 450, 120);//清空之前题目的打印内容
               clearrectangle(130, 140, 540, 180);
               clearrectangle(130, 200, 540, 240);
               clearrectangle(130, 260, 540, 300);
               clearrectangle(130, 30, 550, 50);
               clearrectangle(550, 30, 680, 50);
               q = 5;//进入下一题之前该改变答案的序号以备下一题使用
               CntoEn1(filetype, Ques, A, B, C, D, &Ans);
               timu++;//timu全局变量改变
               int j = 130;
               settextstyle(20, 0, "宋体");
               outtextxy(j, 30, Ques);
               outtextxy(j, 85, A);
               outtextxy(j, 150, B);
               outtextxy(j, 205, C);
               outtextxy(j, 265, D);
               char zhongwen[150] = { '\0' };
               char yingwen[150] = { '\0' };
               //下面是把正确答案对应的内容复制给char yingwen[150]
               if (Ans == 1)
               {
                   for (int m = 0;A[m]!='\0' ; m++)
                   {
                       yingwen[m] = A[m];
                   }
               }
               if (Ans == 2)
               {
                   for (int m = 0; B[m] != '\0'; m++)
                   {
                       yingwen[m] = B[m];
                   }
               }
               if (Ans == 3)
               {
                   for (int m = 0; C[m] != '\0'; m++)
                   {
                       yingwen[m] = C[m];
                   }
               }
               if (Ans == 4)
               {
                   for (int m = 0; D[m] != '\0'; m++)
                   {
                       yingwen[m] = D[m];
                   }
               }
               for (int j = 0;Ques[j]!='\0'; j++)
               {
                   zhongwen[j] = Ques[j];
               }
               fprintf_s(fp3, " %d %s %s \n", ceshishu, yingwen, zhongwen);
               ceshishu++;
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(280, 350, 370, 380);
       }
       if (q == Ans)//判断用户选择是否与答案一致
       {
           settextstyle(30, 0, "楷体");
           settextcolor(RED);
           outtextxy(550, 30, "恭");
           outtextxy(550, 80, "喜");
           outtextxy(550, 130, "答");
           outtextxy(550, 180, "对");
           score++;//答对个数++
       }
       else if (q != Ans)//如果用户选择选项与答案不符合，显示继续答题
       {
           settextstyle(30, 0, "楷体");
           settextcolor(RED);
           outtextxy(550, 30, "继");
           outtextxy(550, 80, "续");
           outtextxy(550, 130, "背");
           outtextxy(550, 180, "诵");
       }
       if (m.x >= 450 && m.x <= 600 && m.y >= 350 && m.y <= 380)//查询分数
       {
           setlinecolor(RED);
           rectangle(450, 350, 600, 380);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               fclose(fp3);
               score1();//跳转查询效果界面
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(450, 350, 600, 380);
       }

   }
}
void EntoCn() //选择
{
   initgraph(640, 480);
   IMAGE img;
   loadimage(&img, _T("tupian3.jpg"));
   putimage(0, 0, &img);
   setbkcolor(WHITE);//设置底色
   settextstyle(30, 0, "宋体");
   settextcolor(BLACK);
   RECT r1 = { 0,30,100,60 };
   drawtext(_T("英文："), &r1, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   rectangle(100, 25, 500, 65);
   RECT r2 = { 0,80,100,120 };
   drawtext(_T("A："), &r2, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r3 = { 0,140,100,180 };
   drawtext(_T("B："), &r3, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r4 = { 0,200,100,240 };
   drawtext(_T("C："), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r5 = { 0,260,100,300 };
   drawtext(_T("D："), &r5, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r6 = { 280,430,370,460 };
   drawtext(_T("返回"), &r6, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r7 = { 280,350,370,380 };
   drawtext(_T("下一个"), &r7, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r8 = { 400,350,640,380 };
   drawtext(_T("查询效果"), &r8, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   FILE* fp2;
   fp2 = fopen("test.txt", "r+");//以写形式打开
   FILE* fp3;
   fp3 = fopen("correct.txt", "w+");//以更新模式打开
   int filetype = 0;
   int Ans;
   score = 0;
   char Ques[150] = { '\0' }, A[150] = { '\0' }, B[150] = { '\0' }, C[150] = { '\0' }, D[150] = { '\0' };
   EntoCn1(filetype, Ques, A, B, C, D, &Ans);
   int j = 130;
   settextstyle(20, 0, "宋体");
   outtextxy(j, 30, Ques);
   outtextxy(j, 85, A);
   outtextxy(j, 150, B);
   outtextxy(j, 205, C);
   outtextxy(j, 265, D);
   read(Ques);
   settextstyle(30, 0, "楷体");
   outtextxy(550, 30, "开");
   outtextxy(550, 80, "始");
   outtextxy(550, 130, "背");
   outtextxy(550, 180, "诵");

   while (1)
   {
       MOUSEMSG m;
       m = GetMouseMsg();
       FlushMouseMsgBuffer();
       if (m.x >= 0 && m.x <= 100 && m.y >= 80 && m.y <= 120)
       {
           setlinecolor(RED);
           rectangle(0, 80, 100, 120);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               q = 1;

           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(0, 80, 100, 120);
       }
       if (m.x >= 0 && m.x <= 100 && m.y >= 140 && m.y <= 180)//
       {
           setlinecolor(RED);
           rectangle(0, 140, 100, 180);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               q = 2;

           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(0, 140, 100, 180);
       }
       if (m.x >= 0 && m.x <= 100 && m.y >= 200 && m.y <= 240)//登陆函数作用域
       {
           setlinecolor(RED);
           rectangle(0, 200, 100, 240);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               q = 3;

}

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(0, 200, 100, 240);
       }
       if (m.x >= 0 && m.x <= 100 && m.y >= 260 && m.y <= 300)//登陆函数作用域
       {
           setlinecolor(RED);
           rectangle(0, 260, 100, 300);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               q = 4;
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(0, 260, 100, 300);
       }
       if (m.x >= 280 && m.x <= 370 && m.y >= 430 && m.y <= 460)//
       {
           setlinecolor(RED);
           rectangle(280, 430, 370, 460);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               fclose(fp3);
               closegraph();
               word_test();
               break;
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(280, 430, 370, 460);
       }
       if (m.x >= 280 && m.x <= 370 && m.y >= 350 && m.y <= 380)//
       {
           setlinecolor(RED);
           rectangle(280, 350, 370, 380);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               for (int k = 0; k < 150; k++)
               {
                   Ques[k] = { '\0' }; A[k] = { '\0' }; B[k] = { '\0' }; C[k] = { '\0' }; D[k] = { '\0' };
               }
               settextcolor(BLACK);
               clearrectangle(130, 80, 550, 120);//清空之前题目的打印内容
               clearrectangle(130, 140, 550, 180);
               clearrectangle(130, 200, 550, 240);
               clearrectangle(130, 260, 550, 300);
               clearrectangle(130, 30, 550, 50);
               q = 5;//进入下一题之前该改变答案的序号以备下一题使用
               EntoCn1(filetype, Ques, A, B, C, D, &Ans);

               timu++;
               int j = 130;
               settextstyle(20, 0, "宋体");
               outtextxy(j, 30, Ques);
               outtextxy(j, 85, A);
               outtextxy(j, 150, B);
               outtextxy(j, 205, C);
               outtextxy(j, 265, D);
               read(Ques);
               char zhongwen[150] = { '\0' };
               char yingwen[150] = { '\0' };
               //下面是把正确答案对应的内容复制给char yingwen[150]
               if (Ans == 1)
               {
                   for (int m = 0; A[m] != '\0'; m++)
                   {
                       zhongwen[m] = A[m];
                   }
               }
               if (Ans == 2)
               {
                   for (int m = 0; B[m] != '\0'; m++)
                   {
                       zhongwen[m] = B[m];
                   }
               }
               if (Ans == 3)
               {
                   for (int m = 0; C[m] != '\0'; m++)
                   {
                       zhongwen[m] = C[m];
                   }
               }
               if (Ans == 4)
               {
                   for (int m = 0; D[m] != '\0'; m++)
                   {
                       zhongwen[m] = D[m];
                   }
               }
               for (int j = 0; Ques[j] != '\0'; j++)
               {
                   yingwen[j] = Ques[j];
               }
               fprintf_s(fp3, " %d %s %s \n", ceshishu, yingwen, zhongwen);
               ceshishu++;

           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(280, 350, 370, 380);
       }
       if (q == Ans)
       {
           settextstyle(30, 0, "楷体");
           settextcolor(RED);
           outtextxy(550, 30, "恭");
           outtextxy(550, 80, "喜");
           outtextxy(550, 130, "答");
           outtextxy(550, 180, "对");
           score++;

       }
       else if (q != Ans)
       {
           settextstyle(30, 0, "楷体");
           settextcolor(RED);
           outtextxy(550, 30, "继");
           outtextxy(550, 80, "续");
           outtextxy(550, 130, "背");
           outtextxy(550, 180, "诵");
       }
       if (m.x >= 450 && m.x <= 600 && m.y >= 350 && m.y <= 380)//查询分数
       {
           setlinecolor(RED);
           rectangle(450, 350, 600, 380);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               fclose(fp3);
               closegraph();
               score1();
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(450, 350, 600, 380);
       }

   }
}
int word_test() //单词测试
{
   initgraph(640, 480);//创建一个图形窗口
   IMAGE img;
   loadimage(&img, _T("tupian3.jpg"));
   putimage(0, 0, &img);//加载图片到窗口
   setbkcolor(WHITE);//设置底色
   settextstyle(30, 0, "宋体");
   settextcolor(BLACK);
   RECT r1 = { 120,20,480,100 };
   RECT r2 = { 120, 140, 480, 220 };
   RECT r3 = { 120, 240, 480, 320 };
   RECT r4 = { 200,340,400,420 };
   drawtext(_T("背单词模式一"), &r1, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   drawtext(_T("背单词模式二"), &r2, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   drawtext(_T("重置学习记录"), &r3, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   drawtext(_T("返回"), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
settextstyle(50, 0, "楷体");
   settextcolor(BLUE);
   outtextxy(550, 50, "背");
   outtextxy(550, 110, "诵");
   outtextxy(550, 170, "模");
   outtextxy(550, 240, "式");
   outtextxy(550, 310, "选");
   outtextxy(550, 380, "择");
   MOUSEMSG m;
   while (1)
   {
       m = GetMouseMsg();
       FlushMouseMsgBuffer();
       if (m.x >= 210 && m.x <= 390 && m.y >= 45 && m.y <= 75)//根据中文写英文鼠标点击
       {
           setlinecolor(RED);
           rectangle(210, 45, 390, 75);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               CntoEn();
               return 1;
               //跳转根据中文写英文子函数
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(210, 45, 390, 75);
       }
       if (m.x >= 210 && m.x <= 390 && m.y >= 165 && m.y <= 195)//根据英文选择中文点击
       {
           setlinecolor(RED);
           rectangle(210, 165, 390, 195);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               EntoCn();
               return 1;
               //跳转根据英文选择中文子函数
           }

       }
       else
       {
           setlinecolor(BLACK);
           rectangle(210, 165, 390, 195);
       }
       if (m.x >= 210 && m.x <= 390 && m.y >= 265 && m.y <= 295)
       {
           setlinecolor(RED);
           rectangle(210, 265, 390, 295);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               remove("chose.txt");
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(210, 265, 390, 295);
       }
       if (m.x >= 270 && m.x <= 330 && m.y >= 365 && m.y <= 395)
       {
           setlinecolor(RED);
           rectangle(270, 365, 330, 395);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               Menu();//跳转菜单子函数
               return 0;
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(270, 365, 330, 395);
       }
   }
}
int CntoEn1(int filetype, char* Ques, char* A, char* B, char* C, char* D, int* Ans)
{
   chose(filetype, 0, Ques, A, B, C, D, Ans);
   return 0;
}
int EntoCn1(int filetype, char* Ques, char* A, char* B, char* C, char* D, int* Ans)
{
   chose(filetype, 1, Ques, A, B, C, D, Ans);
   return 0;
}
int chose(int filetype, int questype, char* Ques, char* A1, char* B1, char* C1, char* D1, int* Ans) //文件类型、问题类型、题目、四个选项和答案
{//filetype 0 dictionary.txt;1 test.txt//questype 0 CntoEn;1 EntoCn;
   int y = 0;
   FILE* fp1, * locate;
   char odr[7] = { '\0' }, cn[100] = { '\0' }, cns[100] = { '\0' }, en[20] = { '\0' }, ens[20] = { '\0' }, null[15] = { '\0' };
   int num;
   char* A, * B, * C, * D, A0[50] = { '\0' }, B0[50] = { '\0' }, C0[50] = { '\0' }, D0[50] = { '\0' };
   A = A0; B = B0; C = C0; D = D0;
   locate = fopen("chose.txt", "r+");
   if (locate == 0)
   {
       locate = fopen("chose.txt", "w");
       fprintf(locate, "0000000000000000");//16个0；存放4个4位数
       fclose(locate);
       locate = fopen("chose.txt", "r+");
   }
   if (filetype == 0)//根据filetype决定打开的文件
   {
       fp1 = fopen("dictionary.txt", "r");
   }
   else if (filetype == 1)//根据filetype决定打开的文件
   {
       fp1 = fopen("test.txt", "r");
       fseek(locate, 4L, 1);
   }
   else
   {
       return 0;
   }
   if (questype == 1)
   {
       fseek(locate, 8L, 1);//根据问题类型跳转数据存储位置
   }
   int odrn = fscanf(locate, "%c%c%c%c", &odr[0], &odr[1], &odr[2], &odr[3]);
   num = scan4charnum(odr) + 1;//测试位置为num
   fseek(locate, -4L, 1);
   if (num < 1000)//把num转化为字符串，补0
   {
       fprintf(locate, "0");
       if (num < 100)
       {
           fprintf(locate, "0");
           if (num < 10)
           {
               fprintf(locate, "0");
           }
       }
   }
   fprintf(locate, "%d", num);
   while (num > 1)//跳转到第num行
   {
       num--;
       fnextline(fp1);
   }
   int i = 0;
   y=fscanf(fp1, "%d ", &num);//格式化读取内容
   i = -1;
   do//读入英文
   {
       i++;
       y=fscanf(fp1, "%c", &en[i]);
   } while (((en[i] >= 'a' && en[i] <= 'z') || (en[i] >= 'A' && en[i] <= 'Z')) && i < 20);
   i = 1;
   do//吃掉空格
   {
       y=fscanf(fp1, "%c", &cn[0]);
   } while (cn[0] == ' ');

   do//读入中文
   {
       y=fscanf(fp1, "%c", &cn[i]);
       if (cn[i] == ' ')//((cn[i] >= 'a' && cn[i] <= 'z') || (cn[i] >= 'A' && cn[i] <= 'Z'))
       {
           cn[i] = '\0';
           break;
       }
       i++;
   } while (i < 40);
   fclose(fp1);
   fp1 = fopen("dictionary.txt", "r");//从字典中获取错误选项
   int RandOrder[4];//存放4个选项的序数
   int j = 0;
   i = 0;
   while (i < 4)//随机产生4个选项的序数
   {
       RandOrder[i] = RandInt(0, 200 - i); //生成一个长度为200的随机整数数组，数组中的每个元素都是0到200之间的整数，且每个元素只出现一次
       while (j < i)
       {
           if (RandOrder[j] <= RandOrder[i])
           {
               RandOrder[i]++;
           }
           j++;
       }
       i++;
   }
   i = 0, j = 0;
   int tAns = RandInt(1024, 65536) % 4 + 1;//随机正确答案填充位置
   *Ans = tAns;

   if (questype == 1)//对应EntoCn函数
   {
       for (int i = 0; en[i] != '\0' && i < 20; i++)
           *(Ques + i) = en[i];

       for (i = 0; i < 4; i++)
       {
           while (RandOrder[i] > 0)
           {
               RandOrder[i]--;
               fnextline(fp1);
           }
           y=fscanf(fp1, "%d %s %s", &j, ens, cns);//记录随机位置内容
           //printf("\n\n%d \n%s \n%s", j, ens, cns);
           for (j = 0; ens[j] == en[j]; j++)//比较随机内容是否恰好正确
           {
               if (ens[j] == '\0' && en[j] == '\0')
               {
                   *Ans = i + 1;
                   break;
               }
           }
           switch (i + 1)//填充选项
           {
           case 1:
           /*   memset(A, 0, sizeof(A));*/
               for (int i = 0; cns[i] != '\0' && i < 40; i++)
                   *(A + i) = cns[i];

               break;
           case 2:
           /*   memset(B, 0, sizeof(B));*/
               for (int i = 0; cns[i] != '\0' && i < 40; i++)
                   *(B + i) = cns[i];

               break;
           case 3:
           /*   memset(C, 0, sizeof(C));*/
               for (int i = 0; cns[i] != '\0' && i < 40; i++)
                   *(C + i) = cns[i];

               break;
           case 4:
               /*memset(D, 0, sizeof(D));*/
               for (int i = 0; cns[i] != '\0' && i < 40; i++)
                   *(D + i) = cns[i];

               break;
           default:
               break;
           }

           fseek(fp1, 0L, 0);
       }
       int i = 0;
       switch (*Ans)
       {
       case 1:
           for ( i = 0; cn[i] != '\0' && i < 40; i++)
               *(A + i) = cn[i];
           *(A + i) = '\0';
           break;
       case 2:
           for ( i = 0; cn[i] != '\0' && i < 40; i++)
               *(B + i) = cn[i];
           *(B + i) = '\0';
           break;
       case 3:
           for ( i = 0; cn[i] != '\0' && i < 40; i++)
               *(C + i) = cn[i];
           *(C + i) = '\0';
           break;
       case 4:
           for (i = 0; cn[i] != '\0' && i < 40; i++)
               *(D + i) = cn[i];
           *(D + i) = '\0';
           break;
       default:
           break;
       }
   }
   if (questype == 0)//对应CntoEn函数
   {
       for (int i = 0; cn[i] != '\0' && i < 40; i++)
           *(Ques + i) = cn[i];
       for (i = 0; i < 4; i++)
       {
           while (RandOrder[i] > 0)
           {
               RandOrder[i]--;
               fnextline(fp1);
           }
           y=fscanf(fp1, "%d %s %s", &j, ens, cns);//记录随机位置内容
           for (j = 0; ens[j] == en[j]; j++)//比较随机内容是否恰好正确
           {
               if (ens[j] == '\0' && en[j] == '\0')
               {
                   *Ans = i + 1;
                   break;
               }
           }
           switch (i + 1)//填充选项
           {
           case 1:
               for (int i = 0; ens[i] != '\0'; i++)
                   *(A + i) = ens[i];
               break;
           case 2:
               for (int i = 0; ens[i] != '\0'; i++)
                   *(B + i) = ens[i];
               break;
           case 3:
               for (int i = 0; ens[i] != '\0'; i++)
                   *(C + i) = ens[i];
               break;
           case 4:
               for (int i = 0; ens[i] != '\0'; i++)
                   *(D + i) = ens[i];
               break;
           default:
               break;
           }
           fseek(fp1, 0L, 0);
       }
       int i = 0;

       switch (*Ans)
       {
       case 1:
           for (; en[i] != '\0'; i++)
               *(A + i) = en[i];
           *(A + i) = '\0';
           break;
       case 2:
           for (; en[i] != '\0'; i++)
               *(B + i) = en[i];
           *(B + i) = '\0';
           break;
       case 3:
           for (; en[i] != '\0'; i++)
               *(C + i) = en[i];
           *(C + i) = '\0';
           break;
       case 4:
           for (; en[i] != '\0'; i++)
               *(D + i) = en[i];
           *(D+ i) = '\0';
           break;
       default:
           break;
       }
   }
   //填充最终的选项
   for (int i = 0; (*(A + i) != ' ' && *(A + i) != '\0'); i++)
   {
       *(A1 + i) = *(A + i);
   }
   for (int i = 0; (*(B + i) != ' ' && *(B + i) != '\0'); i++)
   {
       *(B1 + i) = *(B + i);
   }
   for (int i = 0; (*(C + i) != ' ' && *(C + i) != '\0'); i++)
   {
       *(C1 + i) = *(C + i);
   }
   for (int i = 0; (*(D + i) != ' ' && *(D + i) != '\0'); i++)
   {
       *(D1 + i) = *(D + i);
   }
   fclose(locate);
   return 0;
}
int scan4charnum(char* num)//将num中存放的4位数字转化为int型输出
{
   int ret = 0;
   for (int i = 0; i < 4; i++)
   {
       ret = ret * 10 + (*num - 48);
       num++;
   }
   return ret;
}
int inquire(FILE* fp, char* in) //单词查询
{
   FILE* fp1 = fp;
   char tempin[40] = { '\0' }, file[400] = { '\0' };
   int p = 40;
   int i = 0, j = 0, flag = -1;
   if ((*in >= 'a' && *in <= 'z') || (*in >= 'A' && *in <= 'Z'))
       p = 20;
   for (i = 0; *(in + i) != '\0'; i++)
   {
       tempin[i] = *(in + i);
   }
   int bfscan = 1;
   while (bfscan != 0)
   {

       if (fscanf(fp1, "%d %s %s", &file[0], &file[20], &file[40]) == 0 || file[0] == flag)
       {
           fnextline(fp1);
           printf("未查询到“%s”\n", in);
           return 0;
       }
       flag = file[0];
       for (j = 0; (j <= i && tempin[j] == file[p + j] && tempin[j - 1] != '\0'); j++)
       {
           if (j == i)
           {
               bfscan = 0;
               j = 0;
               do
               {
                   fscanf(fp1, "%c", &file[100 + j]);
                   j++;
               } while (file[100 + j] != '\n' && j < 300);//判断输出条件(file[100 + j] >= ' ' && file[100 + j] <= '~');
           }
       }
       fnextline(fp1);

}

   printf("%s %s\n", &file[20], &file[40]);
   i = 0;
   while (i < j && file[100 + i] != '\n')
   {
       printf("%c", file[100 + i]);
       i++;
   }
   read(&file[20]);
   printf("\n");
   return 0;
}
int findword(FILE* fp1)
{
   initgraph(640, 480);
   IMAGE img;
   loadimage(&img, _T("tupian3.jpg"));
   putimage(0, 0, &img);
   setbkcolor(WHITE);//设置底色
   settextstyle(30, 0, "宋体");
   settextcolor(BLACK);
   char in[40] = { '\0' };
   system("cls");
   printf("请输入你要查询的单词(输入0返回上一级菜单)例如complain\n");
   int flag = -1; char c;
   while (flag == -1)
   {
       do
       {
           scanf_s("%c", &c,1);
       } while (c == '\n');
       system("cls");
       printf("请输入你要查询的单词(输入0以退出)例如complain\n");

       if (c == '0')
       {
           return 0;
       }
       else
       {
           ungetc(c, stdin);
       }

       scanf_s("%s", in,40);
       inquire(fp1, in);
       fseek(fp1, 0L, 0);
   }
return 1;
}
int chakanyicuodanci()//查看易错单词
{
   initgraph(640, 480);
   IMAGE img;
   loadimage(&img, _T("tupian3.jpg"));
   putimage(0, 0, &img);
   setbkcolor(WHITE);//设置底色
   settextstyle(40, 0, "宋体");
   settextcolor(BLACK);
   struct word static correct[1000] = { '\0' };
   FILE* fp4 = fopen("correct.txt", "r+");
   int i = 0, d;
   d = fscanf(fp4, "%d %s %s", &correct[i].g, correct[i].yingwen, correct[i].zhongwen);
   while (!feof(fp4))//把文件中的信息都读进结构体中
   {
       i++;
       d = fscanf(fp4, "%d %s %s", &correct[i].g, correct[i].yingwen, correct[i].zhongwen);
   }
   RECT r1 = { 0,100,120,140 };
   drawtext(_T("单词："), &r1, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r2 = { 0,160,120,200 };
   drawtext(_T("释义："), &r2, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r3 = { 200,300,340,340 };
   drawtext(_T("下一个"), &r3, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r4 = { 200,380,340,420 };
   drawtext(_T("返回"), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   settextstyle(30, 0, "宋体");
   outtextxy(20, 50, "要复习：");
   char a[10] = {'\0'};
   InttoChar(i+1, a);
outtextxy(140, 50, *a);
   outtextxy(140, 50, *(a+1));
int j = 0;
   settextstyle(30, 0, "楷体");
   outtextxy(120, 110, correct[j].yingwen);
   outtextxy(120, 170, correct[j].zhongwen);
   read(correct[j].yingwen);
   while (1)
   {
       MOUSEMSG m;
       m = GetMouseMsg();
       FlushMouseMsgBuffer();
       if (m.x >= 200 && m.x <= 340 && m.y >= 300 && m.y <= 340)//下一题
       {
           setlinecolor(RED);
           rectangle(200, 300, 340, 340);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               j++;
               clearrectangle(120, 100, 550, 140);//清空之前题目的打印内容
               clearrectangle(120, 160, 550, 200);
               outtextxy(120, 100, correct[j].yingwen);
               outtextxy(120, 160, correct[j].zhongwen);
               read(correct[j].yingwen);
               while (j > i- 1)
               {
                   settextcolor(BLUE);
                   settextstyle(20, 0, "方正舒体");
                   outtextxy(500, 20, "恭喜你！");
                   outtextxy(500, 40, "复习完成！");
               }
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(200, 300, 340, 340);
       }
       if (m.x >= 200 && m.x <= 340 && m.y >= 380 && m.y <= 420)//返回
       {
           setlinecolor(RED);
           rectangle(200, 380, 340, 420);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               Menu();
           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(200, 380, 340, 420);
       }

   }
   fclose(fp4);//关闭文件
   return 0;
}
int score1()//分数记录函数
{
   initgraph(640, 480);
   IMAGE img;
   loadimage(&img, _T("tupian3.jpg"));
   putimage(0, 0, &img);
   setbkcolor(WHITE);//设置底色
   settextstyle(50, 0, "楷体");
   settextcolor(RED);
   RECT r1 = { 200,50,400,90 };
   drawtext(_T("成长记录"), &r1, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r2 = { 100,200,240,240 };
   settextstyle(20, 0, "楷体");
   settextcolor(BLACK);
   settextstyle(40, 0, "宋体");
   drawtext(_T("评价："), &r2, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r5 = { 0,250,280,290 };
   drawtext(_T("成长活力值："), &r5, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   RECT r6 = { 0,330,280,370 };
   drawtext(_T("测试题目总数："), &r6, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   char p[10] = { '\0' };
   InttoChar(score, p);
   settextstyle(40, 0, "楷体");
   outtextxy(300, 250, *p);
   outtextxy(300, 250, *(p+1));
   char o[10] = { '\0' };
   InttoChar(timu, o);
   outtextxy(300, 330, *o);
   outtextxy(300, 330, *(o+1));
   if (score > 5 && score < 10)//如果答对题的个数大于5打印你真棒到界面
   {
       clearrectangle(200, 200, 500, 240);
       RECT r4 = { 200 ,200,500,240 };
       drawtext(_T("你真棒！"), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
       char pingjia[20] = { "nice" };
       read(pingjia);
   }
   if (score <= 5)
   {
       clearrectangle(200, 200, 500, 240);
       RECT r4 = { 200 ,200,500,240 };
       drawtext(_T("再接再励！"), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
       char pingjia[20] = {"come on" };
       read(pingjia);

   }
   if (score >= 10 && score < 15)
   {
       clearrectangle(200, 200, 500, 240);
       RECT r4 = { 200 ,200,500,240 };
       drawtext(_T("干的漂亮！"), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
       char pingjia[20] = { "good" };
       read(pingjia);

   }
   if (score >= 15)
   {
       clearrectangle(200, 200, 500, 240);
       RECT r4 = { 200 ,200,500,240 };
       settextstyle(40, 0, "宋体");
       drawtext(_T("你真优秀！"), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
       char pingjia[20] = { "beautiful" };
       read(pingjia);

   }
   RECT r3 = { 260,400,340,440 };
   drawtext(_T("返回"), &r3, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
   while (1)
   {
       MOUSEMSG m;
       m = GetMouseMsg();
       FlushMouseMsgBuffer();
       if (m.x >= 260 && m.x <= 340 && m.y >= 400 && m.y <= 440)
       {
           setlinecolor(RED);
           rectangle(260, 400, 340, 440);
           if (m.uMsg == WM_LBUTTONDOWN)
           {
               closegraph();
               Menu();

           }
       }
       else
       {
           setlinecolor(BLACK);
           rectangle(260, 400, 340, 440);
       }
   }
   return 0;
}
char* InttoChar(int num, char* p)//把int型转换为char型
{
   char q[10] = { '\0' };
   int n = num, m = 0, i = 0, j = 0;
   for (i = 0; n > 0; i++)
   {
       m = n % 10;               //最后一位赋给m
       q[i] = m + 48;           //m转化为字符存进q[i]
       n /= 10;               //把n的最后一位截去
   }
   for (j = 0, i--; j <= i; j++)
   {
       *(p + j) = q[i - j];   //把q逆序存进p
   }
   *(p + j) = '\0';           //字符串结束
   return p;
}
int main() //主函数
{
   shiyongshuming();
   zhujiemian();
   srand((unsigned int)time(0));//随机数初始化
   while (Menu());//菜单函数
   return 0;
}