C语言实现背单词软件（系统级别）

采用多种巩固模式，包括「英文选意」（给英文，选对应释义）、「中文选词」（给中文，选对应单词）、「听音辨意」（听读音，选对应单词）、「听音速记」（语音播放单词+例句）、「拼写填空」（补全单词）、「拼写组合」（已知中文，从给出的一些字母组合选出正确的几个部分，拼出单词）、「全拼练习」（给例句，关键词留空，根据中文意思填写。个人单词本，可以让用户存入自己想要存放的单词。作用：本函数功能是个人单词本下辖的

一个编程的菜鸡

7224人浏览 · 2023-02-28 12:41:01

一个编程的菜鸡 · 2023-02-28 12:41:01 发布

一、软件需求说明书

1 引言

1.1编写目的

编写这份系统需求说明书的目的是在于充分考虑用户使用此系统时产生的各种需求，并且通过调研，整合管理各类需求，并进行需求验证。本系统需求说明书的预期读者主要针对本系统开发者和对外介绍推广使用。

1.2 背景

本项目的任务提出者是系统开发小组指导老师居老师，项目开发者是系统开发小组，用户是电子科技大学全校学生，可以用该单词软件进行简单的学习。

1.3 定义

C小程序	通过C编程，达到某种功能的小程序
系统需求	指用户对于系统在功能，性能等方面的期望
OOA	面向对象分析

2 任务概述

2.1 目标

1. 测试词库不小于 200，含英文单词拼写、汉语解释，例句和例句翻译

2. 英汉词典功能：给出英文拼写，输出汉语解释和例句以及例句翻译；

3. 账号功能：账号管理，多用户学习结果处理；

4. 背单词功能 1：随机给出一组单词拼写，选择或输入汉语解释，并判断正误，

记分统计，可配合学习计划；按用户账号进行统计；

5. 背单词功能 2：随机给出单词汉语解释，选择或输入英文单词，并判断正误，

记分统计，可配合学习计划；按用户账号进行统计；

扩展功能

除基本功能外，结合需求分析，给出词库管理、学习计划管理，软件界面，单词

发音，单词填空，并根据记忆曲线进行复习巩固等其他功能；

2.2 用户的特点

用户特点：对于英语有需求的任何人。并且希望在短时间内能够记忆一定数量的

单词。

2.3市场上软件的调查分析

1.扇贝：优点：

1.界面为薄荷绿，简洁清新 2.方便打卡，提醒记忆

3.记录成果，看到成长

4.四种记忆方式（自评，回忆，探索，小结)，如右图

5.有趣味学习功能（短语学单词，视频学单词）

6.有着高效的复习方式（单词测试，例句测试

缺点：

1.第一次登录选择了要背的单词包之后不能更改。

2.看不到要背的单词总量，剩余单词量或者剩余计划时间，天天背单词却不知道什么时候到头，没有成就刺激。

2.百词斩：

优点：

1.采用象形记忆，内容有趣，不再枯燥

2.单词计划明显，便于查看和调整计划

3.记忆模式多样（图片选择、英文选意、听音选单词、中文选词、拼写组合等，尽可能地加深你的记忆）

4.趣味学习功能

单词电台：电台活泼有趣，深度讲解单词，举例使用场景。二是，因为是语音，可以随时听，坐车听、走路听、吃饭也能听。

单词TV：一个几十秒的小视频介绍一个单词，表现形式或是场景对话、或是形近词辨析、或是电影片段配台词

采用多种巩固模式，包括「英文选意」（给英文，选对应释义）、「中文选词」（给中文，选对应单词）、「听音辨意」（听读音，选对应单词）、「听音速记」（语音播放单词+例句）、「拼写填空」（补全单词）、「拼写组合」（已知中文，从给出的一些字母组合选出正确的几个部分，拼出单词）、「全拼练习」（给例句，关键词留空，根据中文意思填写。

缺点：

1.一些抽象概念的单词很难用图片表达出来，所以你还需要费劲巴拉地想哪个图片对应该单词；

2.英语单词一词多义很常见，但是限于“一词配一图”，记的单词的意思会比较单一。也就是说，熟词生义做的不够到位。

3.知米背单词：

优点:

1.可以免费阅读英文名著,通过阅读积累词汇。

推送英文新闻。

2.记忆方式多样，三种记忆方式（每个单词以三种形式出现。第一次是单个单词出现，第二次以短语或者句子的形式出现，第三次以选词填空形式出现。一步一步不断加深你对单词的了解，进而掌握单词的使用方法，记住单词。）

3.两种复习方式：①生词复习：「全拼练习」+「首字母填空」+「听音辨意」+「听音复习」。②熟词复习：巩固熟词。

4.趣味学习功能。

缺点：

1.可提供英文阅读书籍目前还比较少。（数据库还不够大）2.界面有待优化

4.墨墨背单词：

1.单词发音是英式

2.背单词和复习单词时分别有三个按钮：认识，不确定，不认识/认识、模糊、忘记了，精细地根据你的记忆情况来判断你对单词的掌握情况，决定单词在未来学习中的出现次数。

3.时刻监控你的遗忘曲线，结合艾宾浩斯遗忘曲线和你自己的遗忘特征定制你的学习计划。

4.记忆方式：2种模式

「看英文回忆中文」（快速认知单词）+「看中文回忆英文」（深入记忆单词，并验证拼写）。

「看英文回忆中文」和扇贝的自评模式有点类似，通过例句的提示，引导你猜测单词的意思

「看中文回忆英文」这个方式不建议学习新单词的时候使用，适合用来复习学过的单词

缺点：1.学习单词有上限。2.诱导消费购买词量。

2.5调查商用软件功能总结优点：

记忆方式：自评学习、回忆学习、探索学习、小结学习、短语学习、视频学习、音频学习、图片学习

学习/复习方式：英文选意、中文选词、图片选择、听词选意、拼写填空、听音拼词

优化：可修改自选词库、单词倒计时计划、英文文章阅读、场景学习、遗忘曲线复习、覆盖多语种

特色趣味功能：签到打卡、PK模式、闯关模式

2.6用户功能需求

1.用户能够选择查询的的单词，导入或导出

2.用户可以选择自己是否需要详细的解释（熟词生义，英文释义）

3.用户可以将自己的不熟悉的单词添加进入生词本，形成个人化的生词本

4.用户可以自己选择需要的单词包

5.用户可以根据自己的需求选择自己喜欢的界面，更换背单词的背景

6.用户自己制定学习计划

7.用户自己安排学习周期

8.形音义多管齐下

9.利用“艾宾浩斯记忆曲线”使得单词重复出现

10.根据遗忘曲线安排单词复习

2.7本阶段软件需求规格

1 词库从词库源的导入模块（词库）

此模块代码应实现将单词从特定文件中导入词库中。

2 单词删除功能模块（删除）

此模块代码应实现从词库中删除特定的单词的功能。

3 单词增加功能模块（增加单词）

此模块代码应实现在现有词库中添加特定单词，或这从别的词库源文件中添加特定单词到词库中的功能。

4 单词搜索功能模块（搜索）

此模块代码应实现从现有词库中搜索特定单词，并将其返回给用户以达到词典的功能。

5 输入判断功能模块（输入判断）

此模块代码应实现判断用户输入英文内容与所要求的内容之间是否相同

6 选择判断功能模块（选择判断）

此模块代码应实现判断用户选择的中文是否正确的功能

7 随机给出英文模块（匹配选项）

此模块代码应实现随机出现单词中的英文，并出现4个中文选项，其中一个是正确的中文翻译，其余三个随机在词库中选取即可。

8 随机给出中文模块

此模块代码应实现随机出现词库中单词的中文，并要求用户输入其对应的英文单词。

9 创建账户模块

此模块代码应实现用户的创建和删除。

10 错误单词加强功能

此模块应实现统计同一用户单词错误情况，并在此模式下训练用户对自身错误多的单词的加强。

2.8升级功能

计分功能

对用户每次单词测试的成绩进行记录，以便用户查看自己的学习情况。

界面模块

用easyX做一些菜单界面，提升用户的使用体验

二、可行性研究报告

1 编写目的

编写这份系统需求说明书的目的是在于充分考虑用户使用此系统时产生的各种需求，并且通过调研，整合管理各类需求，并进行需求验证。

本系统需求说明书的预期读者主要针对本系统开发者和对外介绍推广使用。

2 所建议的系统（技术可行性）

本系统在技术可行性方面，需要满足风险、资源、技术分析。

风险分析：

本软件系统采用合理技术录入学生信息，并整理，可供用户查询修改。但学生信息由管理员录入，有可能出现失误，因此设置信息的删除和修改功能。可以通过风险分析。

资源分析：

本软件系统的资源主要来自电子科技大学官方以及个人用户发布，需要一定的用户基数才有实现的价值和意义。并且，该系统的设计人员都具有所负责方面的经验，因此可以通过资源分析。

技术分析：

本软件系统采用的VS2019。本次做的暂且是试用版，离正式投入使用还要与前端技术结合进行修改强化。其不涉及移动设备的操作系统约束：Android 系

统生态复杂，若要做到全适配，将会消耗大量的财力人力，iOS 系统 App 发布审核过程复杂，消耗精力。网页端和客户端涉及到用户注册将会从不同程度上涉及到用户隐私。因此可以通过技术分析

3 使用方面的可行性

本软件系统基于VS2019，利用C编写，操作简便，安全可靠。

4 结论

能够进行单词查询，单词背诵，单词预览，个人单词本功能，单词的强化复习，单词的学习效果等方面功能的完成。

三、系统设计说明书

1.面向对象设计

1.1前提说明

引用的头文件和限定语

#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>

#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 filetype;//测试文件类型全局变量

int score = 0;//定义一个全局变量统计全局的分数

int timu;//测试用题目数量所用全局变量

声明的函数

int filetype1();//测试文件选择函数

int shiyongshuming();//使用说明函数

void zhujiemian();//主界面

int fnextline(FILE* fp);

void Register();//注册

void Loading();//登录

int Menu();//主菜单

int fuxi();//复习计划

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);

int  yuyin(int argc, char* argv[]);//语音

定义的结构体变量

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;

};

1.2 系统设计

本背单词程序系统主要有各个不同的大的功能组成。

单词查询	单词预览	背单词模式
个人单词本	复习计划	分数记录（学习效果）

每个大的功能的背后又由诸多个小的功能组成。

个人单词本			单词删除delword函数
			单词增加addword函数
			单词浏览viewword函数
单词查询			findword(FILE* fp1)函数
			Inquire 函数
复习计划			Cuokanyicuodanci函数
			Fuxi函数
分数记录			InttoChar函数
			Score1函数
背单词模式	根据中文背诵英文模式CntoEn	给chose函数定义问题类型函数CntoEn1	chose函数提供正确内容以及正确答案对应选项位置，和其他的错误选项，选择背诵模式参数	随机数函数 RandInt
				转化函数scan4charnum(char* num);
	根据英文背诵中文模式EntoCn	给chose函数定义问题类型函数 EntoCn1		回车数字函数scannum
				文件指针跳转函数fnextline
单词预览			foreseejiemian函数	转化函数scan4charnum(char* num);
				回车数字函数scannum
			foresee函数	文件指针跳转函数fnextline

2.面向对象建模

2.1 主函数

（1）调用shiyongshuoming子函数，zhujiemian子函数

（2）进行随机数初始化操作srand((unsigned int)time(0))

无特别之处，不在给出流程图

2.2次要函数-使用说明函数

加载图片到界面，对用户进行引导使用。

2.1 主函数

（1）调用shiyongshuoming子函数，zhujiemian子函数

（2）进行随机数初始化操作srand((unsigned int)time(0))

2.2界面子函数

创建640*480图形窗口。
设置注册和登录鼠标点击按钮和outtextxy一些提示信息。
用户点击选择进入登陆或者注册。

2.3注册账户子函数

作用：用户输入自己的用户名和注册密码作为进入该背单词程序的密钥。

流程图如下：

2.4登录系统子函数

作用：用户输入用户名和密码进入该系统。

流程图如下：

2.5主菜单子函数

作用：主要设置一些提示信息和按钮，显示本程序大的功能。

2.6个人单词本子函数

作用：显示单词删除，单词增加和单词浏览三个功能，并提供相应的选择按钮让用户选择需要的功能。

2.7数字检测子函数

作用：当用户输入数字后，下次输入空输入时保存对该数字的记忆。

当改变数字之后，记忆随之改变。

注：该函数作用于单词预览学习和个人单词本中的单词浏览，方便用户学习。

2.8将文件指针跳转到下一行开头函数

作用：把文件指针移到下一行开头

流程图如下：

2.7单词删除子函数

作用：本函数功能是个人单词本下辖的一个小的功能，用户选择该函数可以实现个人单词本（一个文件）中的单词的删除，达到个人笔记本和计划的功能。

2.8单词增加子函数

作用：用户输入想要添加单词的中文和英文，之后存储在个人单词本文件中

2.9单词浏览子函数

作用:用户输入自己单词想要想要浏览的单词数i，控制台中显示输入数量对应的单词。在第一次输入过后，如果没有重新输入i，输入回车，返回如前面一样

2.10单词查询子函数

作用：用户输入查询的单词，返回单词的中文释义，例句和翻译

2.11单词查询调用函数

作用：调用上面的单词查询inquire函数，方便使用

2.12随机数子函数

作用：为单词测试中给出英文选择中文这一模块提供随机选项。调用该函数可以产生i-j之间的随机数，方便下面的单词测试使用。

随机种子
产生随机数

注：由于比较简洁，在此不在给出流程图。

2.13单词测试子函数

作用：这函数主要是一个调用其他两个函数的功能，实现用户的功能选择，并提供一个界面达到美感。

2.14给出中文选择英文模块

作用：随机给出中文让用户选择英文，之后联合计分函数，记录分数。

主要作用是调用chose函数，选择chose的模式是给中文选择英文

2.15给出英文选择中文模块

作用：随机给出英文让用户选择中文，之后联合计分函数，记录分数。

主要作用是调用chose函数，选择chose的模式是给英文选择中文

2.16通用选择题模块（chose函数）

作用：传入几个参数：文件类型；问题；答案A,B,C,D;正确答案对应的数字位置，之后会给问题，答案，对应答案数字赋值

流程图如下：

2.17单词预览学习子函数

2.18分数记录子函数（学习效果）

作用：主要是联合单词测试对用户做过的题目数量和答对题目的个数做出统计

2.19复习计划子函数

2.20把int型转换为char型函数（和普通的转换思路不一样，比较特殊）

作用：把传入的int型数据转换为char型输出，方便分数统计时的outtextxy

流程图如下：

四．界面设计

说明：本程序采用easyX作为界面设计的工具。

1.操作说明指引界面

设计了一个简洁明了的操作说明界面，即使是初次使用者也可以根据该系统提供的详细操作指示方便快捷的完成想要使用的功能。

附图如下：

2.登陆注册界面

主菜单界面

单词本界面

五、测试计划

1.编写目的

1.本次测试首先是发现软件程序的运行错误，能够发现软件中程序的 bug 并加以修正。

2.测试界面是否对用户来说清晰明了，让用户能够在给定的操作指示下完成想要实现的功能。

3.测试各个函数模块运行结果的正确性。

4.测试输出结果是否符合要求。

5.测试整个模块界面的完整性与统一性。

1. 背景
本软件系统名称为背单词软件，内容包括单词查询，个人单词本，单词测试，单词预览，复习计划，计分统计

2.项目开发历史：无。

3.预先工作：需求分析、可行性分析、系统大致框架设计、界面设计。

2 计划

2.1编写的函数

函数名称	函数输入（形参）	函数功能	函数输出
int shiyongshuming()	无	加载程序使用说明的内容	返回1
unsigned int scannum()	无
int fnextline(FILE* fp)	FILE* fp	将文件指针跳转到下一行开头	返回0
void zhujiemian()	无	显示和调用登录和注册和函数	无
void Register()	无	注册账户功能	无
void Loading()	无	登录系统功能	无
int Menu()	无	调用六个函数，并设计界面	返回为1
void delword()	无	删除个人单词本中的单词	无
void addword()	无	增加个人单词本中的单词	无
void viewword()	无	浏览个人单词本中的单词	无
int perwordbank()	无	调用上面三个函数，并设计界面	返回为1
int seejiemian()	无	单词预览界面，并且提供预览方式的两种选择	返回为1
int foresee	FILE* fp1, int type	预览单词	返回为1
int RandInt（）	int i, int j	产生i~j之间的随机数	返回随机数
void CntoEn()	无	根据中文选择英文	无
void EntoCn()	无	根据英文选择中文	无
int word_test()	无	选择背诵模式	返回为1
int CntoEn1（）	int filetype, char* Ques, char* A, char* B, char* C, char* D, int* Ans	随机给出中文及对应英文，以及其他错误答案选项，调用chose	返回 0
int EntoCn1（）	int filetype, char* Ques, char* A, char* B, char* C, char* D, int* Ans	随机给出英文及对应中文，以及其他错误答案选项，调用chose	返回为0
int chose（）	int filetype, int questype, char* Ques, char* A1, char* B1, char* C1, char* D1, int* Ans	随机给出英文/中文及对应中文/英文，以及其他错误答案选项	返回为0
int scan4charnum（）	char* num	将num中存放的4位数字转化为int型输出	返回转换之后int型
int inquire（）	FILE* fp, char* in	单词查询，输出单词，中文，以及例句翻译	返回为0
int findword（）	FILE* fp1	调用上个函数	返回0或1
int fuxi（）	无	调用	返回
int chakanyicuodanci（）	无	查看易错单词	返回0
int score1（）	无	打印用户测试的成绩	返回0
char* InttoChar(int num, char* p)	int num, char* p	把int型转换为char型	返回int 型数据
int main()	无	进行随机数初始化调用zhujiemian函数	返回为0

2.2 测试内容

1.注册功能

2.登录功能

3.单词查询

4.个人单词本

5.单词预览

6.分数查询

7.背诵模式

8.复习计划

3 测试设计说明

3.1 测试

对所有函数功能一次性测试，主要测试函数功能是否正常工作，以及对函数设计的健壮性进行测试。

3.2 输入与输出

1.注册功能测试：

这是注册成功的情况：

下面是注册失败的情况：

登录功能测试：

下面是登陆成功的情况：

下面的是登陆失败的情况无用户名：

密码错误的情况：第一个第一次输入错误，第二次输入正确；第二个是两次都错误

单词查询功能测试：

测试时输入单词之后会返回中文意思和例句和翻译。

4.个人单词本测试：

单词增加测试

第一份图是增加之后截取的文件的部分内容

单词删除测试：

单词浏览测试：

这一部分单词浏览是浏览的自己添加的单词，也就是自己的个人词库，与下面的单词预览学习测试时不相同的。

5.单词预览功能测试：（主要是在正式背诵之前先学习）

不想在预览学习后，用户输入0，会提供测试或者返回主菜单的选择

6.分数查询功能测试（即是背诵效果查询）

根据测试者做多题目的数量，会给予不同房的评价
在这个界面还会显示出用户测试过的题目数量和作对的正确个数

7.单词背诵功能测试

（1）刚开始是模式的选择

(2)之后是进入测试界面

下面两个截屏是根据英文背诵中文，也就是背诵模式二

下面的两个截屏是根据中文选择英文，也就是背诵模式一

8.复习计划功能

首先是进入之后的界面选择

查看易错单词进行复习背诵

4 评价准则

4.1 范围

本次测试的范围包括本函数所有提供的功能测试，所以是完全覆盖了本函数。

4.2 数据整理方式

本测试的数据是通过手工测试后手工记录并且整理完成，通过手工记录数据来分析测试结果。

4.3 尺度

如若按照本软件的提示合法操作或者输入数据，那么将会得到预想的结果；如若未按照本软件提示或者误输入，将会无法得到预想结果，但软件不会停止运行或者中断，并且会提示重新操作或者输入。

六、操作手册

1. 引言

1.1 编写目的

为了帮助用户更好的了解和使用该系统，操作手册讲述了怎么合理的使用此系统，并且记录了该系统在使用过程中应该注意的一些问题。

1.2 背景

本项目的主要依托平台是visual 2019平台，主要为实现有需要的学生进行背单词使用，采用学生们比较喜欢的高效的记忆方式（采用测试和记忆相结合的手段）

2. 用途

2.1 功能

可以实现通过用户鼠标点击，判断需要完成的功能；可以实现单词查询，返回单词的全部信息；单词测试，方便用户记忆单词；计分统计，方便用户检查自己的学习效果，以便进行间歇性的复习；个人单词本，可以让用户存入自己想要存放的单词。

3. 运行环境

Visual 2019

4 菜单界面展示

5.使用过程

用户点击不同的选择会进入不同的功能区域，之后进行不同的功能选择，完成不同程度的单词学习。使用的话和平常的其他PC端软件使用效果差不多，有时可能会涉及到控台的输入与输出。

#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>
#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 filetype;//测试文件类型全局变量
int score = 0;//定义一个全局变量统计全局的分数
int timu;//测试用题目数量所用全局变量
int filetype1();//测试文件选择函数
int shiyongshuming();//使用说明函数
void zhujiemian();//主界面
int fnextline(FILE* fp);
void Register();//注册
void Loading();//登录
int Menu();//主菜单
int fuxi();//复习计划
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);
int  yuyin(int argc, char* argv[]);//语音
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;
};
int  yuyin(int argc, char* argv[])
{
	ISpVoice* pVoice = NULL;

	//COM初始化：
	if (FAILED(::CoInitialize(NULL)))
		return FALSE;

	//获取ISpVoice接口：
	HRESULT hr = CoCreateInstance(CLSID_SpVoice, NULL, CLSCTX_ALL, IID_ISpVoice, (void**)&pVoice);
	if (SUCCEEDED(hr))
	{
		hr = pVoice->Speak(L"Hello world", 0, NULL);
		pVoice->Release();
		pVoice = NULL;
	}

	//千万不要忘记：
	::CoUninitialize();
	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]);
		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)//将文件指针跳转到下一行开头
{
	char c;
	do
	{
		fscanf(fp, "%c", &c);
		if (feof(fp))//(0==fscanf(fp, "%c", &c))
			return -1;
	} while (c != '\n');//逐字符扫描，直到换行或文件结束
	return 0;
}
void zhujiemian()
{
	int i, event = 0;
	initgraph(640, 480);
	IMAGE img;
	setbkcolor(WHITE);//设置底色
	loadimage(&img, _T("tupian3.jpg"));
	putimage(0, 0, &img);
	LOGFONT f;
	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 };
	RECT 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, "宋体");
	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", 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");
		getchar();//停顿
		getchar();//停顿
		system("cls");
		Loading();//进入登陆函数
	}
	else
	{
		printf("请再次确认密码:\n");
		scanf("%s", mima3);
		if (!strcmp(mima1, mima3))    //若第一次不一致则需第二次确认一致。
		{
			strcpy_s(mm, mima1);
			fprintf(fp, "%s %s %d\n", yonghuming1, mm, dk);      //用户名与密码还有初始打卡数存入文件。
			fclose(fp);//关闭文件
			printf("恭喜你，注册成功！\n");
			printf_s("请按任意键进入登录\n");
			getchar();//停顿
			getchar();//停顿
			system("cls");
			Loading();//进入登陆函数
		}
		else
		{
			printf("注册失败!\n");
			printf("请按任意键退出系统：");
			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 (fuxi());
				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);
	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 (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;
	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 = 120;
	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));//随机数初始化
	int i = 1;//做过的题目的初值序号定为1
	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();
				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(100, 80, 540, 120);//清空之前题目的打印内容
				clearrectangle(100, 140, 540, 180);
				clearrectangle(100, 200, 540, 240);
				clearrectangle(100, 260, 540, 300);
				clearrectangle(120, 30, 550, 50);
				clearrectangle(550, 30, 680, 50);
				q = 5;//进入下一题之前该改变答案的序号以备下一题使用
				CntoEn1(filetype, Ques, A, B, C, D, &Ans);
				timu++;//timu全局变量改变
				int j = 120;
				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; m < strlen(A); m++)
					{
						yingwen[m] = A[m];
					}
				}
				if (Ans == 2)
				{
					for (int m = 0; m < strlen(B); m++)
					{
						yingwen[m] = B[m];
					}
				}
				if (Ans == 3)
				{
					for (int m = 0; m < strlen(B); m++)
					{
						yingwen[m] = C[m];
					}
				}
				if (Ans == 4)
				{
					for (int m = 0; m < strlen(D); m++)
					{
						yingwen[m] = D[m];
					}
				}
				for (int j = 0; j < strlen(Ques); j++)
				{
					zhongwen[j] = Ques[j];
				}
				fprintf_s(fp3, " %d  %s %s \n", i, yingwen, zhongwen);
				i++;
			}
		}
		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();
				score1();//跳转查询效果界面
			}
		}
		else
		{
			setlinecolor(BLACK);
			rectangle(450, 350, 600, 380);
		}
	}
	fclose(fp3);
}
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+");//以写形式打开
	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 = 120;
	settextstyle(20, 0, "宋体");
	outtextxy(j, 30, Ques);
	outtextxy(j, 85, A);
	outtextxy(j, 150, B);
	outtextxy(j, 205, C);
	outtextxy(j, 265, D);
	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)
			{
				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(100, 80, 540, 120);
				clearrectangle(100, 140, 540, 180);
				clearrectangle(100, 200, 540, 240);
				clearrectangle(100, 260, 540, 300);
				clearrectangle(120, 30, 550, 50);
				clearrectangle(550, 30, 680, 50);
				q = 5;//进入下一题之前该改变答案的序号以备下一题使用
				EntoCn1(filetype, Ques, A, B, C, D, &Ans);
				timu++;
				int j = 120;
				settextstyle(20, 0, "宋体");
				outtextxy(j, 30, Ques);
				outtextxy(j, 85, A);
				outtextxy(j, 150, B);
				outtextxy(j, 205, C);
				outtextxy(j, 265, D);
			}
		}
		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();
				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 = { 200, 240, 400, 320 };
	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);
	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 >= 270 && m.x <= 330 && m.y >= 265 && m.y <= 295)
		{
			setlinecolor(RED);
			rectangle(270, 265, 330, 295);
			if (m.uMsg == WM_LBUTTONDOWN)
			{
				closegraph();
				Menu();//跳转菜单子函数
				return 0;
			}
		}
		else
		{
			setlinecolor(BLACK);
			rectangle(270, 265, 330, 295);
		}
	}
}
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);
	//int numn=fscanf(fp1, "%d %s %s", &num, en, cn);
	//printf("%d\n\n%s\n\ncn::%s", num, en, cn);//
	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);
		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:
				for (int i = 0; cns[i] != '\0' && i < 40; i++)
					*(A + i) = cns[i];
				break;
			case 2:
				for (int i = 0; cns[i] != '\0' && i < 40; i++)
					*(B + i) = cns[i];
				break;
			case 3:
				for (int i = 0; cns[i] != '\0' && i < 40; i++)
					*(C + i) = cns[i];
				break;
			case 4:
				for (int i = 0; cns[i] != '\0' && i < 40; i++)
					*(D + i) = cns[i];
				break;
			default:
				break;
			}




			fseek(fp1, 0L, 0);
		}

		switch (*Ans)
		{
		case 1:
			for (int i = 0; cn[i] != '\0' && i < 40; i++)
				*(A + i) = cn[i];
			break;
		case 2:
			for (int i = 0; cn[i] != '\0' && i < 40; i++)
				*(B + i) = cn[i];
			break;
		case 3:
			for (int i = 0; cn[i] != '\0' && i < 40; i++)
				*(C + i) = cn[i];
			break;
		case 4:
			for (int i = 0; cn[i] != '\0' && i < 40; i++)
				*(D + i) = cn[i];
			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);
		}

		switch (*Ans)
		{
		case 1:
			for (int i = 0; en[i] != '\0'; i++)
				*(A + i) = en[i];
			break;
		case 2:
			for (int i = 0; en[i] != '\0'; i++)
				*(B + i) = en[i];
			break;
		case 3:
			for (int i = 0; en[i] != '\0'; i++)
				*(C + i) = en[i];
			break;
		case 4:
			for (int i = 0; en[i] != '\0'; i++)
				*(D + i) = en[i];
			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);
	}

	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] <= '~');

				//fscanf(fp1,"%s", &file[200]);

			}

		}
		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++;
	}
	printf("\n");
	return 0;
}
int findword(FILE* fp1)
{
	char in[40] = { '\0' };
	system("cls");
	printf("请输入你要查询的单词(输入0返回上一级菜单)例如complain\n");
	int flag = -1; char c;
	while (flag == -1)
	{
		do
		{
			scanf("%c", &c);
		} while (c == '\n');
		system("cls");
		printf("请输入你要查询的单词(输入0以退出)例如complain\n");

		if (c == '0')
		{
			return 0;
		}
		else
		{
			ungetc(c, stdin);
		}
		scanf("%s", in);
		inquire(fp1, in);
		fseek(fp1, 0L, 0);
	}

	return 1;
}
int fuxi()
{
	int filetype = 1;
	initgraph(640, 480);
	IMAGE img;
	loadimage(&img, _T("tupian3.jpg"));
	putimage(0, 0, &img);
	setbkcolor(WHITE);//设置底色
	settextstyle(40, 0, "宋体");
	settextcolor(BLACK);
	RECT r1 = { 150,100,390,140 };
	drawtext(_T("复习易错单词"), &r1, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
	RECT r2 = { 150,160,390,200 };
	drawtext(_T("易错单词强化"), &r2, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
	RECT r3 = { 220,220,310,260 };
	drawtext(_T("返回"), &r3, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
	settextstyle(50, 0, "楷体");
	settextcolor(RED);
	outtextxy(500, 80, "复");
	outtextxy(500, 140, "习");
	outtextxy(500, 200, "计");
	outtextxy(500, 260, "划");
	MOUSEMSG m;
	while (1)
	{
		m = GetMouseMsg();
		FlushMouseMsgBuffer();
		if (m.x >= 150 && m.x <= 390 && m.y >= 100 && m.y <= 140)//登陆函数作用域
		{
			setlinecolor(BLUE);
			rectangle(150, 100, 390, 140);
			if (m.uMsg == WM_LBUTTONDOWN)
			{
				closegraph();
				chakanyicuodanci();//查看易错单词
			}
		}
		else
		{
			setlinecolor(YELLOW);
			rectangle(150, 100, 390, 140);
		}
		if (m.x >= 150 && m.x <= 390 && m.y >= 160 && m.y <= 200)
		{
			setlinecolor(BLUE);
			rectangle(150, 160, 390, 200);
			if (m.uMsg == WM_LBUTTONDOWN)
			{
				closegraph();
				word_test();
			}
		}
		else
		{
			setlinecolor(YELLOW);
			rectangle(150, 160, 390, 200);
		}
		if (m.x >= 220 & m.x <= 310 && m.y >= 220 && m.y <= 260)
		{
			setlinecolor(BLUE);
			rectangle(220, 220, 310, 260);
			if (m.uMsg == WM_LBUTTONDOWN)
			{
				closegraph();
				Menu();
			}
		}
		else
		{
			setlinecolor(YELLOW);
			rectangle(220, 220, 310, 260);
		}
	}
	return 0;
}
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);
	int j = 0;
	settextstyle(20, 0, "楷体");
	outtextxy(120, 110, correct[j].yingwen);
	outtextxy(120, 170, correct[j].zhongwen);
	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, 110, 500, 130);//清空之前题目的打印内容
				clearrectangle(120, 170, 500, 190);
				outtextxy(120, 100, correct[j].yingwen);
				outtextxy(120, 160, correct[j].zhongwen);
			}
		}
		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();
				fuxi();
			}
		}
		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, "楷体");
	outtextxy(150, 100, "注明：分数是刚刚测验做对题的个数");
	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);
	printf("'%d''%s'", score, p);
	outtextxy(300, 330, *p);
	char o[10] = { '\0' };
	InttoChar(timu, o);
	outtextxy(300, 250, *o);
	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);
	}
	if (score <= 5)
	{
		clearrectangle(200, 200, 500, 240);
		RECT r4 = { 200 ,200,500,240 };
		drawtext(_T("再接再励！"), &r4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
	}
	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);
	}
	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);
	}
	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;
}