visualc60c语言

1. c语言转换为VB.NET

Option Explicit On
Option Strict On
Imports System
Mole Program
Sub Main()
Dim y,m,t As Integer
begin:
' 输入数据时一行一个
y=CInt(Console.ReadLine())
m=CInt(Console.ReadLine())
t=CInt(Console.ReadLine())
If y
200 Then
Console.WriteLine("ERROR")
goto begin
End If
pr(y,m,t)
Console.Write("Press any key to continue . . . ")
Console.ReadKey(True)
End Sub
Function pr(y As Integer,m As Integer,t As Integer) As Integer
Dim ye,[Me],i As Integer
ye=CInt((m+t-2)/12+y)
[Me]=(m+t-2) Mod 12+1

End If
End Function
Function mday(y As Integer,m As Integer) As Integer
Dim day As Integer()={0,31,28,31,30,31,30,31,31,30,31,30,31}
Dim ad As I

2. C语言编程问题 成绩统计

Open "C:\score2007.txt" For Input As #1
Dim linetxt As String
Dim c90, c80, c70, c60, c0 As Integer

Do While Not EOF(1)
Line Input #1, linetxt
If Len(Trim(linetxt)) > 0 Then
tmpArr = Split(linetxt, " ")
Select Case CDbl(tmpArr(1))
Case Is >= 90
c90 = c90 + 1
Case Is >= 80
c80 = c80 + 1
Case Is >= 70
c70 = c70 + 1
Case Is >= 60
c60 = c60 + 1
Case Else
c0 = c0 + 1
End Select
End If
Loop
Close #1

Open "c:\renshu.txt" For Output As #2

Print #2, "100-90 共：" + CStr(c90) + " 人"
Print #2, "---------------------------------------------------"
Print #2, "89-80 共：" + CStr(c80) + " 人"
Print #2, "---------------------------------------------------"
Print #2, "79-70 共：" + CStr(c70) + " 人"
Print #2, "---------------------------------------------------"
Print #2, "69-60 共：" + CStr(c60) + " 人"
Print #2, "---------------------------------------------------"
Print #2, "59-0 共：" + CStr(c0) + " 人"
Print #2, "---------------------------------------------------"
Close #2

3. Compac Visual Fortran 如何做并行计算

程序要实现并行其实有两个方面，不单单是编译器的问题，首先你还要装并行库，比如mpich;其次，你要把源程序改为并行程序，要加上一些并行语句如MPI_Init (&argc, &argv)，必要时还应该把程序结构改为适用于并行。最后，你就可以把程序编译为并行执行码了，祝你好运！
给你一个vc++配置编译并行的网址，cvf也应该差不多，windows下并行其实我没做过，我主要在linux下做并行，
http://securelvlan.spaces.live.com/Blog/cns!C60FD6EABDDFC877!250.entry

4. vscode怎么创建c项目

vscode怎样编写c程序？

一、获取C/C++扩展

1、打开vscode

2、ctrl+shift+x打开商店

3、搜索C/C++安装、重启vscode

.png

二、安装GCC

1、下载MinGW

2、打开安装程序，安装到D盘（需要创建MinGW文件夹），安装完成之后生成MinGW安装管理器

3、管理器自动打开（如果没有请手动），点击All Packages,选中gcc.bin,g++.bin,gdb.bin,点击Installation,选择Apply Changes,点击Apply提交进行安装

.png

win+R,输入control进入控制面板,依次点击系统与安装->系统->高级系统设置->环境变量，找到Path->编辑->新建，将安装好的MinGW的bin文件夹路径粘贴进去。

.png

三、配置智能提示

1、编写一个测试文件demo.c,点击引入的标准库下的“提示灯”,生成c_cpp_properties.json文件

2、编辑c_cpp_properties.json

.png

c_cpp_properties.json修改内容如下：

.png

四、开启调试功能

F5或Ctrl+F5启用调试，选择C++(GDB/LLDB)生成launch.json文件，修改如下：

Ctrl+Shift+P输入Tasks:Configure Task配置任务，选择使用模块创建task.json文件，选择Others模板，生成task.json文件，修改如下：

如果出现错误：进程终止，退出代码：1，可能是gcc还没被编辑器加载（测试方法：打开控制台，输入gcc，看提示信息），重启编辑器就可以。

5. c语言在vc++下 编程的俄罗斯方源程序

以下代码来自 easyx 官网，已经测试过可以用，支持各版本 vc。需要安装 easyx 库才能编译。

项目直接建立控制台项目就好了。

////////////////////////////////////////////
//程序名称：俄罗斯方块
//编译环境：VisualC++6.0/2010，EasyX_v20131006(beta)
//程序编写：krissi<[email protected]>
//更新记录：2010-12-18	[email protected]编写
//2011-9-28	[email protected]修改了下落超时的逻辑
//[email protected]修改了绘制方法，将原来的立体效果修改为扁平效果
//
#include<easyx.h>
#include<conio.h>
#include<time.h>/////////////////////////////////////////////
//定义常量、枚举量、结构体、全局变量
/////////////////////////////////////////////

#define	WIDTH	10		//游戏区宽度
#define	HEIGHT	22		//游戏区高度
#define	UNIT	20		//每个游戏区单位的实际像素

//定义操作类型
enumCMD
{
	CMD_ROTATE,						//方块旋转
	CMD_LEFT,CMD_RIGHT,CMD_DOWN,	//方块左、右、下移动
	CMD_SINK,						//方块沉底
	CMD_QUIT						//退出游戏
};

//定义绘制方块的方法
enumDRAW
{
	SHOW,	//显示方块
	CLEAR,	//擦除方块
	FIX		//固定方块
};

//定义七种俄罗斯方块
structBLOCK
{
	WORDdir[4];	//方块的四个旋转状态
	COLORREFcolor;	//方块的颜色
}	g_Blocks[7]={	{0x0F00,0x4444,0x0F00,0x4444,RED},		//I
					{0x0660,0x0660,0x0660,0x0660,BLUE},		//口
					{0x4460,0x02E0,0x0622,0x0740,MAGENTA},	//L
					{0x2260,0x0E20,0x0644,0x0470,YELLOW},	//反L
					{0x0C60,0x2640,0x0C60,0x2640,CYAN},		//Z
					{0x0360,0x4620,0x0360,0x4620,GREEN},	//反Z
					{0x4E00,0x4C40,0x0E40,0x4640,BROWN}};	//T

//定义当前方块、下一个方块的信息
structBLOCKINFO
{
	byteid;	//方块ID
	charx,y;	//方块在游戏区中的坐标
	bytedir:2;	//方向
}	g_CurBlock,g_NextBlock;

//定义游戏区
BYTEg_World[WIDTH][HEIGHT]={0};/////////////////////////////////////////////
//函数声明
/////////////////////////////////////////////

voidInit();											//初始化游戏
voidQuit();											//退出游戏
voidNewGame();											//开始新游戏
voidGameOver();										//结束游戏
CMDGetCmd();											//获取控制命令
voidDispatchCmd(CMD_cmd);								//分发控制命令
voidNewBlock();										//生成新的方块
boolCheckBlock(BLOCKINFO_block);						//检测指定方块是否可以放下
voidDrawUnit(intx,inty,COLORREFc,DRAW_draw);	//画单元方块
voidDrawBlock(BLOCKINFO_block,DRAW_draw=SHOW);	//画方块
voidOnRotate();										//旋转方块
voidOnLeft();											//左移方块
voidOnRight();											//右移方块
voidOnDown();											//下移方块
voidOnSink();											//沉底方块/////////////////////////////////////////////
//函数定义
/////////////////////////////////////////////

//主函数
voidmain()
{
	Init();

	CMDc;
	while(true)
	{
		c=GetCmd();
		DispatchCmd(c);

		//按退出时，显示对话框咨询用户是否退出
		if(c==CMD_QUIT)
		{
			HWNDwnd=GetHWnd();
			if(MessageBox(wnd,_T("您要退出游戏吗？"),_T("提醒"),MB_OKCANCEL|MB_ICONQUESTION)==IDOK)
				Quit();
		}
	}
}


//初始化游戏
voidInit()
{
	initgraph(640,480);
	srand((unsigned)time(NULL));
	setbkmode(TRANSPARENT);			//设置图案填充的背景色为透明

	//显示操作说明
	settextstyle(14,0,_T("宋体"));
	outtextxy(20,330,_T("操作说明"));
	outtextxy(20,350,_T("上：旋转"));
	outtextxy(20,370,_T("左：左移"));
	outtextxy(20,390,_T("右：右移"));
	outtextxy(20,410,_T("下：下移"));
	outtextxy(20,430,_T("空格：沉底"));
	outtextxy(20,450,_T("ESC：退出"));

	//设置坐标原点
	setorigin(220,20);

	//绘制游戏区边界
	rectangle(-1,-1,WIDTH*UNIT,HEIGHT*UNIT);
	rectangle((WIDTH+1)*UNIT-1,-1,(WIDTH+5)*UNIT,4*UNIT);

	//开始新游戏
	NewGame();
}


//退出游戏
voidQuit()
{
	closegraph();
	exit(0);
}


//开始新游戏
voidNewGame()
{
	//清空游戏区
	setfillcolor(BLACK);
	solidrectangle(0,0,WIDTH*UNIT-1,HEIGHT*UNIT-1);
	ZeroMemory(g_World,WIDTH*HEIGHT);

	//生成下一个方块
	g_NextBlock.id=rand()%7;
	g_NextBlock.dir=rand()%4;
	g_NextBlock.x=WIDTH+1;
	g_NextBlock.y=HEIGHT-1;

	//获取新方块
	NewBlock();
}


//结束游戏
voidGameOver()
{
	HWNDwnd=GetHWnd();
	if(MessageBox(wnd,_T("游戏结束。
您想重新来一局吗？"),_T("游戏结束"),MB_YESNO|MB_ICONQUESTION)==IDYES)
		NewGame();
	else
		Quit();
}


//获取控制命令
DWORDm_oldtime;
CMDGetCmd()
{
	//获取控制值
	while(true)
	{
		//如果超时，自动下落一格
		DWORDnewtime=GetTickCount();
		if(newtime-m_oldtime>=500)
		{
			m_oldtime=newtime;
			returnCMD_DOWN;
		}

		//如果有按键，返回按键对应的功能
		if(kbhit())
		{
			switch(getch())
			{
				case'w':
				case'W':	returnCMD_ROTATE;
				case'a':
				case'A':	returnCMD_LEFT;
				case'd':
				case'D':	returnCMD_RIGHT;
				case's':
				case'S':	returnCMD_DOWN;
				case27:	returnCMD_QUIT;
				case'':	returnCMD_SINK;
				case0:
				case0xE0:
					switch(getch())
					{
						case72:	returnCMD_ROTATE;
						case75:	returnCMD_LEFT;
						case77:	returnCMD_RIGHT;
						case80:	returnCMD_DOWN;
					}
			}
		}

		//延时(降低CPU占用率)
		Sleep(20);
	}
}


//分发控制命令
voidDispatchCmd(CMD_cmd)
{
	switch(_cmd)
	{
		caseCMD_ROTATE:	OnRotate();		break;
		caseCMD_LEFT:		OnLeft();		break;
		caseCMD_RIGHT:		OnRight();		break;
		caseCMD_DOWN:		OnDown();		break;
		caseCMD_SINK:		OnSink();		break;
		caseCMD_QUIT:		break;
	}
}


//生成新的方块
voidNewBlock()
{
	g_CurBlock.id=g_NextBlock.id,		g_NextBlock.id=rand()%7;
	g_CurBlock.dir=g_NextBlock.dir,	g_NextBlock.dir=rand()%4;
	g_CurBlock.x=(WIDTH-4)/2;
	g_CurBlock.y=HEIGHT+2;

	//下移新方块直到有局部显示
	WORDc=g_Blocks[g_CurBlock.id].dir[g_CurBlock.dir];
	while((c&0xF)==0)
	{
		g_CurBlock.y--;
		c>>=4;
	}

	//绘制新方块
	DrawBlock(g_CurBlock);

	//绘制下一个方块
	setfillcolor(BLACK);
	solidrectangle((WIDTH+1)*UNIT,0,(WIDTH+5)*UNIT-1,4*UNIT-1);
	DrawBlock(g_NextBlock);

	//设置计时器，用于判断自动下落
	m_oldtime=GetTickCount();
}


//画单元方块
voidDrawUnit(intx,inty,COLORREFc,DRAW_draw)
{
	//计算单元方块对应的屏幕坐标
	intleft=x*UNIT;
	inttop=(HEIGHT-y-1)*UNIT;
	intright=(x+1)*UNIT-1;
	intbottom=(HEIGHT-y)*UNIT-1;

	//画单元方块
	switch(_draw)
	{
		caseSHOW:
			//画普通方块
			setlinecolor(0x006060);
			roundrect(left+1,top+1,right-1,bottom-1,5,5);
			setlinecolor(0x003030);
			roundrect(left,top,right,bottom,8,8);
			setfillcolor(c);
			setlinecolor(LIGHTGRAY);
			fillrectangle(left+2,top+2,right-2,bottom-2);
			break;

		caseFIX:
			//画固定的方块
			setfillcolor(RGB(GetRValue(c)*2/3,GetGValue(c)*2/3,GetBValue(c)*2/3));
			setlinecolor(DARKGRAY);
			fillrectangle(left+1,top+1,right-1,bottom-1);
			break;

		caseCLEAR:
			//擦除方块
			setfillcolor(BLACK);
			solidrectangle(x*UNIT,(HEIGHT-y-1)*UNIT,(x+1)*UNIT-1,(HEIGHT-y)*UNIT-1);
			break;
	}
}


//画方块
voidDrawBlock(BLOCKINFO_block,DRAW_draw)
{
	WORDb=g_Blocks[_block.id].dir[_block.dir];
	intx,y;

	for(inti=0;i<16;i++,b<<=1)
		if(b&0x8000)
		{
			x=_block.x+i%4;
			y=_block.y-i/4;
			if(y<HEIGHT)
				DrawUnit(x,y,g_Blocks[_block.id].color,_draw);
		}
}


//检测指定方块是否可以放下
boolCheckBlock(BLOCKINFO_block)
{
	WORDb=g_Blocks[_block.id].dir[_block.dir];
	intx,y;

	for(inti=0;i<16;i++,b<<=1)
		if(b&0x8000)
		{
			x=_block.x+i%4;
			y=_block.y-i/4;
			if((x<0)||(x>=WIDTH)||(y<0))
				returnfalse;

			if((y<HEIGHT)&&(g_World[x][y]))
				returnfalse;
		}

	returntrue;
}


//旋转方块
voidOnRotate()
{
	//获取可以旋转的x偏移量
	intdx;
	BLOCKINFOtmp=g_CurBlock;
	tmp.dir++;					if(CheckBlock(tmp))	{	dx=0;		gotorotate;	}
	tmp.x=g_CurBlock.x-1;	if(CheckBlock(tmp))	{	dx=-1;	gotorotate;	}
	tmp.x=g_CurBlock.x+1;	if(CheckBlock(tmp))	{	dx=1;		gotorotate;	}
	tmp.x=g_CurBlock.x-2;	if(CheckBlock(tmp))	{	dx=-2;	gotorotate;	}
	tmp.x=g_CurBlock.x+2;	if(CheckBlock(tmp))	{	dx=2;		gotorotate;	}
	return;

rotate:
	//旋转
	DrawBlock(g_CurBlock,CLEAR);
	g_CurBlock.dir++;
	g_CurBlock.x+=dx;
	DrawBlock(g_CurBlock);
}


//左移方块
voidOnLeft()
{
	BLOCKINFOtmp=g_CurBlock;
	tmp.x--;
	if(CheckBlock(tmp))
	{
		DrawBlock(g_CurBlock,CLEAR);
		g_CurBlock.x--;
		DrawBlock(g_CurBlock);
	}
}


//右移方块
voidOnRight()
{
	BLOCKINFOtmp=g_CurBlock;
	tmp.x++;
	if(CheckBlock(tmp))
	{
		DrawBlock(g_CurBlock,CLEAR);
		g_CurBlock.x++;
		DrawBlock(g_CurBlock);
	}
}


//下移方块
voidOnDown()
{
	BLOCKINFOtmp=g_CurBlock;
	tmp.y--;
	if(CheckBlock(tmp))
	{
		DrawBlock(g_CurBlock,CLEAR);
		g_CurBlock.y--;
		DrawBlock(g_CurBlock);
	}
	else
		OnSink();	//不可下移时，执行“沉底方块”操作
}


//沉底方块
voidOnSink()
{
	inti,x,y;

	//连续下移方块
	DrawBlock(g_CurBlock,CLEAR);
	BLOCKINFOtmp=g_CurBlock;
	tmp.y--;
	while(CheckBlock(tmp))
	{
		g_CurBlock.y--;
		tmp.y--;
	}
	DrawBlock(g_CurBlock,FIX);

	//固定方块在游戏区
	WORDb=g_Blocks[g_CurBlock.id].dir[g_CurBlock.dir];
	for(i=0;i<16;i++,b<<=1)
		if(b&0x8000)
		{
			if(g_CurBlock.y-i/4>=HEIGHT)
			{	//如果方块的固定位置超出高度，结束游戏
				GameOver();
				return;
			}
			else
				g_World[g_CurBlock.x+i%4][g_CurBlock.y-i/4]=1;
		}

	//检查是否需要消掉行，并标记
	BYTEremove=0;	//低4位用来标记方块涉及的4行是否有消除行为
	for(y=g_CurBlock.y;y>=max(g_CurBlock.y-3,0);y--)
	{
		i=0;
		for(x=0;x<WIDTH;x++)
			if(g_World[x][y]==1)
				i++;

		if(i==WIDTH)
		{
			remove|=(1<<(g_CurBlock.y-y));
			setfillcolor(LIGHTGREEN);
			setlinecolor(LIGHTGREEN);
			setfillstyle(BS_HATCHED,HS_DIAGCROSS);
			fillrectangle(0,(HEIGHT-y-1)*UNIT+UNIT/2-5,WIDTH*UNIT-1,(HEIGHT-y-1)*UNIT+UNIT/2+5);
			setfillstyle(BS_SOLID);
		}
	}

	if(remove)	//如果产生整行消除
	{
		//延时300毫秒
		Sleep(300);

		//擦掉刚才标记的行
		IMAGEimg;
		for(i=0;i<4;i++,remove>>=1)
		{
			if(remove&1)
			{
				for(y=g_CurBlock.y-i+1;y<HEIGHT;y++)
					for(x=0;x<WIDTH;x++)
					{
						g_World[x][y-1]=g_World[x][y];
						g_World[x][y]=0;
					}

				getimage(&img,0,0,WIDTH*UNIT,(HEIGHT-(g_CurBlock.y-i+1))*UNIT);
				putimage(0,UNIT,&img);
			}
		}
	}

	//产生新方块
	NewBlock();
}

6. 用c语言编写俄罗斯方块程序 求详解

1、用C语言绘制图形界面

EasyX图形库(http://www.easyx.cn)即TC的图形库在VC下的移植。

包含库#include <graphics.h>

先初始化图形窗口

initgraph(WINDOW_WIDTH, WINDOW_HIGH) ;WINDOW_WIDTH为窗口的宽带，WINDOW_HIGH为窗口的高度。

清空绘图设备

cleardevice();

设置画笔颜色

setcolor(RED) ;

设置线条风格

setlinestyle(PS_SOLID, NULL, 0);

画矩形

rectangle

还有画线、显示文字等函数，可以参照其帮助文档。

注意：由于我们用的是EasyX图形库，故源文件后缀要为.cpp，但其中内容都是C的语法。

2、存储表示出俄罗斯方块的形状

一、我们可以用编号，不同的编号代表不同的俄罗斯方块，根据编号把不同方块的画法写在代码中，这样19种

方块就得有19种相应的代码来描绘。而且这样扩展性不好，若以后设计了新的方块，则需要更改大量源代码。

二、我们很自然的想到可用字模点阵的形式来表示，即设置一个4行4列的数组，元素置1即代表这个位置有小

方块，元素置0即代表这个位置无小方块，这个整个的4*4的数组组成俄罗斯方块的形状。

1000

1000

1100

0000

我们把俄罗斯方块点阵的数位存在rockArray中，我们可以事先把这19种方块的字模点阵自己转化成十六进制，然后在rockArray数组的初始化时赋值进去。

但这样做未免有点太费力，且扩展性也不太好，若以后设计的新方块种类加入，要改变数组rockArray中的值。

我们可以考虑把所有俄罗斯方块的点阵存储在配置文件中，在程序初始化时读取文件，把这些点阵转换成unsigned int的变量存储在rockArray中。

这样，以后我们增添新的方块形状只需要在配置文件中增加新的点阵即可。

@###

@###

@@##

####（为使得看起来更醒目，我们用@表示1，用#表示0）

3、让图形动起来

在某位置处用函数DrawRock在屏幕上画出俄罗斯方块，然后再擦除掉(即用背景色在原位置处重绘一次方块)，最后在下落的下一个位置处用函数DrawRock在屏幕上画出俄罗斯方块，如此循环，中间用计时器间隔一段时间以控制下落的速度。

同理，按下屏幕的左右键也是如此，只是在按下键盘时把方块的位置重新计算了。

那么按下上方向键时，如何让方块翻转呢？

我们在配置文件中就把方块的顺时针翻转形态放在了一起：

@###

@###

@@##

####

@@@#

@###

####

####

@@##

#@##

#@##

####

##@#

@@@#

####

####

我们每按一次上方向键改变一次方块的形状即可。若一直按上键，形状应该是循环地翻滚。

我们想到了循环链表的数据结构可实现这个效果。

可是我们若把这些一种类的方块的各种形态串成循环链表形式，那么每次重新生成方块时我们就难以随机地生成方块了。

故还是得用数组来存储，但又要有循环链表的功能，于是我们想到了静态循环链表。

我们用结构体来作为一个方块在rockArray中的元素

typedef struct ROCK

{ //用来表示方块的形状(每一个字节是8位，用每4位表示方块中的一行)

unsigned int rockShapeBits ;

int nextRockIndex ; //下一个方块，在数组中的下标

} RockType ;

这样，当我们按下上方向键时，把传入函数DrawRock中的rockIndex变为当前方块结构体中的nextRockIndex即可。

7. 求一个用C语言编写的小游戏代码

/*也不知道你是什么级别的，我是一个新手，刚接触编程语言，以下是我自己变得一个小程序，在所有c语言的编译器（vc++6.0、turbo…………）上都能运行，你还可以进一步改进。这是一个类似贪吃蛇的小游戏。祝你好运*/
/*贪吃蛇*/
#include<stdio.h>
#include<time.h>
#include<conio.h>
#include<stdlib.h>
int head=3 ,tail=0;
int main()
{
int i,j,k=0;
int zuobiao[2][80];
long start;
int direction=77;
int gamespeed;
int timeover;
int change(char qipan[20][80],int zuobiao[2][80],char direction);
zuobiao[0][tail]=1;zuobiao[1][tail]=1;zuobiao[0][1]=1;zuobiao[1][1]=2;zuobiao[0][2]=1;zuobiao[1][2]=3;zuobiao[0][head]=1;zuobiao[1][head]=4;
/*处理棋盘*/
char qipan[20][80];//定义棋盘
for(i=0;i<20;i++)
for(j=0;j<80;j++)
qipan[i][j]=' ';//初始化棋盘
for(i=0;i<80;i++)
qipan[0][i]='_';
for(i=0;i<20;i++)
qipan[i][0]='|';
for(i=0;i<20;i++)
qipan[i][79]='|';
for(i=0;i<80;i++)
qipan[19][i]='_';
qipan[1][1]=qipan[1][2]=qipan[1][3]='*';//初始化蛇的位置
qipan[1][4]='#';
printf("This is a game of a SNAKE.\nGOOD LUCK TO YOU !\n");
printf("Input your game speed,please.(e.g.300)\n");
scanf("%d",&gamespeed);

while(direction!='q')
{
system("cls");
for(i=0;i<20;i++)//打印出棋盘
for(j=0;j<80;j++)
printf("%c",qipan[i][j]);
timeover=1;
start=clock();
while(!kbhit()&&(timeover=clock()-start<=gamespeed));
if(timeover)
{
getch();
direction=getch();
}
else
direction=direction;
if(!(direction==72||direction==80||direction==75||direction==77))
{
return 0;
system("cls");
printf("GAME OVER!\n");
}
if(!change(qipan,zuobiao,direction))
{
direction='q';
system("cls");
printf("GAME OVER!\n");
}
}
return 0;
}
int change(char qipan[20][80],int zuobiao[2][80],char direction)
{
int x,y;
if(direction==72)
x=zuobiao[0][head]-1;y=zuobiao[1][head];
if(direction==80)
x=zuobiao[0][head]+1;y=zuobiao[1][head];
if(direction==75)
x=zuobiao[0][head];y=zuobiao[0][head]-1;
if(direction==77)
x=zuobiao[0][head];y=zuobiao[1][head]+1;
if(x==0||x==18||y==78||y==0)
return 0;
if(qipan[x][y]!=' ')
return 0;
qipan[zuobiao[0][tail]][zuobiao[1][tail]]=' ';
tail=(tail+1)%80;
qipan[zuobiao[0][head]][zuobiao[1][head]]='*';
head=(head+1)%80;
zuobiao[0][head]=x;
zuobiao[1][head]=y;
qipan[zuobiao[0][head]][zuobiao[1][head]]='#';
return 1;
}

8. c语言：编写程序，输入是个学生的学号、姓名成绩，输出学生成绩等级和不及格人数。

strcpy(students[i].grade,"set_grade(score)"); => students[i].grade=set_grade(score);

students[i].grade-"D"==0 => students[i].grade-'D'==0

9. 将C语言转换成VB

C语言转成VB不是可能，只是难度太大，你这10分实在太吝啬了。
而且有一些是无法转换的，例如你这句
#include "CRC.h"
这个CRC.h，VB语言是不兼容的。
我劝你还是好好学习吧。这种偷懒的事情，我大学里干过，在处理实验数据时，随便抄了个程序（fortran语言），又怕都是发现，于是把fortran语言转成C语言，一心想着欺负老师看不懂（或者不熟悉）C语言，居然给蒙混过关，一开始还沾沾自喜，现在想起，两种语言风牛马不相及，只不过是都是不愿意跟学生计较罢了，想起来真是惭愧。

10. C语言编程，要求有反代码，功能不限，20行以上，求高手帮忙啊

#include "stdafx.h"
#include <stdio.h> //身份证号码升级
int main()
{
int i,wi=0;
char sh[19],a[4];
int w[17]={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};
char y[12]={"10x98765432"};
printf("请输入15位身份证号码:");
scanf("%s",sh);
printf("\n");
for(i=15;i>=6;i--)
sh[i+2]=sh[i];
sh[6]='1';sh[7]='9';
printf("\n");
for(i=0;i<17;i++)
wi+=(sh[i]-'0')*w[i];
sh[17]=y[wi%11];
sh[18]='\0';
printf("18位身份证号码是:%s\n",sh);
}

汇编：
int main()
{
000B6C26 inc ebp
000B6C27 cld
int i, wi = 0;
000B6C28 mov dword ptr [wi],0
char sh[19];
int w[17] = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };
000B6C2F mov dword ptr [w],7
000B6C36 mov dword ptr [ebp-7Ch],9
000B6C3D mov dword ptr [ebp-78h],0Ah
000B6C44 mov dword ptr [ebp-74h],5
000B6C4B mov dword ptr [ebp-70h],8
000B6C52 mov dword ptr [ebp-6Ch],4
000B6C59 mov dword ptr [ebp-68h],2
000B6C60 mov dword ptr [ebp-64h],1
000B6C67 mov dword ptr [ebp-60h],6
000B6C6E ?? ??
000B6C6F ?? ??
000B6C70 ?? ??
000B6C71 ?? ??
000B6C72 add byte ptr [eax],al
000B6C74 add bh,al
000B6C76 inc ebp
000B6C77 test al,7
000B6C79 add byte ptr [eax],al
000B6C7B add bh,al
000B6C7D inc ebp
000B6C7E lods byte ptr [esi]
char sh[19];
int w[17] = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };
000B6C7F or dword ptr [eax],eax
000B6C81 add byte ptr [eax],al
000B6C83 mov dword ptr [ebp-50h],0Ah
000B6C8A mov dword ptr [ebp-4Ch],5
000B6C91 mov dword ptr [ebp-48h],8
000B6C98 mov dword ptr [ebp-44h],4
000B6C9F mov dword ptr [ebp-40h],2
char y[12] = { "10x98765432" };
000B6CA6 mov eax,dword ptr ds:[000BED84h]
000B6CAB mov dword ptr [y],eax
000B6CB1 mov ecx,dword ptr ds:[0BED88h]
000B6CB7 mov dword ptr [ebp-90h],ecx
000B6CBD mov edx,dword ptr ds:[0BED8Ch]
char y[12] = { "10x98765432" };
000B6CC3 mov dword ptr [ebp-8Ch],edx
cout<<"请输入15位身份证号码:";
000B6CC9 push 0BED94h
000B6CCE mov eax,dword ptr ds:[000C20C0h]
000B6CD3 push eax
000B6CD4 call std::operator<<<std::char_traits<char> > (0B1302h)
000B6CD9 add esp,8
cin >> sh;
000B6CDC lea eax,[sh]
000B6CDF push eax
000B6CE0 mov ecx,dword ptr ds:[0C20BCh]
000B6CE6 push ecx
000B6CE7 call std::operator>><char,std::char_traits<char> > (0B10E1h)
000B6CEC add esp,8
for (i = 15; i >= 6; i--)
000B6CEF mov dword ptr [i],0Fh
000B6CF6 jmp main+101h (0B6D01h)
000B6CF8 mov eax,dword ptr [i]
000B6CFB sub eax,1
000B6CFE mov dword ptr [i],eax
000B6D01 cmp dword ptr [i],6
000B6D05 jl main+117h (0B6D17h)
sh[i + 2] = sh[i];
000B6D07 mov eax,dword ptr [i]
000B6D0A mov ecx,dword ptr [i]
000B6D0D mov dl,byte ptr sh[ecx]
000B6D11 mov byte ptr [ebp+eax-32h],dl
000B6D15 jmp main+0F8h (0B6CF8h)
sh[6] = '1'; sh[7] = '9';
000B6D17 mov eax,1
000B6D1C imul ecx,eax,6
000B6D1F mov byte ptr sh[ecx],31h
000B6D24 mov eax,1
000B6D29 imul ecx,eax,7
000B6D2C mov byte ptr sh[ecx],39h
printf("\n");
000B6D31 mov esi,esp
000B6D33 push 0BEDB0h
000B6D38 call dword ptr ds:[0C2220h]
000B6D3E add esp,4
000B6D41 cmp esi,esp
000B6D43 call __RTC_CheckEsp (0B1398h)
for (i = 0; i<17; i++)
000B6D48 mov dword ptr [i],0
000B6D4F jmp main+15Ah (0B6D5Ah)
000B6D51 mov eax,dword ptr [i]
000B6D54 add eax,1
000B6D57 mov dword ptr [i],eax
000B6D5A cmp dword ptr [i],11h
000B6D5E jge main+17Bh (0B6D7Bh)
wi += (sh[i] - '0')*w[i];
000B6D60 mov eax,dword ptr [i]
000B6D63 movsx ecx,byte ptr sh[eax]
000B6D68 sub ecx,30h
000B6D6B mov edx,dword ptr [i]
000B6D6E imul ecx,dword ptr w[edx*4]
000B6D73 add ecx,dword ptr [wi]
000B6D76 mov dword ptr [wi],ecx
000B6D79 jmp main+151h (0B6D51h)
sh[17] = y[wi % 11];
000B6D7B mov eax,dword ptr [wi]
000B6D7E cdq
000B6D7F mov ecx,0Bh
000B6D84 idiv eax,ecx
000B6D86 mov eax,1
000B6D8B imul ecx,eax,11h
000B6D8E mov dl,byte ptr y[edx]
000B6D95 mov byte ptr sh[ecx],dl
sh[18] = '\0';
000B6D99 mov eax,1
sh[18] = '\0';
000B6D9E imul ecx,eax,12h
000B6DA1 mov dword ptr [ebp-160h],ecx
000B6DA7 cmp dword ptr [ebp-160h],13h
000B6DAE jae main+1B2h (0B6DB2h)
000B6DB0 jmp main+1B7h (0B6DB7h)
000B6DB2 call ___report_rangecheckfailure (0B1415h)
000B6DB7 mov edx,dword ptr [ebp-160h]
000B6DBD mov byte ptr sh[edx],0
cout << "18位身份证号码是:" << sh << "\n";
000B6DC2 push 0BEDB0h
000B6DC7 lea eax,[sh]
000B6DCA push eax
000B6DCB push 0BEDB4h
000B6DD0 mov ecx,dword ptr ds:[0C20C0h]
000B6DD6 push ecx
000B6DD7 call std::operator<<<std::char_traits<char> > (0B1302h)
000B6DDC add esp,8
000B6DDF push eax
000B6DE0 call std::operator<<<std::char_traits<char> > (0B1302h)
000B6DE5 add esp,8
000B6DE8 push eax
000B6DE9 call std::operator<<<std::char_traits<char> > (0B1302h)
000B6DEE add esp,8
}
000B6DF1 jmp main+1F5h (0B6DF5h)
000B6DF3 jmp main+1F7h (0B6DF7h)
000B6DF5 xor eax,eax
000B6DF7 push edx
000B6DF8 mov ecx,ebp
000B6DFA push eax
000B6DFB lea edx,ds:[0B6E28h]
000B6E01 call @_RTC_CheckStackVars@8 (0B1159h)
000B6E06 pop eax
000B6E07 pop edx
000B6E08 pop edi
000B6E09 pop esi
000B6E0A pop ebx
000B6E0B mov ecx,dword ptr [ebp-4]
000B6E0E xor ecx,ebp
000B6E10 call @__security_check_cookie@4 (0B1050h)
000B6E15 add esp,164h
000B6E1B cmp ebp,esp
000B6E1D call __RTC_CheckEsp (0B1398h)
000B6E22 mov esp,ebp
000B6E24 pop ebp
000B6E25 ret
000B6E26 mov edi,edi
000B6E28 add eax,dword ptr [eax]
000B6E2A add byte ptr [eax],al
000B6E2C xor byte ptr [esi+0Bh],ch
000B6E2F add ah,cl
000B6E31 ?? ??
000B6E32 ?? ??
000B6E33 call dword ptr [ebx]
000B6E35 add byte ptr [eax],al
000B6E37 add byte ptr [eax+6Eh],bl
000B6E3A or eax,dword ptr [eax]
000B6E3C cmp bh,0FFh
000B6E3F inc dword ptr [eax+eax]
000B6E43 add byte ptr [esi+6Eh],dl
000B6E46 or eax,dword ptr [eax]
000B6E48 ins byte ptr es:[edi],dx
000B6E49 ?? ??
000B6E4A ?? ??
000B6E4B dec dword ptr [eax+eax]
000B6E4E add byte ptr [eax],al
000B6E50 push esp
000B6E51 outs dx,byte ptr [esi]
000B6E52 or eax,dword ptr [eax]
000B6E54 jns main+256h (0B6E56h)
000B6E56 ja main+258h (0B6E58h)
000B6E58 jae _main+2C2h (0B6EC2h)
000B6E5A add ah,cl