月度归档： 2019年8月

int和Integer的区别

相信每一个写java的人难免会对这个问题有疑惑，在java中存在有两个整型类，他们究竟有什么区别呢

https://www.cnblogs.com/guodongdidi/p/6953217.html

int和Integer的区别

1、Integer是int的包装类，int则是java的一种基本数据类型 
2、Integer变量必须实例化后才能使用，而int变量不需要 
3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值 
4、Integer的默认值是null，int的默认值是0

延伸： 
关于Integer和int的比较 
1、由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。

Integer i = new Integer(100);Integer j = new Integer(100);System.out.print(i == j); //false

2、Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）

Integer i = new Integer(100);int j = 100；System.out.print(i == j); //true

3、非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）

Integer i = new Integer(100);Integer j = 100;System.out.print(i == j); //false

4、对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false

Integer i = 100;Integer j = 100;System.out.print(i == j); //true

Integer i = 128;Integer j = 128;System.out.print(i == j); //false

对于第4条的原因： 
java在编译Integer i = 100 ;时，会翻译成为Integer i = Integer.valueOf(100)；，而java API中对Integer类型的valueOf的定义如下：

public static Integer valueOf(int i){    
assert IntegerCache.high >= 127;    
if (i >= IntegerCache.low && i <= IntegerCache.high){        return IntegerCache.cache[i + (-IntegerCache.low)];    
}    
return new Integer(i);
}

java对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了

如果有错误的地方，还请指正。

参考： 
http://blog.csdn.net/you23hai45/article/details/50734274 
http://www.cnblogs.com/liuling/archive/2013/05/05/intAndInteger.html

Javascript写入txt和读取txt文件示例

1. 写入 

FileSystemObject可以将文件翻译成文件流。 

var fso=new ActiveXObject(Scripting.FileSystemObject);

创建一个可以将文件翻译成文件流的对象。 

第二步：用于创建一个textStream 对象 

括号里边有三个属性 

1. 文件的绝对路径 

2. 文件的常数 只读=1，只写=2 ，追加=8 等权限。（ForReading 、 ForWriting 或 ForAppending 。）； 

3. 一个布尔值 允许新建则为true 相反为false；  

var f=fso.createtextfile(“C:\a.txt”,2,true);

第三步：调用textStream的方法 

1. Write（不在写入数据末尾添加新换行符） 

2. WriteLine（要在最后添加一个新换行符） 

3. WriteBlankLines（增加一个或者多个空行）  

f.writeLine(“wo shi di yi hang”);

第四步： 

关闭textStream 对象： 

例：f.close(); 

2. 读取  

var fso=new ActiveXObject(Scripting.FileSystemObject);

创建一个可以将文件翻译成文件流的对象。 

第二步：用于创建一个textStream 对象 

括号里边有三个属性 

4. 文件的绝对路径 

5. 文件的常数 只读=1，只写=2 ，追加=8 等权限。（ForReading 、 ForWriting 或 ForAppending 。）； 

6. 一个布尔值 允许新建则为true 相反为false； 

var f=fso.opentextfile(“C:\a.txt”,1，true);

第三步：调用读取方法 

1. Read（用于读取文件中指定数量的字符） 

2. ReadLine（读取一整行，但不包括换行符） 

3. ReadAll（则读取文本文件的整个内容）； 

判断是否读取到最后一行  

while (!f.AtEndOfStream) 
{ 
f.Readline(); 
}

第四步： 

关闭textStream 对象： 

例：f.close(); 

下面是一个html打开txt文件的例子。  

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml"> 
<head> 
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> 
<title>你好</title> 
</head> 

<body> 
<div id="aa"></div> 

<script language="javascript"> 
var fso, ts, s ; 
var ForReading = 1; 

fso = new ActiveXObject("Scripting.FileSystemObject"); 
ts = fso.OpenTextFile("d:\\testfile.txt", ForReading); 
s = ts.ReadLine(); 
document.getElementById("aa").innerHTML=s; 
</script> 

</body> 
</html>

当年的大数据都遭遇了什么？为什么有段时间全体寂灭？大数据的前世今生

对于此次洗牌大潮，大多从业者表示，并非坏事。 劣币被驱逐，良币才能沐浴阳光，茁壮生长。 去芜存菁，正本清源，大数据行业的野蛮时代终于结束。

文 | 戈森 零和

6月1日，《网络安全法》落地实施已过去三个月，大数据行业结束野蛮时代，进入洗牌期。

此前有15家数据公司被调查，此后，名单扩大到30家；

多家公司的业务负责人被约谈，他们甚至相互打招呼的方式，都变成了“今天，你被抓了吗”；

大量数据接口关停，数据产品停售，导致部分公司开始裁员，一家被调查的公司，甚至将大数据业务完全下架，退出市场。

一些公司黯然退场，一些却高调入局——一些有独家数据源的公司，在最近宣布成立。

数据行业，正处于二八分流，冰火两重天。

01“你被抓了吗？”

2017年5月末，数据行业的清理行动开始。

据多位知情人透露，“数据堂”多人被警方调查，导致部分数据业务线停摆。

此后，数据堂发表声明称，因公司某一客户存在被公安机关调查的情形，公安机关为进一步了解具体情况，向公司个别业务人员及财务人员进行情况了解，不存在“公司高管被抓”的情形；公司业务运作正常。

目前，数据堂的官网可正常打开，但“数据定制—数据堂”的网站页面，却无法打开。

今年8月，数据堂发布股票停牌公告，称因存在“预计应披露的重大信息在披露前已难以保密或已经泄露，或公共媒体出现与公司有关传司，可能或已经对股票转让价格产生较大影响的”事项，2017年8月14日起暂停转让，预计股票恢复转让日期不晚于2017年11月13日。

“公司走了很多人，还有一些人准备拿完年终奖就走”，数据堂离职员工杨青称，“目前，精准营销线和大数据线基本暂停，现在仅靠人工智能一条业务线支撑”。

但杨青同时指出：“公司的海外客户，暂时没有受到影响。”

这只是大数据行业进入冰封时代的一个缩影。

一本财经曾独家报道，15家数据公司被调查，名单中不乏估值几十亿的大公司。据知情人透露，此后，调查范围则进一步扩大，“名单已有30家”。

行业一度风声鹤唳，传闻满天飞。

头部的大数据公司，都曾传出过CEO或高层被调查的“小道消息”。

网传聚信立的高管也被带去问话，业务呈收缩状态。

聚信立CEO罗皓不得不站出来辟谣，紧急接受媒体采访:“我敢否认，说明我们没有被约谈。”

“实际上，确实很多公司的业务负责人被约谈”，行业资深从业者罗锦江称，为了取证，通常电脑等存储设备也会被拿走。

一位大数据行业的CEO听到传闻，另外一家公司的创始人被调查，他急忙在微信上询问：“你没事吧？”

对方回复没事，说是谣言。

结果第二天，CEO又听到消息，接着再问：“今天你被抓了吗？”

“今天你被抓了吗”，这句话一度成为大数据行业高层从业者的问候语。

02接口切断

几乎行业所有的人都明白，这次数据整顿，是为了6月1日新推出的《网络安全法》预热。

“这次是动真格了，毫无容情”，罗锦江称，5月底，很多公司主动将一些敏感业务线停掉。

“数据供应商突然间通知我们，业务暂停，但会支付违约金”，某信贷公司的商务负责人陈希称，最先被停掉的接口，就是“三要素”查询。

“所谓三要素，就是手机、姓名、身份证”，罗锦江称，以前的价格，“购买一条仅7毛、8毛”。

多位行业从业者称，三要素停了之后，大部分公司只提供两要素（身份证和姓名）的“验证”。

“把两个信息提供给数据方，对方只会反馈一个是与否的答案”，陈希称，如果符合，反馈“是”，如果不符合，反馈“否”。

陈希紧急修改了风控规则，让业务线可以勉强推进，但紧接着，更多的接口被切断。

以前一次查询2元的学历数据接口停掉，随后，车辆、住房、公积金等数据接口都全面切断。

“我们只能再次修改风控，让用户自己填写用户名和密码，授权我们去相应的页面爬取数据”，陈希称，如此操作大大提高了风控的成本和用户体验，“但合规了”。

紧接着，各项“特色”的数据产品也悄然撤下，或开始变得不稳定。

而某平台的风控总监郭飞透露发现：“今年年初，百融金服的产品收支等级，查询突然变得不太稳定，缺失率很高”。

所谓的收支等级，就是一个人信用卡和储蓄卡的入账和出账记录，并按照等级给出分数，数字远大，金额越大。

△ 收支等级产品说明

郭飞称，这项数据，是信贷中很有价值的数据，查询一次的价格是2-3元。

但至于如此隐秘的金融数据，百融金服是如何拿到的，在业内一直是一个谜团。

华道征信的业务员称：“自6月份后，不良信息的查询、资产类，目前我们是暂停服务”。

媒体报道，为了规避政策风险，在《网络安全法》实施前，同盾停掉了“失联人修复”服务；中国移动下属全资子公司中移在线，也停掉了“移动三要素”的查询。

一边是主动停止合作，一边是客户直接跑单。

贷后邦的商务负责人称：“部分客户已与我们达成合作意向，规定一出来他们很害怕，所有关于数据的业务都暂时不接，我手上有一两例违约客户。”

大量接口断了后，行业开始了裁员潮。

头部的大数据公司，都曾传出过裁员消息。

“主要裁掉的，是销售和一些敏感业务线的人”，罗锦江称，大量的乙方公司业务人员被裁掉后，就进入了甲方公司。

03艰难求生

2012年，马云在网商大会上震耳发聩地喊出：我们将进入大数据时代。

那一年，阿里巴巴集团设立了“首席数据官”一职，并推出大型数据分享平台“聚石塔”——这是中国大数据行业开始爆发的信号弹。

而大数据行业黄金年代的来临，是在2013年互联网金融崛起之后。

大数据和在线信贷相结合，激发了强烈的化学反应。

在黄金浪潮中，崛起了上万家的大数据供应商，他们采集数据，进行清洗加工，针对不同的应用场景，再输出不同的产品。

“早期，部分大数据公司的商业模式，极为简单，很多都是黑市采买数据后，简单打包，直接销售给客户”，罗锦江将其称为大数据的野蛮时代。

“在这里，就是大数据的天堂”，从美国回国创业的某CRO称，刚回国的时候，发现国内数据流通尺度之大，完全超乎想象。

在美国，很多并不敏感的数据，都无法用在信贷领域，比如，性别、人种颜色、年龄段，都不可随意参考，不然，就可能涉及“歧视女性、黑人或老人”。

滥用的用户数据，让大家就如裸泳一般，毫无隐私可言。

持续数年的数据之乱，终于在“徐玉玉”案之后，将行业推到了众矢之的的深渊。

这似乎成了诸多行业宿命，总是在鼎盛狂欢中，在利益催化之下，出现浮华泡沫。随后，巨大行业负面爆发，监管如期而至，洗牌来临。

校园贷和大数据行业，都是同样的轨迹。

行业正在挣扎中自救。

曾经很多大力宣传自己是专注大数据的公司，如今，对外的传播口径完全变动。

“行业污名化，不想和大数据扯上关系，外面现在都称自己是人工智能公司”，一位从业者称。

南京一家大数据公司也在被调查的30家名单中，目前，公司已将大数据业务全部关停，正在谋求转型。

“连我们业务员都需要加班加点看项目”，一家数据公司的商务称，公司甚至让他们去找项目，寻找出路。

大部分的数据提供商，正在寻找第一条自救之路：数据的脱敏、加密。

最常见的方式，就是查询结果的输出上，采取打分制，比如，如果完全匹配，就是100分，如果只有一半匹配，就是50分。

而查询不良则是用信息比对，输入名字身份证，输出命中与否。

还有一些公司，尝试用技术，保护用户隐私。如拨打催收电话，直接进行加密，只能看到一个加密号码拨出。

行业想到第二条自救之路：联合建模。

双方开发一套系统，直接放在客户公司的内部，双方共享数据，系统最终输出一个分数或结果。

“联合建模，确实解决了合规问题，能够使双方共享数据”，小赢科技首席风控官成少勇指出，从长远角度来说，这肯定是未来趋势，但目前，推进的过程依然困难重重。

今年8月，郭飞的公司和一家数据公司合作，对方提出了联合建模，但公司内部引发了争论。

“对于我们来说，增加了很大的工作量，我们不可能针对每家数据源都要去做建模，且联合建模的费用是十万”，郭飞称。

“实际上，现在大部分的联合建模，数据公司只是沦为一个技术提供商，这个模式太重，”大数据公司CEO林欣称，如果一家数据公司有20个客户，就得有20个建模师。

对于双方来说，这个模式重，成本高，为了合规都要付出代价。

04行业洗牌

《网络安全法》出台后，要获取、使用用户的数据，都需要用户授权。

而第三方的数据公司，很难再用这种方式获取数据。

林欣认为，这样的公司，无非只有两个命运：要么在原有的老数据基础上，挖掘建模，但这样的产品，很快就会过时；

要么就变成技术提供商和咨询商，比如联合建模。但这个命运，也不能让人愉悦。

如果变成技术提供商，很难和大的公司合作。因为，大的公司数据和风控，都视为核心部门，很少外包；其次，大的公司对数据提供商也百般挑剔。

因此，数据公司几乎只能给小的公司提供技术服务。

“大的公司，从6月之后，都要求数据提供商签一个承诺书，确保使用的数据，都是经过用户授权的”，罗锦江称，基本没几家公司敢签字。

行业的最终命运如何？

“行业90%的公司将被淘汰”，多位行业从业者都下了如此的判断。

有意思的是，一边是死亡，一边又是生长。

就在9月25日，联通大数据公司成立。

“未来，有一类大数据公司能活得不错，就是拥有稀缺数据源的公司”，林欣称。

而成少勇也是同样的观点，只有独家、且不断更新的数据公司，才有竞争力，“二八格局已非常明显”。

对于此次洗牌大潮，大多从业者表示，并非坏事。

劣币被驱逐，良币才能沐浴阳光，茁壮生长。

去芜存菁，正本清源，大数据行业的野蛮时代终于结束。

（应受访者要求，文中部分人名为化名）

xssee

XSSEE是一个专门用于解析解密的一个网站，因为该网站提供了多种常用的解密转换形式。因此使用起来非常的方便，此外还提供了编写js处理的方式，可以让开发人员，快速的处理编码字符。

因为XSSEE是基于前端的一种解析方式，因此可以快速方便的进行转换。目前已经有较多人移植至自己服务器中使用，从而避免去别人的网站使用

常用： https://web2hack.org/xssee/

[数据结构][C++]使用线性表实现一个通讯录

使用线性表实现一个通讯录，通讯录内容包含学号、姓名、电话三项数据。完成通讯录数据的建立，纪录插入和删除功能。

#include <iostream.h>
#include <conio.h>
#include <iomanip.h>
#include <string.h>
//--------------------------------------------------------------------
struct ElemType              // 数据元素的类型
{ 
        int numb;
        char name[20];
        int tel;
};
 
const int MAXSIZE=100;     // 数组的容量
 
class Sqlist
{
private:
        ElemType  elem[MAXSIZE];
        int length;
    public:
                Sqlist( void);
                ~Sqlist(){ };
                void  SetData();
                void  Insert( int i, ElemType e);
                ElemType Delet(int i);
                void PrintOut();
};
//-------------------------------------------------------------
Sqlist::Sqlist( ) { length=0;}
void  Sqlist::SetData( )     //初步建立一个通讯录 
{
        cout<<"\n 输入人数length="<<endl;
        cin>>length;
        for(int i=0;i<length;i++)
        { 
                cout<<"\n 输入学号：";  
                cin>>elem[i].numb;
                cout<<"\n 输入姓名："; 
                cin>> elem[i].name;
                cout<<"\n 输入电话号：="; 
                cin>>elem[i].tel;
        }
}
void  Sqlist::Insert( int i, ElemType e) //请完成此函数
{
        if(length==MAXSIZE)
                cout<<"FLOW!"<<endl;
        else
                if(i<1||i>length+1)
                        cout<<"Insert ERROR!"<<endl;
                else
                        for(int j=length;j>=i;j--)
                                elem[j]=elem[j-1];
                        elem[i-1]=e;
                        length++;
                        cout<<"Insert success!"<<endl;
 
}
ElemType Sqlist::Delet(int i)
{
  ElemType x;
        if(i<1||i>length)
                cout<<"RANGE ERROR!"<<endl;
        else
        {
                x=elem[i-1];
                for(int j=i;j<length;j++)
                        elem[j-1]=elem[j];
                length--;
                cout<<"success"<<endl;
        }
   return x;
}
void Sqlist::PrintOut()  //输出
{ 
        cout<<"\n 通讯录总人数："<<length;
        cout<<"\n PrintOut Data:\n";
        cout<<setw(16)<<"学号"<<setw(20)<<"姓名"<<setw(20)<<"电话号"<<endl;
        for(int k=0; k<length;k++)      
        { 
                cout<<setw(16)<<elem[k].numb<<setw(20)<<elem[k].name<<setw(20)<<elem[k].tel<<endl;
        }
}
//--------------------------------------------------
int main( )
{ int i,k;  ElemType e,x;
  Sqlist  as;
  cout<<"\n               通讯录演示";
  do{
      cout<<"\n\n";
      cout<<"\n\n    1. 初步建立一个通讯录（线性表） ";
      cout<<"\n\n    2. 插入一个数据元素 ";
      cout<<"\n\n    3. 删除一个元素，返回其值";
      cout<<"\n\n    4. 结束程序";
      cout<<"\n******************************** ";
      cout<<"\n    请输入你的选择(1,2,3,4)";  cin>>k;
          switch(k)
          { 
          case 1:
                  {  as.SetData(); as.PrintOut();  }break;
          case 2:{ cout<<"\n 插入的位置， i=?"; cin>>i;
                   cout<<"\n 插入的数据 编号=?"; cin>>e.numb;
                   cout<<"\n 插入的数据 姓名=?"; cin>>e.name;
                   cout<<"\n 插入的数据 电话号=?"; cin>>e.tel;
                   as.Insert(i,e);  as.PrintOut();
                 }break;
          case 3:{ cout<<"\n 删除第几个元i=?";  cin>>i;
                  x=as.Delet(i);
                  cout<<"\n  被删除的元素数值= "<<setw(10)<<x.numb<<
                  setw(10)<<x.name<<setw(10)<<x.tel;
                  as.PrintOut();
                 }break;
          default:break;
          } //switch
  }while(k>=1&&k<4);
  cout<<"\n          再见!";  cout<<"\n     按任意键，返回。";
  _getch(); return 0;
}

[纯C实现贪吃蛇游戏]vc++ 6.0实现

#include<stdio.h>
#include<time.h>
#include<windows.h>
#include<stdlib.h>
 
#define U 1
#define D 2
#define L 3 
#define R 4 //蛇的状态，U：上 ；D：下；L:左 R：右
 
typedef struct SNAKE //蛇身的一个节点
{
 int x;
 int y;
 struct SNAKE *next;
}snake;
 
//全局变量//
int score=0,add=10;//总得分与每次吃食物得分。
int status,sleeptime=200;//每次运行的时间间隔
snake *head, *food;//蛇头指针，食物指针
snake *q;//遍历蛇的时候用到的指针
int endgamestatus=0; //游戏结束的情况，1：撞到墙；2：咬到自己；3：主动退出游戏。
 
//声明全部函数//
void Pos();
void creatMap();
void initsnake();
int biteself();
void createfood();
void cantcrosswall();
void snakemove();
void pause();
void gamecircle();
void welcometogame();
void endgame();
void gamestart();
 
void Pos(int x,int y)//设置光标位置
{
 COORD pos;
 HANDLE hOutput;
 pos.X=x;
 pos.Y=y;
 hOutput=GetStdHandle(STD_OUTPUT_HANDLE);
 SetConsoleCursorPosition(hOutput,pos);
}
 
void creatMap()//创建地图
{
 int i;
 for(i=0;i<58;i+=2)//打印上下边框
 {
 Pos(i,0);
 printf("■");
 Pos(i,26);
 printf("■");
 }
 for(i=1;i<26;i++)//打印左右边框
 {
 Pos(0,i);
 printf("■"); 
 Pos(56,i);
 printf("■"); 
 }
}
 
void initsnake()//初始化蛇身
{
 snake *tail;
 int i;
 tail=(snake*)malloc(sizeof(snake));//从蛇尾开始，头插法，以x,y设定开始的位置//
 tail->x=24;
 tail->y=5;
 tail->next=NULL;
 for(i=1;i<=4;i++)
 {
 head=(snake*)malloc(sizeof(snake));
 head->next=tail;
 head->x=24+2*i;
 head->y=5;
 tail=head;
 }
 while(tail!=NULL)//从头到为，输出蛇身
 {
 Pos(tail->x,tail->y);
 printf("■");
 tail=tail->next;
 }
}
 
int biteself()//判断是否咬到了自己
{
 snake *self;
 self=head->next;
 while(self!=NULL)
 {
 if(self->x==head->x && self->y==head->y)
 {
 return 1;
 }
 self=self->next;
 }
 return 0;
}
 
void createfood()//随机出现食物
{
 snake *food_1;
 srand((unsigned)time(NULL));
 food_1=(snake*)malloc(sizeof(snake));
 while((food_1->x%2)!=0) //保证其为偶数，使得食物能与蛇头对其
 {
 food_1->x=rand()%52+2;
 }
 food_1->y=rand()%24+1;
 q=head;
 while(q->next==NULL)
 {
 if(q->x==food_1->x && q->y==food_1->y) //判断蛇身是否与食物重合
 {
 free(food_1);
 createfood();
 }
 q=q->next;
 }
 Pos(food_1->x,food_1->y);
 food=food_1;
 printf("■");
}
 
void cantcrosswall()//不能穿墙
{ 
 if(head->x==0 || head->x==56 ||head->y==0 || head->y==26)
 {
 endgamestatus=1;
 endgame();
 }
}
 
void snakemove()//蛇前进,上U,下D,左L,右R
{
 snake * nexthead;
 cantcrosswall();
 
 nexthead=(snake*)malloc(sizeof(snake));
 if(status==U)
 {
 nexthead->x=head->x;
 nexthead->y=head->y-1;
 if(nexthead->x==food->x && nexthead->y==food->y)//如果下一个有食物//
 {
 nexthead->next=head;
 head=nexthead;
 q=head;
 while(q!=NULL)
 {
 Pos(q->x,q->y);
 printf("■");
 q=q->next;
 }
 score=score+add;
 createfood();
 }
 else //如果没有食物//
 {
 nexthead->next=head;
 head=nexthead;
 q=head;
 while(q->next->next!=NULL)
 {
 Pos(q->x,q->y);
 printf("■");
 q=q->next; 
 }
 Pos(q->next->x,q->next->y);
 printf(" ");
 free(q->next);
 q->next=NULL;
 }
 }
 if(status==D)
 {
 nexthead->x=head->x;
 nexthead->y=head->y+1;
 if(nexthead->x==food->x && nexthead->y==food->y) //有食物
 {
 nexthead->next=head;
 head=nexthead;
 q=head;
 while(q!=NULL)
 {
 Pos(q->x,q->y);
 printf("■");
 q=q->next;
 }
 score=score+add;
 createfood();
 }
 else //没有食物
 {
 nexthead->next=head;
 head=nexthead;
 q=head;
 while(q->next->next!=NULL)
 {
 Pos(q->x,q->y);
 printf("■");
 q=q->next; 
 }
 Pos(q->next->x,q->next->y);
 printf(" ");
 free(q->next);
 q->next=NULL;
 }
 }
 if(status==L)
 {
 nexthead->x=head->x-2;
 nexthead->y=head->y;
 if(nexthead->x==food->x && nexthead->y==food->y)//有食物
 {
 nexthead->next=head;
 head=nexthead;
 q=head;
 while(q!=NULL)
 {
 Pos(q->x,q->y);
 printf("■");
 q=q->next;
 }
 score=score+add;
 createfood();
 }
 else //没有食物
 {
 nexthead->next=head;
 head=nexthead;
 q=head;
 while(q->next->next!=NULL)
 {
 Pos(q->x,q->y);
 printf("■");
 q=q->next; 
 }
 Pos(q->next->x,q->next->y);
 printf(" ");
 free(q->next);
 q->next=NULL;
 }
 }
 if(status==R)
 {
 nexthead->x=head->x+2;
 nexthead->y=head->y;
 if(nexthead->x==food->x && nexthead->y==food->y)//有食物
 {
 nexthead->next=head;
 head=nexthead;
 q=head;
 while(q!=NULL)
 {
 Pos(q->x,q->y);
 printf("■");
 q=q->next;
 }
 score=score+add;
 createfood();
 }
 else //没有食物
 {
 nexthead->next=head;
 head=nexthead;
 q=head;
 while(q->next->next!=NULL)
 {
 Pos(q->x,q->y);
 printf("■");
 q=q->next; 
 }
 Pos(q->next->x,q->next->y);
 printf(" ");
 free(q->next);
 q->next=NULL;
 }
 }
 if(biteself()==1) //判断是否会咬到自己
 {
 endgamestatus=2;
 endgame();
 }
}
 
void pause()//暂停
{
 while(1)
 {
 Sleep(300);
 if(GetAsyncKeyState(VK_SPACE))
 {
 break;
 }
 
 }
}
 
void gamecircle()//控制游戏 
{
 
 Pos(64,15);
 printf("不能穿墙，不能咬到自己\n");
 Pos(64,16);
 printf("用↑.↓.←.→分别控制蛇的移动.");
 Pos(64,17);
 printf("F1 为加速，F2 为减速\n");
 Pos(64,18);
 printf("ESC ：退出游戏.space：暂停游戏.");
 Pos(64,20);
 printf("c语言");
 status=R;
 while(1)
 {
 Pos(64,10);
 printf("得分：%d ",score);
 Pos(64,11);
 printf("每个食物得分：%d分",add);
 if(GetAsyncKeyState(VK_UP) && status!=D)
 {
 status=U;
 }
 else if(GetAsyncKeyState(VK_DOWN) && status!=U)
 {
 status=D;
 }
 else if(GetAsyncKeyState(VK_LEFT)&& status!=R)
 {
 status=L;
 }
 else if(GetAsyncKeyState(VK_RIGHT)&& status!=L)
 {
 status=R;
 }
 else if(GetAsyncKeyState(VK_SPACE))
 {
 pause();
 }
 else if(GetAsyncKeyState(VK_ESCAPE))
 {
 endgamestatus=3;
 break;
 }
 else if(GetAsyncKeyState(VK_F1))
 {
 if(sleeptime>=50)
 {
 sleeptime=sleeptime-30;
 add=add+2;
 if(sleeptime==320)
 {
 add=2;//防止减到1之后再加回来有错
 }
 }
 }
 else if(GetAsyncKeyState(VK_F2))
 {
 if(sleeptime<350)
 {
 sleeptime=sleeptime+30;
 add=add-2;
 if(sleeptime==350)
 {
 add=1; //保证最低分为1
 }
 }
 }
 Sleep(sleeptime);
 snakemove();
 }
}
 
void welcometogame()//开始界面
{
 Pos(40,12);
 
 system("title c语言");
 printf("欢迎来到贪食蛇游戏！");
 Pos(40,25);
 system("pause");
 system("cls");
 Pos(25,12);
 printf("用↑.↓.←.→分别控制蛇的移动， F1 为加速，2 为减速\n");
 Pos(25,13);
 printf("加速将能得到更高的分数。\n");
 system("pause");
 system("cls");
}
 
void endgame()//结束游戏
{
 
 system("cls");
 Pos(24,12);
 if(endgamestatus==1)
 {
 printf("对不起，您撞到墙了。游戏结束.");
 }
 else if(endgamestatus==2)
 {
 printf("对不起，您咬到自己了。游戏结束.");
 }
 else if(endgamestatus==3)
 {
 printf("您的已经结束了游戏。");
 }
 Pos(24,13);
 printf("您的得分是%d\n",score);
 exit(0);
}
 
void gamestart()//游戏初始化
{
 system("mode con cols=100 lines=30");
 welcometogame();
 creatMap();
 initsnake();
 createfood();
}
 
int main()
{
 gamestart();
 gamecircle();
 endgame();
 return 0;
}

[学生成绩管理系统]c实现

#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<stdlib.h>
#include<windows.h>
#include<conio.h>
#include<time.h>
/*********************************宏定义*****************************************/
#define N 100                                //结构体中数组的大小
/*********************************函数声明***************************************/
void save_file();        
void Delay();                
/*********************************自定义数据类型*********************************/
typedef struct stu
{
        char num[N];                        //学号
        char name[N];                        //姓名
        char chinese[N];                //语文
        char math[N];                        //数学

        struct stu* pnext;

}STU;
/*********************************全局变量定义*********************************/
STU* pStu = NULL;                        //表头
STU* pCurrent = NULL;                //当前学生（已经存在）
STU* pNew=NULL;                                //当前学生（待输入）
char KEY[7];                                //服务密码
/*********************************子函数定义***********************************/
//登陆验证        
void InCheck()                                                        
{        
        int InputLimit= 0;
        char keynumber[7]="0";
        int i = 0;

        srand((unsigned)time(NULL));                //生成随机验证码
        for(i=0;i<6;i++)
        {
                KEY[i] = rand() % 10  + 48; 
        }
        KEY[6] = '\0';

        system("cls");
        system("color 3e");

        printf("\n\n\t┌================================================┑\n");
        printf("\n\n");
        printf("\t\t\t欢迎使用学生信息管理系统\n");
        printf("\t\t\t\t\n");
        printf("\t\t\t\t\n");
        printf("\t\t\t\t\n");
        printf("\t\t\t请输入验证码登陆此系统\n");
        printf("\t\t\t<验证码是%s>\n",KEY);
        printf("\t\t\t \n");
        printf("\t\t\t如果3次输入均不正确，将退出系统\n");

        printf("\n\n\t┕================================================┚\n");
        
        
        scanf("%s",keynumber);
        while(strcmp(keynumber,KEY)!=0)
        {        InputLimit++;
                if(InputLimit==3)
                {        printf("\t您输入错误的次数已经到达%d次,您将退出系统",InputLimit);
                        Delay();
                        exit(0);
                }
                printf("\n\t\t您的输入有误!请重新输入\n");
                scanf("%s",keynumber);
        }

        system("cls");
        
}
//检查信息合法性:输入的都是数字字符吗？
char InformationCheck(const char *str)                        
{
        int L = 0;
        int i = 0;
        int PointCount=0;
        int NumCount = 0;


        L = strlen(str);
        for(i=0;i<L;i++)
        {        if(str[i]=='.')
                        PointCount++;
                if((str[i]<'0'||str[i]>'9')&&str[i]!='.')
                {        printf("\t您输入不合法，请重新输入\n");
                        return 1;
                }

        }
        if(PointCount>1)
        {        printf("\t您输入不合法，请重新输入\n");
                return 1;
        }
        else
        {
                return 0;
        }
}
//输入的信息容错后期处理[在InformationCheck,确保没有重大错误之后]
void InformationDebug(char *str)        
{
        int L = 0;
        char PointFlag=0;
        int IntCount = 0;
        int FloatCount = 0;                        //小数部分
        int i = 0;        
        int PositionOfPoint = 0;        //小数点所在的下标
        int ZeroPre = 0;                        //无用的0的个数
        char NotZeroStartFlag=0;        //字符串中开始出现了第一个1-9的数字字符

        L= strlen(str);

        for(i=0;i<L;i++)
        {        if(str[i]>='1'&&str[i]<='9')
                        NotZeroStartFlag=1;

                if(str[i]=='.')
                {        
                        PointFlag = 1;
                        PositionOfPoint = i;
                }
                else if(!PointFlag)
                        IntCount++;
                else
                        FloatCount++;

                if((PointFlag==0)&&(NotZeroStartFlag==0)&&(str[i]=='0')&&(str[i+1]!='.'))        //多余的'0'
                        ZeroPre++;
        }

        if(IntCount==0)                                                                //没有整数部分?
        {
                for(i=L;i>0;i--)
                {
                        str[i]=str[i-1];
                }
                str[0] = '0';
                str[L+1] = '\0';
                PositionOfPoint++;
        }
        if(FloatCount==0&&PointFlag == 1)                        //有小数点却没有小数部分？
        {
                str[PositionOfPoint+1] = '0';
                str[PositionOfPoint+2] = '\0';
        }
        if(ZeroPre>0)
        {
                strcpy(str,str+ZeroPre);
        }
        if(!NotZeroStartFlag)                                                //字符串中从来没有出现过1 -9 字符
        {
                strcpy(str,"0");
        }
}
//检查信息合法性:有没有输入的学号已经存在？
char NumCheck(const char *str)                        
{
        STU * View = NULL;
        int L = 0;
        int i = 0;

        View = pStu->pnext;


        while(View!=NULL)
        {
                if(strcmp(str,View->num)==0)
                {        printf("\t您输入的学号已经存在，请重新输入\n");
                        return 1;
                }
                View=View->pnext;
        }
                                                                                //输入的学号是在0 -9 之内的字符吗
        L = strlen(str);
        for(i=0;i<L;i++)
        {        
                if(str[i]<'0'||str[i]>'9')
                {        printf("\t您输入的字符应在'0'-'9'之间输入，请重新输入\n");
                        return 1;
                }
        }

        return 0;


}
//信息数字检查，,只检查字符串里面是不是只有 '0' - '9' 字符
void NumberCheck(char *str,char *Display)
{
        while(NumCheck(str))
        {
                printf("\t%s:",Display);
                scanf("%s",str);

        }
}
//信息过安检，不仅仅检查字符串里面是不是有除了'0' - '9'和'.'以外的字符，还进行消除冗余的'0'的操作
void SecureCheck(char *str,char *DisPlay)
{
                while(InformationCheck(str))
        {
                
                printf("\t%s:",DisPlay);
                scanf("%s",str);
        }
        InformationDebug(str);
}
//增加学生信息
void AddInformation()                                                                
{        
        int placed=0;
        STU* vIew = NULL;

        system("cls");

        placed=0;
        pNew = (STU *)malloc(sizeof(STU));                        
        pNew->pnext = NULL;
        printf("\t请输入要增加的学生信息:\n");

        printf("\t学号:");
        scanf("%s",pNew->num);
        //信息检查
        NumberCheck(pNew->num,"学号");


        printf("\t姓名:");
        scanf("%s",pNew->name);
        
        
        printf("\t语文:");
        scanf("%s",pNew->chinese);
        //信息检查
        SecureCheck(pNew->chinese,"语文");

        printf("\t数学:");
        scanf("%s",pNew->math);
        //信息检查
        SecureCheck(pNew->math,"数学");
        //信息检查
        vIew = (STU *)malloc(sizeof(STU));
        
        if(pStu->pnext==NULL)
                pStu->pnext=pNew;
        else                                                                //查找最佳位置进行升序插入节点, 维护学号升序顺序的插入
        {        
                vIew->pnext=pStu;
                while(vIew->pnext->pnext!=NULL)
                {
                        if(strcmp(vIew->pnext->num , pNew->num)<=0 && strcmp(vIew->pnext->pnext->num ,pNew->num)>=0)
                        {        
                        
                                pNew->pnext = vIew->pnext->pnext;
                                vIew->pnext->pnext = pNew;
                                placed=1;                                //表示已经放置
                                break;
                                
                        }
                        vIew->pnext = vIew->pnext->pnext;
                }
                if(placed==0)
                        vIew->pnext->pnext = pNew;        //没有找到合适的节点，把pNew挂在链表最后面
                
        }
        
        free(vIew);
        vIew=NULL;
        
}
//显示信息
void ShowInformation()                                        
{
        STU* vIew = NULL;

        system("cls");
        printf("\n\t┍====================显示信息====================┑\n");
        
        
        vIew = (STU *)malloc(sizeof(STU));

        vIew->pnext=pStu->pnext;
        if(vIew->pnext==NULL)
        {
                printf("\n\t\t当前档案内没有学生信息");
        }
        else
        {
                while(vIew->pnext!=NULL)
                {
                printf("\t学号:%s\n",vIew->pnext->num);
                printf("\t姓名:%s\n",vIew->pnext->name);
                printf("\t语文:%s\n",vIew->pnext->chinese);
                printf("\t数学:%s\n",vIew->pnext->math);
                printf("\n\t...................................................\n");
                vIew->pnext=vIew->pnext->pnext;
                }
        }
        free(vIew);
        vIew=NULL;

        printf("\n\t┕====================显示信息完毕================┙\n");

}

//查找信息
void Search()                                                
{
        char serach[N];
        int flag=0;
        char choice='0';
        STU* vIew = NULL;

        system("cls");
                                                                        //选择查找的根据[学号/姓名]
        printf("\n\t输入指令\t 1、按照学号查找 \t2、按照姓名查找\n");
        choice = getch();

        if(choice=='1')
                printf("\t请输入要查找的学生的学号:\n");
        else if(choice=='2')
                printf("\t请输入要查找的学生的姓名:\n");
        else
                printf("\t您的指令输入有误！已经退出查找\n");

        if(choice=='1'||choice=='2')        //如果指令是正确的
        {
                scanf("%s",serach);

        
                vIew = (STU *)malloc(sizeof(STU));

                vIew->pnext=pStu->pnext;
                while(vIew->pnext!=NULL)
                {
                        if((strcmp(vIew->pnext->num,serach)==0&&choice == '1')||(strcmp(vIew->pnext->name,serach)==0&&choice == '2'))
                        {flag=1;
                        printf("\t学号:%s\n",vIew->pnext->num);
                        printf("\t姓名:%s\n",vIew->pnext->name);
                        printf("\t语文:%s\n",vIew->pnext->chinese);
                        printf("\t数学:%s\n",vIew->pnext->math);
                        printf("\n\t...................................................\n");
                        }
                vIew->pnext=vIew->pnext->pnext;
                }
                free(vIew);
                vIew=NULL;

                if(!flag)
                printf("\n!!!!!!!!!!!!!!!!!!!!对不起，查无此人!!!!!!!!!!!!!!!!!!!!!!!!!\n");
        }

}
//删除信息
void Delete()                                                        
{        
        STU *temp;
        char num_serach[N];
        int flag=0;
        STU* vIew = NULL;

        system("cls");

        temp=(STU *)malloc(sizeof(STU));
        
        
        printf("\n\t请输入要删除的学生的学号:\n");
        scanf("%s",num_serach);



        vIew = (STU *)malloc(sizeof(STU));
        
        vIew->pnext=pStu;
        while(vIew->pnext->pnext!=NULL)
        {
                if(strcmp(vIew->pnext->pnext->num,num_serach)==0)                //匹配到了学号
                {
                flag=1;
                printf("\n\n\t待删除的学生信息为:\n");
                printf("\t学号:%s\n",vIew->pnext->pnext->num);
                printf("\t姓名:%s\n",vIew->pnext->pnext->name);
                printf("\t语文:%s\n",vIew->pnext->pnext->chinese);
                printf("\t数学:%s\n",vIew->pnext->pnext->math);
                
                temp ->pnext=vIew->pnext->pnext;                                                //temp->next保存将要删除的节点的地址
                vIew->pnext->pnext=vIew->pnext->pnext->pnext;                        //绕过将要删除的节点

                free(temp->pnext);                                                                                //释放已经被绕过的节点，节省空间
                
                printf("\n\t待删除的学生已经删除\n");                        
                printf("\n\t...................................................\n");
                break;                                                                                                        //删除一个节点之后，跳出循环体
                }
                vIew->pnext=vIew->pnext->pnext;
        }

        free(vIew);
        vIew=NULL;
        free(temp);
        temp=NULL;

        if(!flag)
        printf("\n!!!!!!!!!!!!!!!!!!!!对不起，查无此人!!!!!!!!!!!!!!!!!!!!!!!!!\n");

}
//修改信息
void Modify()                                                                
{        
        char num_serach[N];
        int flag=0;
        STU* vIew = NULL;
        
        system("cls");
        
        printf("\n\t请输入要修改的学生的学号:\n");
        scanf("%s",num_serach);

        
        vIew = (STU *)malloc(sizeof(STU));

        vIew->pnext=pStu->pnext;
        while(vIew->pnext!=NULL)
        {
                if(strcmp(vIew->pnext->num,num_serach)==0)
                {
                        flag=1;
                printf("\t学号:%s\n",vIew->pnext->num);
                printf("\t姓名:%s\n",vIew->pnext->name);
                printf("\t语文:%s\n",vIew->pnext->chinese);
                printf("\t数学:%s\n",vIew->pnext->math);
                printf("\t修改成:\n");
                //新信息的输入
                printf("\t语文:\n");
                scanf("%s",vIew->pnext->chinese);
                //信息检查
                SecureCheck(vIew->pnext->chinese,"语文");

                //信息检查
                printf("\t数学:\n");
                scanf("%s",vIew->pnext->math);
                //信息检查
                SecureCheck(vIew->pnext->math,"数学");
                //信息检查
                
                //AddInformation();        //原则上不修改学号和姓名；但如果要；可以直接用AddInformation()函数
                                                        //去代替新信息的输入
                printf("\n\t...................................................\n");
                }
                vIew->pnext=vIew->pnext->pnext;
        }
        free(vIew);
        vIew=NULL;

        if(!flag)
        printf("\n!!!!!!!!!!!!!!!!!!!!对不起，查无此人!!!!!!!!!!!!!!!!!!!!!!!!!\n");
        
}
//数据统计
void Statistical()
{
        double score    = 0;
        int    Number   = 0;
        int    Over90   = 0;
        int    Below60  = 0;

        STU *View = NULL;
        View = pStu->pnext;
        
        system("cls");

        printf("\t进行数据统计:\n");
        while(View!=NULL)
        {        
                score += atof(View->math) + atof(View->chinese);
                if(atof(View->math)<60||atof(View->chinese)<60)
                {
                        Below60++;
                }
                if(atof(View->math)>=90&&atof(View->chinese)>=90)
                {
                        Over90++;
                }

                Number++;
                View = View->pnext;
        }
        printf("\n\t学生的总人数是:%d",Number);

        if(Number!=0)
                printf("\n\t学生的总平均分是:%.2f",score/Number);
        else
                printf("\n\t学生的总平均分是:0");

        printf("\n\t学生总分数是:%.2f",score);
        printf("\n\t存在不及格科目的学生的人数是:%d",Below60);
        printf("\n\t两科分数均达到90的学生人数是:%d",Over90);
}
//根据总成绩进行排序[改变指针指向的方法进行链表排序]
void Sort()                                                                                
{        
        STU *View_0 = NULL;
        STU *View_1 = NULL;
        STU *View_2 = NULL;
        int StudentNumber = 0;
        int i = 0,j = 0;
        float SortKey1 = 0,SortKey2=0,result=0;                                //排序因素
        char  Choice = 0;
        
        system("cls");
        printf("\n1.以学号为依据排序 2.以总分为依据排序: ");
        Choice = getch();
        printf("%c",Choice);

        while(Choice!='1'&&Choice!='2')
        {        printf("\n输入错误！重新输入  1.以学号为依据排序 2.以总分为依据排序: ");
                Choice = getch();
                printf("%c",Choice);
        }

        
        View_0 = pStu->pnext;
        while(View_0!=NULL)
        {
                View_0 = View_0 ->pnext;
                StudentNumber++;
        }
        printf("\n学生的个数为%d\n",StudentNumber);
        
        if(StudentNumber<2)
        {
                printf("\n表内学生数据少于2个，无需排序\n");//只有头结点或者除了头结点之外只有一个节点,不用排序
        }
        else
        {        
                
                //exchange A(View_1)and B(View_2)                                //冒泡排序
                for(i=0;i<StudentNumber-1;i++)
                {        
                        View_0 = pStu;
                        View_1 = pStu->pnext;
                        View_2 = View_1->pnext;

                        for(j=0;j<StudentNumber-1-i;j++)
                        {        
                                if(Choice=='2')                                                                                //排序因素:是拿什么来排序？
                                {        //学生的总成绩为排序因素
                                        SortKey1 = atof(View_1->math)+atof(View_1->chinese);
                                        SortKey2 = atof(View_2->math)+atof(View_2->chinese);
                                        result = (SortKey1)<(SortKey2)? 1:0;
                                }
                                else
                                {        //学生的学号为排序因素
                                        SortKey1 = atoi(View_1->num);
                                        SortKey2 = atoi(View_2->num);
                                        result = (SortKey1)>(SortKey2)? 1:0;
                                }
                                if(result)
                                {
                                //        printf("%\n%s与%s交换",View_1->num,View_2->num);
                                        View_0->pnext = View_2;
                                        View_1->pnext = View_2->pnext;
                                        View_2->pnext = View_1;        
                                        
                                        View_1 = View_2;
                                        View_2 = View_1->pnext;
                                        

                                }
                                if(View_2->pnext!=NULL)                                        
                                {
                                        View_0 = View_0->pnext;
                                        View_1 = View_0->pnext;
                                        View_2 = View_1->pnext;
                                }
                                
                                //如果最后节点的pnext是空，证明排序完毕，不需要再递进了
                        }
                }
                                printf("\n排序完毕\n");
                        
        }


        
}
//保存信息
void save_file()                                                                
{        
        FILE *file=NULL;
        STU* vIew = NULL;


        file = fopen("C:\\student_file.txt","w+");
        if(file==NULL)
                printf("文件打开失败!\n");
        
        vIew = (STU *)malloc(sizeof(STU));

        vIew->pnext=pStu->pnext;
        while(vIew->pnext!=NULL)
        {
        fputs(vIew->pnext->num,file);
        fputc(0x20,file);
        fputs(vIew->pnext->name,file);
        fputc(0x20,file);
        fputs(vIew->pnext->chinese,file);
        fputc(0x20,file);
        fputs(vIew->pnext->math,file);
        fputc(0x20,file);
        vIew->pnext=vIew->pnext->pnext;
        }
        free(vIew);
        vIew=NULL;        
        
        fputs("END_OF_FILE",file);
        fputc(0x20,file);

        fclose(file);
}
//从文件读入信息
void read_file()                                                                
{        
        int i=0;

        
        FILE *file=NULL;
        file = fopen("C:\\student_file.txt","r");

        if(file==NULL)
        {
                save_file();
                file = fopen("C:\\student_file.txt","r");
        }

        rewind(file);

        pCurrent ->pnext =pStu;
                
        while(1)
        {        pNew = (STU *)malloc(sizeof(STU));
                pNew->pnext = NULL;


                fscanf(file,"%s",pNew->num);
                if(strcmp(pNew->num,"END_OF_FILE")==0)        break;

                fscanf(file,"%s",pNew->name);
                fscanf(file,"%s",pNew->chinese);
                fscanf(file,"%s",pNew->math);
                
                
                pCurrent->pnext->pnext=pNew;                        
                pCurrent->pnext = pCurrent->pnext->pnext;
                //pCurrent->pnext指向现在存在的节点
        
        }
        fclose(file);

}
//短暂延时效果
void Delay()                                                                                                                        
{
        int i = 0;
        int j = 0;

        for(i=50000;i>0;i--)
                for(j=5000;j>0;j--)
                        ;
}
//系统初始化
void init()                
{
        pStu = (STU *)malloc(sizeof(STU));                                        //创建头节点
        pStu->pnext  =NULL;
        strcpy(pStu->num, "0");
        strcpy(pStu->name, " ");

        pCurrent = (STU *)malloc(sizeof(STU));
        pCurrent ->pnext =NULL;

        read_file();

}
//欢迎使用
void Welcome()                                                                        
{        system("cls");
        
        printf("\n\n\t┌================================================┑\n");
        printf("\n\n");
        printf("\t\t★★★欢迎使用学生信息管理系统★★★\n\n\n");
        printf("\t\t\t1.查看信息\n");
        printf("\t\t\t2.增加信息\n");
        printf("\t\t\t3.查找信息\n");
        printf("\t\t\t4.修改信息\n");
        printf("\t\t\t5.删除信息\n");
        printf("\t\t\t6.学生排序\n");
        printf("\t\t\t7.数据统计\n");
        printf("\t\t\t8.退出系统\n");
        printf("\n\n\t┕================================================┚\n");
}
/************************************主函数************************************/
int main()
{
        char choice  = 0;
        char AddYorN = 0;

        init();
        InCheck();
        Welcome();
//        MessageBox(0, "", 0);

                                                                                                                        //命令解释
        
        while(choice!='8')
        {        
                printf("\n>>");                                                                                //输入命令
                choice=getch();
                printf("%c",choice);

                switch(choice)
                {
                        case '1':ShowInformation();                
                                break;
                        case '2':        do
                                                {
                                                        AddInformation();        save_file();
                                                        printf("输入N可以退出增加信息.任意键继续输入\n");AddYorN=getch();printf("%c",AddYorN);
                                                }while(AddYorN!='N');
                                break;        
                        case '3':Search();
                                break;        
                        case '4':Modify();        save_file();        
                                break;
                        case '5':Delete();        save_file();
                                break;
                        case '6':Sort();        save_file();
                                break;
                        case '7':Statistical();
                                break;
                        case '8':
                                break;
                        default:printf("\t\t任意键返回主菜单\n");getch();Welcome();
                        
                }
}
        
    system("cls");
        system("color 81");
        printf("\n\t\t感谢您的使用，再见!\n");
        Delay();

        
        save_file();
        return 0;

}
查看所有文章