C语言实现背单词软件(系统级别)

这篇具有很好参考价值的文章主要介绍了C语言实现背单词软件(系统级别)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、软件需求说明书

1 引言 

2 任务概述  

二、可行性研究报告 

1 编写目的 

2 所建议的系统(技术可行性) 

3 使用方面的可行性 

4 结论 

三、系统设计说明书  

1.面向对象设计

1.1前提说明

 1.2 系统设计

2.面向对象建模  

四.界面设计

五、测试计划  

1.编写目的 

2 计划 

4 评价准则 

六、操作手册 

1. 引言 

2. 用途 

3. 运行环境 

4 菜单界面展示 

5.使用过程 


一、软件需求说明书

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

缺点:

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升级功能

  1. 计分功能

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

  1. 界面模块

用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 系统设计

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

单词查询

单词预览

背单词模式

个人单词本

复习计划

分数记录(学习效果)

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

个人单词本

单词删除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.面向对象建模  

  1. 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界面子函数

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

2.3注册账户子函数

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

流程图如下:

C语言实现背单词软件(系统级别)

2.4登录系统子函数

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

流程图如下:

C语言实现背单词软件(系统级别)

2.5主菜单子函数

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

C语言实现背单词软件(系统级别)

2.6个人单词本子函数

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

C语言实现背单词软件(系统级别)

2.7数字检测子函数

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

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

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

C语言实现背单词软件(系统级别)

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

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

流程图如下:

C语言实现背单词软件(系统级别)

2.7单词删除子函数

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

C语言实现背单词软件(系统级别)

2.8单词增加子函数

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

C语言实现背单词软件(系统级别)

2.9单词浏览子函数

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

C语言实现背单词软件(系统级别)

 2.10单词查询子函数

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

C语言实现背单词软件(系统级别)

 2.11单词查询调用函数

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

2.12随机数子函数

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

  1. 随机种子
  2. 产生随机数

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

2.13单词测试子函数

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

C语言实现背单词软件(系统级别)

 2.14给出中文选择英文模块

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

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

2.15给出英文选择中文模块

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

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

2.16通用选择题模块(chose函数)

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

流程图如下:

C语言实现背单词软件(系统级别)

2.17单词预览学习子函数

C语言实现背单词软件(系统级别)

2.18分数记录子函数(学习效果)

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

C语言实现背单词软件(系统级别)

2.19复习计划子函数

C语言实现背单词软件(系统级别)

2.20把int型转换为char型函数(和普通的转换思路不一样,比较特殊)

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

流程图如下:

四.界面设计

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

1.操作说明指引界面

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

附图如下:

C语言实现背单词软件(系统级别)

2.登陆注册界面

C语言实现背单词软件(系统级别)

  1. 主菜单界面
  2. C语言实现背单词软件(系统级别)

  1. 单词本界面

    C语言实现背单词软件(系统级别)

5.背单词模式界面

背单词先选择背诵模式

模式选择

C语言实现背单词软件(系统级别)

6.复习计划界面

C语言实现背单词软件(系统级别)

7.分数查询界面

C语言实现背单词软件(系统级别)

8.单词预览界面

C语言实现背单词软件(系统级别)

五、测试计划  

1.编写目的 

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

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

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

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

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

    1. 背景 
  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.注册功能测试:

这是注册成功的情况:

C语言实现背单词软件(系统级别)

下面是注册失败的情况:

C语言实现背单词软件(系统级别)

  1. 登录功能测试:

下面是登陆成功的情况:

C语言实现背单词软件(系统级别)

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

C语言实现背单词软件(系统级别)

密码错误的情况:第一个第一次输入错误,第二次输入正确;第二个是两次都错误

C语言实现背单词软件(系统级别)

 C语言实现背单词软件(系统级别)

  1. 单词查询功能测试:

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

C语言实现背单词软件(系统级别)

4.个人单词本测试

  1. 单词增加测试

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

C语言实现背单词软件(系统级别)

C语言实现背单词软件(系统级别)

  1. 单词删除测试:C语言实现背单词软件(系统级别)
  1. 单词浏览测试:C语言实现背单词软件(系统级别)

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

C语言实现背单词软件(系统级别)

5.单词预览功能测试:(主要是在正式背诵之前先学习)

C语言实现背单词软件(系统级别)

 C语言实现背单词软件(系统级别)

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

C语言实现背单词软件(系统级别)

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

  1. 根据测试者做多题目的数量,会给予不同房的评价
  2. 在这个界面还会显示出用户测试过的题目数量和作对的正确个数C语言实现背单词软件(系统级别)

7.单词背诵功能测试

(1)刚开始是模式的选择

C语言实现背单词软件(系统级别)

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

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

C语言实现背单词软件(系统级别)

C语言实现背单词软件(系统级别)

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

C语言实现背单词软件(系统级别)

 C语言实现背单词软件(系统级别)

8.复习计划功能

  1. 首先是进入之后的界面选择
  2. C语言实现背单词软件(系统级别)
  1. 查看易错单词进行复习背诵

C语言实现背单词软件(系统级别)

4 评价准则 

4.1 范围

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

4.2 数据整理方式

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

4.3 尺度

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

六、操作手册 

1. 引言 

1.1 编写目的

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

1.2 背景

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

2. 用途 

2.1 功能

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

3. 运行环境 

Visual 2019

4 菜单界面展示 

C语言实现背单词软件(系统级别)

 

5.使用过程 

用户点击不同的选择会进入不同的功能区域,之后进行不同的功能选择,完成不同程度的单词学习。使用的话和平常的其他PC端软件使用效果差不多,有时可能会涉及到控台的输入与输出。文章来源地址https://www.toymoban.com/news/detail-462754.html

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

到了这里,关于C语言实现背单词软件(系统级别)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 数据结构 C语言 树形结构 简单目录管理系统

    在图书、操作系统文件夹、学生等管理系统中,目录管理是必要环节,如何高效搜寻与低复杂度存储是实现这一环节的关键性问题。本课程设计需完成一种基于多叉树结构简单目录管理系统,该系统能以交互式界面进行创建目录、删除目录、查找目录、修改目录、层次遍历目

    2024年02月04日
    浏览(47)
  • 数据结构 C语言 树形结构 简单目录管理系统

    在图书、操作系统文件夹、学生等管理系统中,目录管理是必要环节,如何高效搜寻与低复杂度存储是实现这一环节的关键性问题。本课程设计需完成一种基于多叉树结构简单目录管理系统,该系统能以交互式界面进行创建目录、删除目录、查找目录、修改目录、层次遍历目

    2024年02月07日
    浏览(48)
  • 基于微信小程序的英语单词记忆系统的设计与实现(论文+源码)_kaic

    摘  要 当前时期,国内的经济获得了非常快速的发展,互联网技术在持续的创新和完善,教育教学方面也在不断的进步,教育全面深化改革在发展,并且移动互联网技术在教育领域获得了大量的实践以及应用。语言的全球化慢慢的变成现今世纪非常重要的一种发展趋势,其中

    2024年02月12日
    浏览(38)
  • 安卓android记单词软件

    课程设计项目总结,基于安卓的记单词软件,分为前端和服务器端,前端使用安卓,后端使用SSM框架。 具体技术栈为: 前端:android、okhttp、sqlite、litepal等 后端:SSM(SpringMVC+Spring+Mybatis)、mysql数据库、tomcat服务器等 项目的总体介绍 基于安卓的记单词软件,用户在第一次使用的时

    2024年02月05日
    浏览(36)
  • SQLyog软件安装(保姆级别)

    首先下载SQLyog 软件,并解压 选择自己操作系统的版本 双击点击 .exe 文件,进行安装 选择安装语言,默认中文,直接点击【OK】即可 点击【下一步】 先【勾选】同意协议,再点击【下一步】 点击【下一步】 根据自己需求,看是否更改路径,如果更改点击【浏览】选择位置,

    2024年01月16日
    浏览(44)
  • 一个利用摸鱼时间背单词的软件

    大家好,我是 Java陈序员 。 最近进入了考试季,各种考试,英语四六级、考研、期末考等。不知道大家的英语四六级成绩怎么样呢? 记得大学时,英语四级都是靠高中学习积累的老本才勉强过关。 而六级则是考了多次,最终还是折戟沙场,最好的一次是 424! 不得不说,英

    2024年02月04日
    浏览(34)
  • 软件测试Pytest实现接口自动化应该如何在用例执行后打印日志到日志目录生成日志文件?

    Pytest可以使用内置的logging模块来实现接口自动化测试用例执行后打印日志到日志目录以生成日志文件。以下是实现步骤: 1、在pytest配置文件(conftest.py)中,定义一个日志输出路径,并设置logging模块。 2、在测试用例中调用logging模块,输入需要生成的日志信息。 3、运行p

    2024年02月10日
    浏览(62)
  • 单词倒排(C语言详解)

    描述: 对字符串中的所有单词进行倒排。 说明: 1、构成单词的字符只有 26个大写或小写英文字母; 2、非构成单词的字符均视为单词间隔符; 3、要求倒排后的 单词间隔符以一个空格 表示;如果原字符串中相邻单词间有多个间隔符时,倒排转换后也只允许出现一个空格间隔

    2024年02月12日
    浏览(26)
  • C语言——大头记单词

    归纳编程学习的感悟, 记录奋斗路上的点滴, 希望能帮到一样刻苦的你! 如有不足欢迎指正! 共同学习交流! 🌎欢迎各位→点赞 👍+ 收藏⭐ + 留言​📝 每一发奋努力的背后,必有加倍的赏赐! 一起加油! 题目描述 大头的词汇量很小,所以每次做英语选择题的时候都很头

    2024年01月19日
    浏览(22)
  • Linux:概述 、安装 、文件与目录结构 、vim编辑器 、网络配置 、远程登录 、系统管理 、基础命令 、软件包管理 、克隆虚拟机 、shell编程

    2.1.1、Linux是什么? Linux是一个操作系统(OS) 所谓的操作系统就是直接用来操作计算机底层硬件的软件。 2.1.2、Linux的出现 官网: https://www.centos.org/ 进入官网进行下载 有很多的镜像,以阿里云的为例: 3.3.1、下载 官网: https://www.vmware.com/ 这是下载的企业版,30天试用期,可

    2024年02月05日
    浏览(65)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包