c语言画蜡烛(2006-6-16 11:03:00)

 新3.2版QQ空间代码 　 　

#include<stdlib.h>
#include<stdio.h>
#include<graphics.h>
int main()
{
  int gdriver=VGA, gmode=VGAHI, i,j,size,s2,s3,s4;
  initgraph(&gdriver, &gmode, "c:\\tc");
  setbkcolor(BLUE);
  cleardevice();
  setcolor(12);
  setfillstyle( 4,4) ;
  bar(180,360,200,320);   /*蜡烛*/
  sector(190,310,0,360,4,6);
  setcolor(6);
  getch();
  closegraph();
}

阅读全文(1965) | 评论:0 | 复制链接

迷宫程序1.10版(2006-6-16 10:54:00)

新3.2版QQ空间代码 　

  程序目的：
输入一个任意大小的迷宫，用栈求出一条走出迷宫的路径，并
显示在屏幕上。
程序实现：
可以实现载入迷宫和保存迷宫，附带文件中有4个测试迷宫路径的
文件test1~4.dd。请将这些文件拷贝到TC当前目录下，或者在载
入时写明完全路径。由于屏幕大小的限制，当用户自己输入迷宫
时一定要注意：迷宫大小是有限制的，不小于4*3,不大于30*20。
否则会出现错误信息。输入开始时全是墙，用上下左右键移动，
用Del键删除墙，形成通路，用Enter键添加墙。输入结束时可以
将迷宫保存下来，以dd为扩展名。输入完毕时用F9键来得到结果，
找到路径时，屏幕下方会出现Path found，否则出现Path not found。
程序经Turbo C 2.0编译调试成功。运行时不用添加任何运行库。
不可以在VC上编译。
下载DOS版和windows版的迷宫游戏全部代码
用户名：migong
----------------------------------------------------------------------------------
/*
MazePath Demo BY Turbo C 2.0
Copyright(c) RoverUnion. All right reserved.
Filename: Maze.c
Author Dongchengyu.
Ver 1.10
*/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <conio.h>
#include <dos.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define F9 0x43
#define Esc 0x1b
#define Del 0x53
#define Home 0x47
#define End 0x4f
#define Space 0x20
#define Up 0x48
#define Down 0x50
#define Left 0x4b
#define Right 0x4d
#define Enter 0x0d
#define F2 0x3c
#define F3 0x3d
#define STACK_INIT_SIZE 200
#define STACKINCREMENT 10
typedef int Boolean;
typedef int Status;
typedef struct {
int x;
int y;
} PosType;
typedef struct {
int ord;
PosType seat;
int di;
} SElemType;
typedef struct {
int td;
int foot;
int mark;
} MazeType;
typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
} Stack;
int Maze[20][30];
MazeType maze[20][30];
PosType StartPlace;
PosType EndPlace;
int count;
int m,n;
Boolean b_start=FALSE,b_end=FALSE;
void CreatMaze(void);
Status SaveMaze(char *filename);
Status LoadMaze(char *filename);
void Error(char *message);
Status InitStack(Stack *s);
Status DestroyStack(Stack *s);
Status ClearStack(Stack *s);
Boolean StackEmpty(Stack *s);
int StackLength(Stack *s);
Status Push(Stack *s,SElemType e);
SElemType Pop(Stack *s,SElemType e);
Status GetTop(Stack *s,SElemType *e);
Status StackTraverse(Stack *s,Status (* visit)(SElemType *se));
Boolean Pass(PosType curpos);
void MarkPrint(PosType seat);
void FootPrint(PosType curpos);
PosType NextPos(PosType seat,int di);
Status MazePath(PosType start,PosType end);
void CreatMaze(void)
/* Form the maze. */
{
void Error(char *message);
Status SaveMaze(char *filename);
Status LoadMaze(char *filename);
int i,j;
int x,y;
char c;
char savename[12],loadname[12];
Boolean flag=FALSE,load=FALSE;
clrscr();
printf("Menu:\n\n");
printf("1.Load Mazefile:(*.dd)\n\n");
printf("2.Input Maze:\n\n");
printf("Input your choice: ");
do
{
c=getch();
switch(c)
{
case ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''); break;
case ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''); break;
case Esc: sleep(1); exit(1);
default: break;
}
}
while(c!=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''&&c!=''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''') ;
if(c==''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''')
{
printf("\n\nLoadName: ");
scanf("%s",loadname);
if(LoadMaze(loadname))
{
sleep(1); load=TRUE;
}
else { gotoxy(1,9); printf("Load fail! "); }
}
if(!load)
{
printf("\nInput the maze''''''''''''''''''''''''''''''''s size:\n");
printf("\nInput Length :\n");
scanf("%d",&m);
printf("\nInput Width :\n");
scanf("%d",&n);
if(m<4||n<4) Error("Input");
if(m>30||n>20) Error("Maze too large");
for(i=0;i<30;i++)
for(j=0;j<20;j++)
Maze[j][i]=2;
StartPlace.x=0;
StartPlace.y=0;
EndPlace.x=0;
EndPlace.y=0;
clrscr();
printf("\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
printf(" #");
Maze[i-1][j-1]=0;
}
printf("\n");
}
}
gotoxy(65,5);
printf("''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''':Wall");
gotoxy(65,7);
printf("Start:Home");
gotoxy(65,9);
printf("End:End");
gotoxy(65,11);
printf("Delete Wall:Del");
gotoxy(65,13);
printf("Enter Wall:Enter");
gotoxy(65,15);
printf("Save Maze:F2");
gotoxy(65,17);
printf("Complete:F9");
gotoxy(65,19);
printf("Exit:Esc");
gotoxy(4,3);
x=4;y=3;
do
{
c=getch();
switch(c)
{
case Up: if(y>3) { y--; gotoxy(x,y); }
break;
case Down: if(y<n) { y++; gotoxy(x,y); }
break;
case Left: if(x>4) { x-=2; gotoxy(x,y); }
break;
case Right: if(x<2*m-2) { x+=2; gotoxy(x,y); }
break;
case Del: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) b_start=FALSE;
if(y-2==EndPlace.y&&x/2-1==EndPlace.x) b_end=FALSE;
putch('''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=1; gotoxy(x,y);
break;
case Enter: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) break;
if(y-2==EndPlace.y&&x/2-1==EndPlace.x) break;
putch(''''''''''''''''''''''''''''''''#''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=0; gotoxy(x,y);
break;
case Home: if(Maze[y-2][x/2-1]&&!b_start)
{
StartPlace.x=x/2-1;
StartPlace.y=y-2;
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
gotoxy(x,y);
b_start=TRUE;
}
break;
case End: if(Maze[y-2][x/2-1]&&!b_end)
{
EndPlace.x=x/2-1;
EndPlace.y=y-2;
putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
gotoxy(x,y);
b_end=TRUE;
}
break;
case Esc: gotoxy(2,22); printf("exit"); sleep(1); exit(1);
case F9: if(b_start&&b_end) flag=TRUE; break;
case F2: gotoxy(2,22);
printf("Savename:");
scanf("%s",savename);
gotoxy(2,22);
if(SaveMaze(savename)) printf("Save OK! ");
else printf("Save fail! ");
sleep(1);
gotoxy(2,22);
printf(" ");
gotoxy(x,y);
break;
default: break;
}
}
while(!flag);
for(i=0;i<30;i++)
for(j=0;j<20;j++)
{
maze[j][i].td=Maze[j][i];
maze[j][i].mark=0;
maze[j][i].foot=0;
}
}
Status LoadMaze(char *file)
/* The maze has been loaded. */
{
FILE *fp;
char *buffer;
char ch;
int i=0,j,k;
Boolean len=FALSE,wid=FALSE;
if((fp=fopen(file,"r"))==NULL)
return ERROR;
buffer=(char *)malloc(600*sizeof(char));
ch=fgetc(fp);
while(ch!=EOF)
{
buffer[i]=ch;
i++;
ch=fgetc(fp);
}
m=30;n=20;
for(i=0;i<600;i++)
{
j=i/30; k=i%30;
if(buffer[i]==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!len){ m=i; len=TRUE; }
if(k==0&&buffer[i]==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!wid){ n=j; wid=TRUE; }
switch(buffer[i])
{
case ''''''''''''''''''''''''''''''''0'''''''''''''''''''''''''''''''': Maze[j][k]=0; break;
case ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': Maze[j][k]=1; break;
case ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': Maze[j][k]=2; break;
case ''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''': Maze[j][k]=1;
StartPlace.x=k;
StartPlace.y=j;
b_start=TRUE;
break;
case ''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''': Maze[j][k]=1;
EndPlace.x=k;
EndPlace.y=j;
b_end=TRUE;
break;
default : break;
}
}
fclose(fp);
clrscr();
for(i=0;i<30;i++)
for(j=0;j<20;j++)
{
maze[j][i].td=Maze[j][i];
maze[j][i].foot=0;
maze[j][i].mark=0;
if(Maze[j][i]==0)
{
gotoxy(2*i+2,j+2);
putch(''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''');
}
}
gotoxy(2*StartPlace.x+2,StartPlace.y+2);
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
gotoxy(2*EndPlace.x+2,EndPlace.y+2);
putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
return OK;
}
Status SaveMaze(char *filename)
/* The maze has been saved. */
{
FILE *fp;
char *buffer;
int i,j,k;
fp=fopen(filename,"wb");
buffer=(char *)malloc(600*sizeof(char));
for(i=0;i<600;i++)
{
j=i/30; k=i%30;
switch(Maze[j][k])
{
case 0: buffer[i]=''''''''''''''''''''''''''''''''0''''''''''''''''''''''''''''''''; break;
case 1: buffer[i]=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''; break;
case 2: buffer[i]=''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''; break;
default : Error("Write"); break;
}
if(k==StartPlace.x&&j==StartPlace.y) buffer[i]=''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''';
if(k==EndPlace.x&&j==EndPlace.y) buffer[i]=''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''';
}
fwrite(buffer,600,1,fp);
free(buffer);
fclose(fp);
return OK;
}
void Error(char *message)
{
clrscr();
fprintf(stderr,"Error:%s\n",message);
exit(1);
} /* Error */

Status InitStack(Stack *s)
/* The stack s has been created and is initialized to be empty. */
{
s->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!s->base) Error("Overflow");
s->top=s->base;
s->stacksize=STACK_INIT_SIZE;
return OK;
} /* InitStack */
Status DestroyStack(Stack *s)
/* The stack s has been destroyed. */
{
s->top=NULL;
s->stacksize=0;
free(s->base);
s->base=NULL;
return OK;
} /* DestroyStack */
Status ClearStack(Stack *s)
/* The stack has been clear to be maximum. */
{
s->top=s->base;
s->stacksize=STACK_INIT_SIZE;
return OK;
} /* ClearStack */
Boolean StackEmpty(Stack *s)
/* Check if the stack s is empty. */
{
if(s->top==s->base) return TRUE;
else return FALSE;
} /* StackEmpty */
int StackLength(Stack *s)
/* Gain the length of the stack s. */
{
if(s->top>s->base) return (int)(s->top-s->base);
else return 0;
} /* StackLength */
Status Push(Stack *s,SElemType e)
/* The element e has been pushed into the stack s. */
{
if(s->top-s->base>=s->stacksize)
{
s->base=(SElemType *)realloc(s->base,
(s->stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!s->base) Error("Overflow");
s->top=s->base+s->stacksize;
s->stacksize+=STACKINCREMENT;
}
*s->top++=e;
return OK;
} /* Push */
SElemType Pop(Stack *s,SElemType e)
/* The element e has been removed from the stack s. */
{
if(s->top==s->base) Error("Pop");
e=*--s->top;
return e;
} /* Pop */
Status GetTop(Stack *s,SElemType *e)
/* The element e has got to the top of the stack s.*/
{
if(s->top==s->base) Error("GetTop");
*e=*(s->top-1);
return OK;
} /* GetTop */
/* Traverse the stack s using ''''''''''''''''''''''''''''''''visiting'''''''''''''''''''''''''''''''' function. */
/* Status StackTraverse(Stack *s,Status (* visit)(SElemType *se))
{
SElemType p;
int result;
if(s->top==s->base) return ERROR;
p=s->base;
while(!(p==s->top))
{
result=(*visit)(p);
p++;
}
return OK;
} */
Boolean Pass(PosType curpos)
/* Check if the current position can be passed. */
{
if(maze[curpos.x][curpos.y].td==1&&
maze[curpos.x][curpos.y].foot==0&&maze[curpos.x][curpos.y].mark==0)
return TRUE;
else return FALSE;
} /* Pass */
void MarkPrint(PosType seat)
/* Mark the position seat. */
{
maze[seat.x][seat.y].mark=-1;
/* Marking ''''''''''''''''''''''''''''''''-1'''''''''''''''''''''''''''''''' symbolize the current position cannot be put. */
} /* MarkPrint */
void FootPrint(PosType curpos)
/* The foot of the curpos of the maze has been set ''''''''''''''''''''''''''''''''true''''''''''''''''''''''''''''''''. */
{
maze[curpos.x][curpos.y].foot=1;
} /* FootPrint */
PosType NextPos(PosType seat,int di)
{
switch(di)
{
case 1: seat.y++; return seat; /* Eastward */
case 2: seat.x++; return seat; /* Southward */
case 3: seat.y--; return seat; /* Westward */
case 4: seat.x--; return seat; /* Northward */
default: seat.x=0; seat.y=0; return seat;
}
} /* NextPos */

/* The key to the program. */
/* Pre: The maze array & the startplace & the endplace.
Post: Find the one traverse of the maze and perform the mazepath.
Uses: The ADT stack class.
*/
Status MazePath(PosType start,PosType end)
{
PosType curpos;
int curstep;
SElemType e;
Stack *s,stack;
stack.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!stack.base) Error("Overflow");
stack.top=stack.base;
stack.stacksize=STACK_INIT_SIZE;
s=&stack;
curpos=start;
curstep=1;
do
{
if(Pass(curpos))
{
FootPrint(curpos);
e.ord=curstep; e.seat=curpos; e.di=1;
gotoxy((curpos.y+1)*2,curpos.x+2);
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
delay(8000); /* pospone time. */
Push(s,e);
if(curpos.x==end.x&&curpos.y==end.y) /* Proceed recursively. */
{
DestroyStack(s);
return TRUE;
}
curpos=NextPos(curpos,1); /* Try next position. */
curstep++;
}
else
{
if(!StackEmpty(s))
{
e=Pop(s,e); /* Removed e from s. */
while(e.di==4&&!StackEmpty(s)) /* Four directions have been checked
and s is not empty. */
{
MarkPrint(e.seat);
gotoxy((e.seat.y+1)*2,e.seat.x+2);
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
delay(8000); /* Pospone time. */
gotoxy((e.seat.y+1)*2,e.seat.x+2);
putch('''''''''''''''''''''''''''''''' '''''''''''''''''''''''''''''''');
e=Pop(s,e); /* Remove e from s. */
curstep--;
}
if(e.di<4) /* The current position hasnot been checked. */
{
e.di++;
Push(s,e); /* Insert e into s. */
curpos=NextPos(e.seat,e.di); /* Try next position. */
}
}
}
}
while(!StackEmpty(s));
DestroyStack(s);
return FALSE;
} /* MazePath */
void main()
{
PosType start,end;
CreatMaze();
start.x=StartPlace.y;
start.y=StartPlace.x;
end.x=EndPlace.y;
end.y=EndPlace.x;
if(MazePath(start,end))
{
gotoxy(2,22);
printf("Path found\n");
}
else
{
gotoxy(2,22);
printf("Path not found\n");
}
getch();
clrscr();
}

阅读全文(1276) | 评论:1 | 复制链接

关于汉诺塔问题的最终解决(2006-6-16 10:46:00)

    问题的提出:约19世纪末，在欧州的商店中出售一种智力玩具，在一块铜板上有三根杆，最左边的杆上自上而下、由小到大顺序串着由64个圆盘构成的塔。目的是将最左边杆上的盘全部移到右边的杆上，条件是一次只能移动一个盘，且不允许大盘放在小盘的上面。
*问题分析与算法设计
这是一个著名的问题，几乎所有的教材上都有这个问题。由于条件是一次只能移动一个盘，且不允许大盘放在小盘上面，所以64个盘的移动次数是：
18，446，744，073，709，551，615
这是一个天文数字，若每一微秒可能计算(并不输出)一次移动，那么也需要几乎一百万年。我们仅能找出问题的解决方法并解决较小N值时的汉诺塔，但很难用计算机解决64层的汉诺塔。
分析问题，找出移动盘子的正确算法。
首先考虑a杆下面的盘子而非杆上最上面的盘子，于是任务变成了：
*将上面的63个盘子移到b杆上；
*将a杆上剩下的盘子移到c杆上；
*将b杆上的全部盘子移到c杆上。
将这个过程继续下去，就是要先完成移动63个盘子、62个盘子、61个盘子....的工作。
为了更清楚地描述算法，可以定义一个函数movedisc(n,a,b,c)。该函数的功能是：将N个盘子从A杆上借助C杆移动到B杆上。这样移动N个盘子的工作就可以按照以下过程进行：
1) movedisc(n-1,a,c,b);
2) 将一个盘子从a移动到b上；
3) movedisc(n-1,c,b,a)；
重复以上过程，直到将全部的盘子移动到位时为止。
*程序与程序注释
#include<stdio.h>
void movedisc(unsigned n,char fromneedle,char toneedle,char usingneedle);
int i=0;
void main()
{
unsigned n;
printf("please enter the number of disc:");
scanf("%d",&n); /*输入N值*/
printf("\tneedle:\ta\t b\t c\n");
movedisc(n,'a','c','b'); /*从A上借助B将N个盘子移动到C上*/
printf("\t Total: %d\n",i);
}
void movedisc(unsigned n,char fromneedle,char toneedle,char usingneedle)
{
if(n>0)
{
movedisc(n-1,fromneedle,usingneedle,toneedle);
/*从fromneedle上借助toneedle将N-1个盘子移动到usingneedle上*/
++i;
switch(fromneedle) /*将fromneedle 上的一个盘子移到toneedle上*/
{
case 'a': switch(toneedle)
{
case 'b': printf("\t[%d]:\t%2d.........>%2d\n",i,n,n);
break;
case 'c': printf("\t[%d]:\t%2d...............>%2d\n",i,n,n);
break;
}
break;
case 'b': switch(toneedle)
{
case 'a': printf("\t[%d]:\t%2d<...............>%2d\n",i,n,n);
break;
case 'c': printf("\t[%d]:\t %2d........>%2d\n",i,n,n);
break;
}
break;
case 'c': switch(toneedle)
{
case 'a': printf("\t[%d]:\t%2d<............%2d\n",i,n,n);
break;
case 'b': printf("\t[%d]:\t%2d<........%2d\n",i,n,n);
break;
}
break;
}
movedisc(n-1,usingneedle,toneedle,fromneedle);
/*从usingneedle上借助fromneedle将N-1个盘子移动到toneedle上*/
}

阅读全文(1431) | 评论:0 | 复制链接

设计彩色框的C源程序(2006-6-16 10:43:00)

 /*
*
* Short driver module
*
*/

main()
{
clrscr();
box(1,1,23,79);
box(2,2,21,77);
box(3,3,19,75);
box(4,4,17,73);
box(5,5,15,71);
box(6,6,13,69);
box(7,7,11,67);
box(8,8,9,65);
box(9,9,7,63);
box(10,10,5,61);
box(11,11,3,59);
box(12,12,1,57);
poscur(24,1);
}

/************************************************************
* BOX *
*----------------------------------------------------------*
* Written by: Jeff Ebert 7/01/87 *
* Modified by: xxxxxxxxxx *
* *
* Please modify me! *
* Possible Enhancements include but are not limited to: *
* 1) Variable box character styles [1 line or 2] *
* 2) Error checking *
* 3) Color options *
* *
* *
* This function builds a simple double frame for a menu. *
* The function is passed the parameters for the upper *
* left corner row, upper left corner column the height *
* of the frame and the width. *
* *
************************************************************/
#include

#define ULCOR 201
#define URCOR 187
#define LLCOR 200
#define LRCOR 188
#define VBAR 186
#define HBAR 205
#define ESC 27

box(row, col, hgt, wdth)
int row, col, hgt, wdth;

{
int x, y;

poscur(row,col);
putchar(ULCOR);
for(x = col + 1; x <=(col + wdth -1); x++)
putchar(HBAR);
putchar(URCOR);

for(x = row + 1; x <=(row + hgt - 1); x++){
poscur(x,col);
putchar(VBAR);
poscur(x,col+wdth);
putchar(VBAR);
}
poscur(x,col);
putchar(LLCOR);
for(x= col + 1; x <=(col + wdth -1); x++)
putchar(HBAR);
putchar(LRCOR);
}

/********************************************************
* POSCUR *
*------------------------------------------------------*
* This function positions the cursor at the specified *
* x,y coordinate. It uses the ANSI standard ESCAPE *
* sequence to produce the desired effect. Its not the *
* fastest way to position the cursor, but perhaps the *
* most portable. *
* *
********************************************************/
poscur(xcor,ycor)
int xcor,ycor;
{
printf("%c[%d;%dH",ESC,xcor,ycor);
}

/********************************************************
* CLRSCR *
*------------------------------------------------------*
* This function positions the cursor at the specified *
* x,y coordinate. It uses the ANSI standard ESCAPE *
* sequence to produce the desired effect. Its not the *
* fastest way to position the cursor, but perhaps the *
* most portable. *
* *
********************************************************/
clrscr()
{
printf("%c[2J",ESC);
}

阅读全文(1306) | 评论:0 | 复制链接

c语言(2006-6-16 10:42:00)

运动与静止同时实现在这里我用圆实现运动、方块实现静止
代码如下：
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int gdriver = DETECT, gmode;
void *ball;
int x, y,maxx;
unsigned int size;
initgraph(&gdriver, &gmode, "");
maxx = getmaxx();
x = 0;
y = 200;
rectangle(x,y+11,x+20,y+31);
circle(x+10,y,10);
size = imagesize(x, y-10, x+20, y+10);
ball = malloc(size);
setfillstyle(SOLID_FILL, BLACK);
while (!kbhit())
{
cleardevice();
x += 10;
if (x >= maxx)
x = 0;
rectangle(0,211,20,231);
circle(x+10,y,10);
delay(100);
}
free(ball);
closegraph();
return 0;
}

再来说一下赛车游戏
我上面给大家可以说是从第一步：制作简单的场景和玩家的赛车
到第二步：进一步完善场景，
大家可能已经有所领会
下面我们就把它做成一个简单的游戏
代码如下：
#include <math.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <graphics.h>
static int c=1;
static int e=0;
static int u=0;
static int v=0;
static int x=1;
static int y=0;
static int j=-21;
static int i;
static int b;
void begin(void)
{
int xmax, ymax;
int startx,starty,endx,endy;
setbkcolor(WHITE);
xmax = getmaxx();
ymax = getmaxy();
endx=20;endy=20;
startx=10;starty=10;
setcolor(RED);
settextstyle(1,HORIZ_DIR,4);
outtextxy(10,240,"Bus Bus Bus");
outtextxy(300,300,"Made by PU BIN.");
setlinestyle(SOLID_LINE,0,3);
setwritemode(XOR_PUT);
setcolor(GREEN);
while(startx<xmax&&starty<ymax)
{
rectangle(startx,starty,endx,endy);
delay(4);
rectangle(startx,starty,endx,endy);
startx+=2;
starty+=startx*startx/2000;
endx=startx+10;
endy=starty+10;
sound(startx*10);
delay(10);
nosound();
}
getch();
cleardevice();
}

void road(void)
{
int h;
for(h=0;h<4;h++)
line(150+h*100,0,150+h*100,472);
for(h=0;h<3;h++)
{
setlinestyle(3,0,1);
line(200+h*100,0,200+h*100,472);
settextstyle(1,HORIZ_DIR,3);
}
settextstyle(1,HORIZ_DIR,4);
setcolor(RED);
outtextxy(40,40,"PASS");
outtextxy(40,80,"1");
setcolor(10);
setlinestyle(SOLID_LINE,0,3);
rectangle(150,400,450,460);
outtextxy(160,410,"Ready,Begin!");
}
void math(void)
{
settextstyle(1,HORIZ_DIR,4);
setcolor(RED);
if(x==2)
{
outtextxy(40,80,"1");
outtextxy(40,80,"2");
}
else if(x==3)
{
outtextxy(40,80,"2");
outtextxy(40,80,"3");
}
else if(x==4)
{
outtextxy(40,80,"3");
outtextxy(40,80,"4");
}else if(x==5){
outtextxy(40,80,"4");
outtextxy(40,80,"5");
}else if(x==6){
outtextxy(40,80,"5");
outtextxy(40,80,"6");
}else if(x==7){
outtextxy(40,80,"6");
outtextxy(40,80,"7");
}else if(x==8){
outtextxy(40,80,"7");
outtextxy(40,80,"8");
}else if(x==9){
outtextxy(40,80,"8");
outtextxy(40,80,"9");
}else if(x==10){
outtextxy(40,80,"9");
outtextxy(40,80,"10");
}else if(x==11){
outtextxy(40,80,"10");
outtextxy(40,80,"11");
}else if(x==12){
outtextxy(40,80,"11");
outtextxy(40,80,"12");
}else if(x==13){
outtextxy(40,80,"12");
outtextxy(40,80,"13");
}else if(x==14){
outtextxy(40,80,"13");
outtextxy(40,80,"14");
}else if(x==15){
outtextxy(40,80,"14");
outtextxy(40,80,"15");
}else if(x==16){
outtextxy(40,80,"15");
outtextxy(40,80,"16");
}else if(x==17){
outtextxy(40,80,"16");
outtextxy(40,80,"17");
}else if(x==18){
outtextxy(40,80,"17");
outtextxy(40,80,"18");
}else if(x==19){
outtextxy(40,80,"18");
outtextxy(40,80,"19");
}else if(x==20){
outtextxy(40,80,"19");
outtextxy(40,80,"20");
}else if(x==21){
outtextxy(40,80,"20");
outtextxy(40,80,"21");
}else if(x==22){
outtextxy(40,80,"21");
outtextxy(40,80,"22");
}else if(x==23){
outtextxy(40,80,"22");
outtextxy(40,80,"23");
}else if(x==24){
outtextxy(40,80,"23");
outtextxy(40,80,"24");
}else if(x==25){
outtextxy(40,80,"24");
outtextxy(40,80,"25");
y=1; v=1;
}
}
void bus2(void)
{
setcolor(BLUE);
rectangle(180+c*100,350,220+c*100,390);
rectangle(170+c*100,340,230+c*100,350);
rectangle(190+c*100,320,210+c*100,340);
rectangle(170+c*100,390,230+c*100,400);
setcolor(5);
line(190+c*100,350,190+c*100,390);
line(200+c*100,350,200+c*100,390);
line(210+c*100,350,210+c*100,390);
line(200+c*100,300,200+c*100,320);
line(185+c*100,300,215+c*100,300);
if((b==0x4b00)&&(c>0))
c--;
else if((b==0x4d00)&&(c<2))
c++;
else if((b==0x5000)&&(c<2))
sleep(1);
setcolor(BLUE);
rectangle(180+c*100,350,220+c*100,390);
rectangle(170+c*100,340,230+c*100,350);
rectangle(190+c*100,320,210+c*100,340);
rectangle(170+c*100,390,230+c*100,400);
setcolor(5);
line(190+c*100,350,190+c*100,390);
line(200+c*100,350,200+c*100,390);
line(210+c*100,350,210+c*100,390);
line(200+c*100,300,200+c*100,320);
line(185+c*100,300,215+c*100,300);

setcolor(BLUE);
}
void light(void)
{
rectangle(535,65,565,155);
floodfill(545,100,BLUE);
setfillstyle(1,RED);
fillellipse(550,80,10,10);
sound(650);
delay(300);
nosound();
delay(100);
setfillstyle(1,YELLOW);
fillellipse(550,110,10,10);
sound(650);
delay(300);
nosound();
delay(100);
setfillstyle(1,GREEN);
fillellipse(550,140,10,10);
sound(650);
delay(300);
nosound();
delay(100);
setcolor(10);
setlinestyle(SOLID_LINE,0,3);
rectangle(150,400,450,460);
outtextxy(160,410,"Ready,Begin!");
}

void brock(void)
{
if((c==i)&&(j>4)&&(j<38))
e=1;
}

void tree(void)
{
int w;
int poly[14];
setcolor(10);
for (w=-3;w<3;w=w+2)
{
line(85,-25+u*15+w*157,85,35+u*15+w*157);
line(95,-25+u*15+w*157,95,35+u*15+w*157);
line(105,-25+u*15+w*157,105,35+u*15+w*157);
line(115,-25+u*15+w*157,115,35+u*15+w*157);
line(75,-9+u*15+w*157,75,19+u*15+w*157);
line(125,-9+u*15+w*157,125,19+u*15+w*157);
}
for (w=-2;w<3;w=w+2)
{
poly[0] = 530;
poly[1] = u*15+w*157;
poly[2] =515;
poly[3] = 25+u*15+w*157;
poly[4] =485;
poly[5] =25+u*15+w*157 ;
poly[6] =470;
poly[7] =u*15+w*157 ;
poly[8] =485;
poly[9] =-25+u*15+w*157;
poly[10] =515;
poly[11] =-25+u*15+w*157 ;
poly[12] = poly[0];
poly[13] = poly[1];
drawpoly(7,poly);
}
}


void bus1(void)
{
randomize();
i=random(3);
setlinestyle(SOLID_LINE,0,3);
do
{
do
{
if((x!=7)&&(x!=16)&&(x!=23))
setcolor(x);
else
setcolor(2);
rectangle(170+i*100,j*10,230+i*100,60+j*10);
rectangle(160+i*100,70+j*10,240+i*100,260+j*10);
line(180+i*100,70+j*10,180+i*100,260+j*10);
line(200+i*100,70+j*10,200+i*100,260+j*10);
line(220+i*100,70+j*10,220+i*100,260+j*10);
tree();
sound(j*10);
delay(10);
nosound();
if((x!=7)&&(x!=16)&&(x!=23))
setcolor(x);
else
setcolor(2);
rectangle(170+i*100,j*10,230+i*100,60+j*10);
rectangle(160+i*100,70+j*10,240+i*100,260+j*10);
line(180+i*100,70+j*10,180+i*100,260+j*10);
line(200+i*100,70+j*10,200+i*100,260+j*10);
line(220+i*100,70+j*10,220+i*100,260+j*10);
tree();
u++;
j++;
brock();
if(e==1)
{
j=48;
y=1;
u=63;
v=0;
}
}while((bioskey(1)==0)&&(j<=47)&&(u<=62));
if((j<=47)&&(u<=62))
/* function 0 returns the key that is waiting */
{
b= bioskey(0);
bus2();
}
else if(u<=62)
{
j=-21;
randomize();
i=rand()%3;
x++;
math();
setcolor(x);
}
else
u=0;

}while(y!=1);
}
void end()
{
if (v==1)
{
for(j=0;j<94;j++)
{
rectangle(150,j*5,450,60+j*5);
settextstyle(1,HORIZ_DIR,4);
outtextxy(160,10+j*5,"STOP! You win!");
sound(500+j*10);
delay(2);
nosound();
setlinestyle(SOLID_LINE,0,3);
rectangle(150,j*5,450,60+j*5);
outtextxy(160,10+j*5,"STOP! You win!");
}
closegraph();
printf("\n\nyou win!");
}
else if(v==0 )
{
closegraph();
printf("\n\nYou lose.");
}
printf("\n\n\nCome back again.\n\n Made by YOU LIAO working house. pubingk@citiz.net");
getch();
getch();
}
void car()
{
setcolor(BLUE);
setlinestyle(SOLID_LINE,0,3);
rectangle(280,350,320,390);
rectangle(270,340,330,350);
rectangle(290,320,310,340);
rectangle(270,390,330,400);
setcolor(5);
line(290,350,290,390);
line(300,300,300,320);
line(300,350,300,390);
line(310,350,310,390);
line(285,300,315,300);
setcolor(BLUE);
}

void main(void)
{
int gdriver = DETECT , gmode;

initgraph(&gdriver, &gmode, "");
begin();
setbkcolor(7);
setcolor(WHITE);
setwritemode(XOR_PUT);
road();
car();
light();
bus1();
end();
}

阅读全文(1300) | 评论:0 | 复制链接

c语言(九格游戏100多行)(2006-6-16 10:39:00)

/*很多人都觉得编游戏很高深...其实不然...以下是我初学C时写个一个九格游戏涉及的知识只有函数,各种流程控制和从老师那里问来的几个非常有用的函数. 当然,当时我连一点图形的知识都没有. 我只想说明一个问题:不要觉得你C语言学得不够多,只是,你没有充分利用你所学到的*/

#include
#include /*使用其中的int random(int a):
产生一个在0到a-1之间的整数
和 randomize():复位随机发生器*/
#include /*使用其中的gotoxy(int x,int y):
把光标移动到屏幕的x（1~80）,y（1~25/50）处*/
/*和clrscr():清屏*/
int num[]={1,2,3,4,5,6,7,8,0}; /*方块的数字*/

main(){
char key=0; /*键盘码*/
int pos; /*九格中，空格的位置*/
clrscr(); /*清屏*/
randomize(); /*初始化随机发生器*/
newGame();
for(;;){
key=getch(); /*获得键盘输入*/
if(key==0) continue;
pos=GetTheNull(); /*得到空格*/
switch(key){ /*测试按键*/
case 72: /*按下*/
if(pos<=5) change(pos,pos+3);
break;
case 80: /*按上*/
if(pos>=3) change(pos,pos-3);
break;
case 77: /*按左*/
if(pos%3!=0) change(pos,pos-1);
break;
case 75: /*按右*/
if(pos%3!=2) change(pos,pos+1);
break;
case 110: /*按下‘n’新建游戏*/
newGame();
}
update(); /*更新*/
if(isSuccess()){ /*看是否游戏成功*/
gotoxy(26,10); /*成功了，输出一个写有Well done!的外框*/
printf("\332\304\304\304\304\304\304\304\304\304\304\304\304\267");
gotoxy(26,11);
printf("\263 \272");
gotoxy(26,12);
printf("\263 Well Done! \272");
gotoxy(26,13);
printf("\263 \272");
gotoxy(26,14);
printf("\324\315\315\315\315\315\315\315\315\315\315\315\315\274\n");
getch();
newGame(); /*新游戏*/
}
if(key==27) break; /*退出*/
}
clrscr(); /*清屏*/
}

newGame(){ /*新建游戏,实际上就是把有数字的八个方格打散,
这种效果的实现就是随机的两两交换,而怎么不与空的那个交换呢?
这涉及有没有解的问题
不管怎么样,九格游戏最后的结果只有两个:
123 | 123
456 | 456
78 | 87 (证明从略)
而要两两交换而始终有解的话,(从原序列开始)必须:相邻交换的次数为偶
但我们用一种更有效的方法:
每一个总与其下第二个交换.
第7,8个与0,1交换,只要交换次数多,仍可获得相同的效果.
而这些的前提是其中的0不能与其第奇数个作奇数次交换.
为了省事,不处理0...
其中产道理,请自己思考
*/
int i,a,b;
for(i=0;i<8;i++) num[i]=i+1;
num[8]=0; /*将数组复原*/
for(i=0;i<300;i++){
a=random(8); /*产生随机数*/
b=(a+2)%8; /*得到下第二个的数组下标*/
change(a,b); /*交换*/
}
update();
}

update(){ /*在屏幕上画出整个九格图像,关于定位的问题自己分析*/
int i,j;
for(i=0;i<=2;i++){
gotoxy(24,8+i*3);
for(j=0;j<=2;j++){
if (num[j+i*3]!=0)
printf("\332\304\304\304\304\267");
else
printf(" ");
}
gotoxy(24,9+i*3);
for(j=0;j<=2;j++){
if (num[j+i*3]!=0)
printf("\263 %d \272",num[j+i*3]);
else
printf(" ");
}
gotoxy(24,10+i*3);
for(j=0;j<=2;j++){
if (num[j+i*3]!=0)
printf("\324\315\315\315\315\274");
else
printf(" ");
}
printf("\n");
}

}

int isSuccess(){ /*判断是否游戏*/
int i,ret=1;
for(i=0;i<8;i++)
ret=ret&&(num[i]==(i+1));
return ret;
}

int GetTheNull(){ /*获得空格的位置*/
int i;
for(i=0;i<=8;i++){
if (num[i]==0)
return i;

}
}

change(int a,int b){ /*交换num[a],num[b]*/
int temp;
temp=num[a];
num[a]=num[b];
num[b]=temp;
}

/*游戏,就这么简单!*/

阅读全文(1296) | 评论:1 | 复制链接

c语言(可控制的笑脸)(2006-6-16 10:34:00)

纯真童趣的《泡泡堂》,还有武林情仇,笑傲江湖的《剑侠情缘online》.它是e时代常谈的话题,是交互式娱乐的主力军,是一种高层次的综合艺术,更是一个民族的文化,世界观的全新传播方式.作为游戏玩家的我们,是不是想设计一个属于自己的游戏呢?爱玩是人的天性,而C语言是我们计算机专业都要学习的一门基础学科.一般来说,是比较枯燥的.那么,我们能不能通过编一些小游戏来提高它的趣味性呢?这样学习程序设计,就不会是一件艰苦,枯燥的事,它变得象电脑游戏一样充满好奇,富有乐趣.这正是我发贴的目的.

一、 总是从Hello,world开始

学习编程的第一个程序,一般就是打印一个亲切的词语——"Hello,来 vcok.com 学c语言!".让我们来看看这个最简单的C程序:

#incolude <stdio.h> /*把输入输出函数的头文件包含进来*/

int main()

{

printf("Hello,来 vcok.com 学c语言!");/*在屏幕上输出字符串"Hello,来 vcok.com 学c语言!"*/

return 0;/*退出main函数,并返回0*/

}

下面我们发现几个值得改进的地方,

1,程序的运行结果一闪而过.
2,每执行这个程序一次都能看见上次运行留下的字符.
3,我们还希望屏幕输出一个笑脸来欢迎我们.
(大家不要小看了这个笑脸曾经有人发贴专门问呢)让我们来改进一下这个程序吧!

1,在return语句的前面加一句:getch ();,表示按任意键结束.
2,在printf语句前用clrscr函数清屏,要使用这个函数和getch函数,需要在程序开头再包含头文件conio.h.
3,ASCII码也有许多非常好玩的字符,比如ASCII码值为2的就是一个笑脸,我们可以用printf("%c", 2)来输出一个笑脸.

现在我们把Hello,world程序改成一个更好看的Hello,world了.下面让我们开始做游戏吧!

二、 心动的开始,一个运动中的笑脸

大家小时侯喜欢看动画片吗?哈哈,我猜你们都喜欢吧!下面就让我们来做一个小动画吧.在屏幕上显示一个运动的小笑脸,而且当它到达屏幕的边缘时会自动弹回来.

先在程序定义一个在屏幕中运动的点的结构:

struct move_point

{

int x, y;/*该点的位置,包括x坐标和y坐标*/

int xv, yv;/*该点在x轴,y轴的速度*/

};

运动的原理是,先擦去物体先前的轨迹,让物体按其速度移动一段距离,再画出该物体.让我们看到以下代码:

gotoxy(man.x, man.y);/*把光标移到指定的坐标*/

printf(" ");/*输出一个空格,把先前的字符擦去*/

然后我们让物体按其速度运动:

man.x += man.xv;/*水平方向按x轴的速度运动*/

man.y += man.yv;/*垂直方向按y轴的速度运动*/

运动后还要判断物体是否出界,如果出了界,就令物体反弹,即让它下一刻的速度等于现在的速度的相反数.最后打印出这个笑脸:

gotoxy(man.x, man.y);

printf("%c\b", 2); /*输出ASCII码值为2的"笑脸"字符*/

怎么样?是不是很有趣呢?不过这个笑脸一直是自己运动,能不能让我们来控制它运动呢?答案是肯定的,让我们继续往下学吧!

三、 交互的实现——让我们来控制笑脸运动

这个程序的主要功能是接受按键,如果接收的是方向键,就让笑脸顺着方向移动,如果接收的是ESC键就退出程序,其他按键则忽略处理.
接受按键我们用以下两条语句:

while (bioskey(1) == 0);/*等待按键*/

key = bioskey(0);/*把接收的按键的键盘码赋给变量key*/

然后用switch语句来判断按键以及执行相关操作,如下:

switch (key) /*对变量key的值进行判断*/

{

case UP: /*如果按的是向上键*/

… break; /*让物体向上运动,并退出switch*/

case DOWN: /*如果按的是向下键*/

… break; /*让物体向下运动,并退出switch*/

case LEFT: /*向左键*/

… break;;/*向左运动*/

case RIGHT: /*向右键*/

… break;/*向右运动*/
default:

break;/*其他按键则忽略处理*/

}

怎么样,是不是有了玩游戏的感觉了?不过这个程序没有什么目的,也没有什么判断胜负的条件.下面我们就利用这个能控制它移动的笑脸来做一个更有趣的游戏吧!

以下为完整的源程序《from vcok.com 》

#include <conio.h>
#include <stdio.h>
#include <bios.h>
#define UP 18432 /*向上的键盘输入标志*/
#define DOWN 20480 /*向下的键盘输入标志*/
#define LEFT 19200 /*向左的键盘输入标志*/
#define RIGHT 19712 /*向右的键盘输入标志*/
main()
{
struct move_point
{
int x, y;
int xv, yv;
}man;
int key;
man.x=20;
man.y=20;
man.xv=1;
man.yv=1;
while(bioskey(1)==0)
{
key=bioskey(0);
clrscr();
switch(key)
{
case UP:
{
man.y-=man.yv;
if(man.y==0) man.y=0;
if(man.x==300) man.x=300;
if(man.y==0) man.y=0;
if(man.y==300) man.y=300;
/*以上四句作为控制边界，在调试时无法正常处理*/
gotoxy(man.x, man.y);
printf("%c\b",2);break;
}
case DOWN:
{
man.y+=man.yv;
if(man.y==0) man.y=0;
if(man.x==300) man.x=300;
if(man.y==0) man.y=0;
if(man.y==300) man.y=300;
/*以上四句作为控制边界，在调试时无法正常处理*/
gotoxy(man.x, man.y);
printf("%c\b",2);break;
}
case LEFT:
{
man.x-=man.xv;
if(man.y==0) man.y=0;
if(man.x==300) man.x=300;
if(man.y==0) man.y=0;
if(man.y==300) man.y=300;
/*以上四句作为控制边界，在调试时无法正常处理*/
gotoxy(man.x, man.y);
printf("%c\b", 2);break;
}
case RIGHT:
{
man.x+=man.xv;
if(man.y==0) man.y=0;
if(man.x==300) man.x=300;
if(man.y==0) man.y=0;
if(man.y==300) man.y=300;
/*以上四句作为控制边界，在调试时无法正常处理*/
gotoxy(man.x, man.y);
printf("%c\b", 2);break;
}
default: break;
}
}
}

阅读全文(1720) | 评论:0 | 复制链接

用C语言写的鼠标驱动程序(2006-6-16 10:30:00)

#include <dos.h>
#include <bios.h>
#include <malloc.h>
#include <stdlib.h>
#include <stdio.h>
#include "graphics.h"

#define R 15 /*鼠标的形态*/

void initgr(void) /* BGI初始化 */
{
int gd = DETECT, gm = 0; /* 和gd = VGA,gm = VGAHI是同样效果 */
registerbgidriver(EGAVGA_driver);/* 注册BGI驱动后可以不需要.BGI文件的支持运行 */
initgraph(&gd, &gm, "");
}
/*获取鼠标位置和按键,key=1是左键,key=2是右键*/
void getmouse(int *x,int *y,int *key)
{
union REGS inregs,outregs;
inregs.x.ax=3; /*获取鼠标位置和状态也可以用3*/
int86(0x33,&inregs,&outregs); /*中断调用*/
*x=outregs.x.cx; /*cx寄存器中存的是横坐标*/
*y=outregs.x.dx; /*dx寄存器中存的是列坐标*/
*key=outregs.x.bx; /*bx寄存器是按键状态*/
}
void visbilemouse()
{
union REGS inregs,outregs;
inregs.x.ax=0x01; /*显示鼠标*/
int86(0x33,&inregs,&outregs);
}
/*按键后,返回当前鼠标的x,y和按键状态,知道按键后才返回*/
void mouse(int *x,int *y,int *z) /*画鼠标是利用将一个空矩形存入内存中,然后再在该空矩形中画鼠标形状*/
{
int a=0,b=0,c=0,a_old=0,b_old=0; /*a,b的值可以随便*/
int *ball; /*定义指向内存的存储图形的指针*/
ball=malloc(imagesize(a,b,a+R,b+R)); /*返回矩形的大小*/
getimage(a,b,a+R,b+R,ball); /*第一次将图形(一个空矩形)存入到内存中,内存中存入的是一个空矩形*/
/*setcolor(GREEN);
setlinestyle(0,0,1);
line(a,b,a+R,b+R/2);
line(a,b,a+R/2,b+R);
line(a+R,b+R/2,a+R/2,b+R);
line(a+R*3/4,b+R*3/4,a+R,b+R); 同样可要可不要,画鼠标*/
while(c==0) /*直到按键后才返回,不按键一直循环*/
{
getmouse(&a,&b,&c); /*a,为横坐标,b,为列坐标,c为按键状态*/
if(a<0) a=0; /*保证鼠标左边不出界*/
if(b<0) b=0; /*保证上面不出界*/
if(a>getmaxx()-R) a=getmaxx()-R; /*保证右边不出界*/
if(b>getmaxy()-R) b=getmaxy()-R; /*保证下边不出界*/
if(a!=a_old || b!=b_old) /*当鼠标移动时*/
{
putimage(a_old,b_old,ball,0); /*在a_old,b_old输出图形,用来擦掉原来的鼠标*/
getimage(a,b,a+R,b+R,ball); /*这条语句是将目前鼠标所在位置的图形存贮到ball里面试着看着有无这条语句的区别*/
/*不需要在获取了*/
setcolor(GREEN);
setlinestyle(0,0,1);
line(a,b,a+R,b+R/2);
line(a,b,a+R/2,b+R);
line(a+R,b+R/2,a+R/2,b+R);
line(a+R*3/4,b+R*3/4,a+R,b+R); /*画鼠标*/
}
a_old=a;b_old=b;
} /*while()结束*/
*x=a;*y=b;*z=c; /*返回按键后鼠标的位置*/
putimage(a,b,ball,0); /*将鼠标擦掉,因为存在ball里面的是一个背景为缺省状态下的一个空矩形*/
free(ball);
}
/*主要思想是通过getimage,putimage,imagesize图形的存贮一个当前的图形来擦拭掉以前的鼠标图形,也可以用清屏部分屏幕来实现*/
void main()
{
int x,y,z;
initgr();
visbilemouse();
do
{
setcolor(WHITE);
rectangle(175,8,220,25);
outtextxy(180,10,"exit");
mouse(&x,&y,&z);
if(z==1)
{
setlinestyle(0,0,1);
setcolor(12);
circle(x,y,1);
}
if(z==2)
{setfillstyle(1,BLACK);
bar(0,0,getmaxx(),getmaxy());
}
}while(x<175 || x>220 || y<8 || y>25);
closegraph();
}

阅读全文(1476) | 评论:0 | 复制链接

附录一:Turbo C(V2.0)编译错误信息(2006-6-16 10:26:00)

编译错误信息

　　说明：Turbo C 的源程序错误分为三种类型：致命错误、一般错误和警告。其中，致命错误通常是内部编译出错；一般错误指程序的语法错误、磁盘或内存存取错误或命令行错误等；警告则只是指出一些得怀疑的情况，它并不防止编译的进行。

　　下面按字母顺序A～Z分别列出致命错误及一般错误信息，英汉对照及处理方法：

(一)、致命错误英汉对照及处理方法：

阅读全文(1110) | 评论:0 | 复制链接

附录二:Turbo C(V2.0)使用指南(2006-6-16 10:24:00)

（本文的许多命令或方法同样适用于TC3）

　　在开始看本文以前，我先说明一下C语言的安装和使用中最应该注意的地方：许多网友在下载Turbo C 2.0和Turbo C++ 3.0后，向我问得最多的是在使用过程中碰到如下问题：

1）出现找不到 stdio.h conio.h等include文件；

2）出现cos.obj无法连接之类的错误
　　这些问题是由于没有设置好路径引起的，目前下载的TC2，TC3按安装分类大概有两种版本：一是通过install安装，这类应该已经设置好了路径；二是直接解压后建立TC.EXE的快捷方式，在WINDOWS下双击即可运行（DOS下直接运行TC.EXE）,目前国内大多为这种,因此下载使用前请注意
路径设置：
设置方法为：
OPTION->DIRECTORIES:
INCLUDE: [TC2/3所在目录]/include
LIB: [TC2/3所在目录]/lib
output输出目录请自己设置一个工作目录，以免混在一起。最后还提醒一点：FILES中的Change dir(改变当前目录）中应设置为当前程序所在目录。

一、 Turbo C 2.0的安装和启动

　　Turbo C 2.0的安装非常简单, 只要将1#盘插入A驱动器中, 在DOS的"A>" 下键入: A>INSTALL 即可, 此时屏幕上显示三种选择:
1. 在硬盘上创造一个新目录来安装整个Turbo C 2.0系统。

2. 对Turbo C 1.5更新版本。这样的安装将保留原来对选择项、颜色和编辑功能键的设置。

3. 为只有两个软盘而无硬盘的系统安装Turbo C 2.0。

　　这里假定按第一种选择进行安装, 只要在安装过程中按对盘号的提示, 顺序插入各个软盘, 就可以顺利地进行安装, 安装完毕将在C盘根目录下建立一个TC 子目录, TC下还建立了两个了目录LIB和INCLUDE, LIB子目录中存放库文件, INCLUDE子目录中存放所有头文件。运行Turbo C2.0时, 只要在TC 子目录下键入TC并回车即可进入Turbo C 2. 0 集成开发环境。

二、 Turbo C 2.0集成开发环境的使用

进入Turbo C 2.0集成开发环境中后, 屏幕上显示:
──────────────────────────────
　File Edit Run Compile Project Options Debug Break/watch
┌────────────Ed i t──────────────┐
│ Line 1 Col 1 Insert Indent Tab File Unindent c:NONAME.C │
│ │
│ │
│ │
│ │
│ │
│ │
│ │
│─────────Message─────────────── │
│ │
│ │
└────────────────────────────┘
F1-Help F5-Zoom F6-Switch F7-Trace F8-Step F9-Make F10-Menu
───────────────────────────────
其中顶上一行为Turbo C 2.0 主菜单, 中间窗口为编辑区, 接下来是信息窗口, 最底下一行为参考行。这四个窗口构成了Turbo C 2.0的主屏幕, 以后的编程、编译、调试以及运行都将在这个主屏幕中进行。下面详细介绍主菜单的内容。

1.主菜单

　　主菜单在Turbo C 2.0主屏幕顶上一行, 显示下列内容:File Edit Run Compile Project Options Debug Break/watch

　　除Edit外, 其它各项均有子菜单, 只要用Alt加上某项中第一个字母(即大写字母), 就可进入该项的子菜单中。

File (文件)菜单 ----按Alt+F可进入File菜单, 该菜单包括以下内容:

.Load (加载)
装入一个文件, 可用类似DOS的通配符(如*.C)来进行列表选择。也可装入其它扩展名的文件, 只要给出文件名(或只给路径)即可。该项的热键为F3, 即只要在主菜单中按F3即可进入该项, 而不需要先进入File菜单再选此项。

.Pick (选择)
将最近装入编辑窗口的8个文件列成一个表让用户选择, 选择后将该程序装入编辑区, 并将光标置在上次修改过的地方。其热健为Alt-F3。

.New (新文件)
说明文件是新的, 缺省文件名为NONAME.C, 存盘时可改名。

.Save (存盘)
将编辑区中的文件存盘, 若文件名是NONAME.C时, 将询问是否更改文件名, 其热键为F2。

.Write to (存盘)
可由用户给出文件名将编辑区中的文件存盘, 若该文件已存在, 则询问要不要覆盖。

.Directory (目录)
显示目录及目录中的文件, 并可由用户选择。

.Change dir (改变目录)
显示当前目录, 用户可以改变显示的目录。

.Os shell (暂时退出)
暂时退出Turbo C 2.0到DOS提示符下, 此时可以运行DOS 命令, 若想回到Turbo C 2.0中, 只要在DOS状态下键入EXIT即可。

.Quit (退出)
退出Turbo C 2.0, 返回到DOS操作系统中, 其热键为Alt+X。

说明: 以上各项可用光标键移动色棒进行选择, 回车则执行。也可用每一项的第一个大写字母直接选择。若要退到主菜单或从它的下一级菜单列表框退回均可用Esc键,Turbo C 2.0所有菜单均采用这种方法进行操作, 以下不再说明。

Edit (编辑)菜单---按Alt+E可进入编辑菜单, 若再回车, 则光标出现在编辑窗口, 此时用户可以进行文本编辑。编辑方法基本与wordstar相同,

可用F1键获得有关编辑方法的帮助信息。与编辑有关的功能键如下:
F1 获得Turbo C 2.0编辑命令的帮助信息
F5 扩大编辑窗口到整个屏幕
F6 在编辑窗口与信息窗口之间进行切换
F10 从编辑窗口转到主菜单

编辑命令简介:
PageUp 向前翻页
PageDn 向后翻页
Home 将光标移到所在行的开始
End 将光标移到所在行的结尾
Ctrl+Y 删除光标所在的一行
Ctrl+T 删除光标所在处的一个词
Ctrl+KB 设置块开始
Ctrl+KK 设置块结尾
Ctrl+KV 块移动
Ctrl+KC 块拷贝
Ctrl+KY 块删除
Ctrl+KR 读文件
Ctrl+KW 存文件
Ctrl+KP 块文件打印
Ctrl+F1 如果光标所在处为Turbo C 2.0库函数, 则获得有关该函数的帮助信息
Ctrl+Q[ 查找Turbo C 2.0双界符的后匹配符
Ctrl+Q] 查找Turbo C 2.0双界符的前匹配符
说明:
a. Turbo C 2.0的双界符包括以下几种符号:
花括符 { }
尖括符 < >
圆括符 ( )
方括符 [ ]
注释符 /* */
双引号 "
单引号 ''
Turbo C 2.0在编辑文件时还有一种功能, 就是能够自动缩进, 即光标定位和上一个非空字符对齐。在编辑窗口中, Ctrl+OL为自动缩进开关的控制键。

Run (运行)菜单---按Alt+R可进入Run菜单, 该菜单有以下各项:

.Run (运行程序)
运行由Project/Project name项指定的文件名或当前编辑区的文件。如果对上次编译后的源代码未做过修改, 则直接运行到下一个断点(没有断点则运行到结束)。否则先进行编译、连接后才运行, 其热键为Ctrl+F9。

.Program reset (程序重启)
中止当前的调试, 释放分给程序的空间, 其热键为Ctrl+F2。

.Go to cursor (运行到光标处)
调试程序时使用, 选择该项可使程序运行到光标所在行。光标所在行必须为一条可执行语句, 否则提示错误。其热键为F4。

.Trace into (跟踪进入)
在执行一条调用其它用户定义的子函数时, 若用Trace into项, 则执行长条将跟踪到该子函数内部去执行, 其热键为F7。

.Step over (单步执行)
执行当前函数的下一条语句, 即使用户函数调用, 执行长条也不会跟踪进函数内部, 其热键为F8。

.User screen (用户屏幕)
显示程序运行时在屏幕上显示的结果。其热键为Alt+F5。

Compile (编译)菜单---按Alt+C可进入Compile菜单, 该菜单有以下几个内容:

.Compile to OBJ (编译生成目标码)
将一个C源文件编译生成.OBJ目标文件, 同时显示生成的文件名。其热键为Alt+F9。

.Make EXE file (生成执行文件)
此命令生成一个.EXE的文件, 并显示生成的.EXE文件名。其中.EXE文件名是下面几项之一。
a. 由Project/Project name说明的项目文件名。
b. 若没有项目文件名, 则由Primary C file说明的源文件。
c. 若以上两项都没有文件名, 则为当前窗口的文件名。

.Link EXE file (连接生成执行文件)
把当前.OBJ文件及库文件连接在一起生成.EXE文件。

.Build all (建立所有文件)
重新编译项目里的所有文件, 并进行装配生成.EXE文件。该命令不作过时检查(上面的几条命令要作过时检查, 即如果目前项目里源文件的日期和时间与目标文件相同或更早, 则拒绝对源文件进行编译)。

.Primary C file (主C文件)
当在该项中指定了主文件后, 在以后的编译中, 如没有项目文件名则编译此项中规定的主C文件, 如果编译中有错误, 则将此文件调入编辑窗口, 不管目前窗口中是不是主C文件。

.Get info
获得有关当前路径、源文件名、源文件字节大小、编译中的错误数目、可用空间等信息。

Project (项目)菜单---按Alt+P可进入Project菜单, 该菜单包括以下内容:

.Project name (项目名)
项目名具有.PRJ的扩展名, 其中包括将要编译、连接的文件名。例如有一个程序由file1.c, file2.c, file3.c组成, 要将这3个文件编译装配成一个file.exe的执行文件, 可以先建立一个file.prj的项目文件, 其内容如下:
file1.c file2.c file3.c
此时将file.prj放入Project name项中, 以后进行编译时将自动对项目文件中规定的三个源文件分别进行编译。然后连接成file.exe文件。如果其中有些文件已经编译成.OBJ文件, 而又没有修改过, 可直接写上.OBJ扩 展名。此时将不再编译而只进行连接。例如: file1.obj file2.c file3.c 将不对file1.c进行编译, 而直接连接。 说明: 当项目文件中的每个文件无扩展名时, 均按源文件对待, 另外, 其中的文件也可以是库文件, 但必须写上扩展名.LIB。

.Break make on (中止编译)
由用户选择是否在有Warining(警告)、Errors(错误)、Fatal Errors( 致命错误)时或Link(连接)之前退出Make编译。

.Auto dependencies (自动依赖)
当开关置为on, 编译时将检查源文件与对应的.OBJ文件日期和时间, 否则不进行检查。

.Clear project (清除项目文件)
清除Project/Project name中的项目文件名。

.Remove messages (删除信息)
把错误信息从信息窗口中清除掉。

Options (选择菜单) ---按Alt+O可进入Options菜单, 该菜单对初学者来说要谨慎使用。

.Compiler (编译器)
本项选择又有许多子菜单, 可以让用户选择硬件配置、存储模型、调试技术、代码优化、对话信息控制和宏定义。这些子菜单如下: Model 共有Tiny, small, medium, compact, large, huge 六种不同模式可由同户选择。
Define 打开一个宏定义框, 同户可输入宏定义。多重定义可同分号, 赋值可用等号。
Code generation 它又有许多任选项, 这些任选项告诉编译器产生什么样的目标代码。
Calling convention 可选择C或Pascal方式传递参数。
Instruction set 可选择8088/8086或80186/80286指令系列。
Floating point 可选择仿真浮点、数学协处理器浮点或无浮点运算。
Default char type 规定char的类型。
Alignonent 规定地址对准原则。
Merge duplicate strings 作优化用, 将重复的字符串合并在一起。
Standard stack frame 产生一个标准的栈结构。
Test stack overflow 产生一段程序运行时检测堆栈溢出的代码。
Line number 在.OBJ文件中放进行号以供调试时用。
OBJ debug information 在.OBJ文件中产生调试信息。
Optimization
Optimize for 选择是对程序小型化还是对程序速度进行优化处理。
Use register variable 用来选择是否允许使用寄存器变量。
Register optimization 尽可能使用寄存器变量以减少过多的取数操作。
Jump optimization 　　通过去除多余的跳转和调整循环与开关语句的办法, 压缩代码。
Source
Indentifier length 说明标识符有效字符的个数, 默认为32个。
Nested comments 是否允许嵌套注释。
ANSI keywords only 　是只允许ANSI关键字还是也允许Turbo C 2.0关键字
Error
Error stop after 多少个错误时停止编译, 默认为25个。
Warning stop after　　　 多少个警告错误时停止编译, 默认为100个。
Display warning
Portability warning 移植性警告错误。
ANSI Violations 侵犯了ANSI关键字的警告错误。
Common error 常见的警告错误。
Less common error 少见的警告错误。
Names 用于改变段(segment)、 组( group) 和类(class)的名字, 默认值为CODE,DATA,BSS。

.Linker (连接器)
本菜单设置有关连接的选择项, 它有以下内容:
Map file menu 选择是否产生.MAP文件。
Initialize segments 是否在连接时初始化没有初始化的段。
Devault libraries 是否在连接其它编译程序产生的目标文件时去寻找其缺省库。
Graphics library 是否连接graphics库中的函数。
Warn duplicate symbols 当有重复符号时产生警告信息。
Stack warinig 是否让连接程序产生No stack的警告信息。
Case-sensitive link 是否区分大、小写字。

.Environment (环境)
本菜单规定是否对某些文件自动存盘及制表键和屏幕大小的设置
Message tracking

Current file 跟踪在编辑窗口中的文件错误。

All files 跟踪所有文件错误。

Off 不跟踪。

Keep message 编译前是否清除Message窗口中的信息。

Config auto save 选on时, 在Run, Shell或退出集成开发环境之前,如果Turbo C 2.0的配置被改过, 则所做 的改动将存入配置文件中。选off时不存。

Edit auto save 是否在Run或Shell之前, 自动存储编辑的源文件。

Backup file 是否在源文件存盘时产生后备文件(.BAK文件)。

Tab size 设置制表键大小, 默认为8。

Zoomed windows 将现行活动窗口放大到整个屏幕, 其热键为F5。

Screen size 设置屏幕文本大小。

.Directories (路径)
规定编译、连接所需文件的路径, 有下列各项:
Include directories 包含文件的路径, 多个子目录用";"分开。
Library directories 库文件路径, 多个子目录用";"分开。
Output directoried 输出文件(.OBJ, .EXE, .MAP文件)的目录。
Turbo C directoried Turbo C 所在的目录。
Pick file name 定义加载的pick文件名, 如不定义则从current pick file中取。

.Arguments (命令行参数)
允许用户使用命令行参数。

.Save options (存储配置)
保存所有选择的编译、连接、调试和项目到配置文件中, 缺省的配置文件为TCCONFIG.TC。

.Retrive options 装入一个配置文件到TC中, TC将使用该文件的选择项。

Debug (调试)菜单

---按Alt+D可选择Debug菜单, 该菜单主要用于查错, 它包括以下内容:

.Evaluate

.Expression 要计算结果的表达式。

.Result 显示表达式的计算结果。

.New value 赋给新值。

.Call stack 该项不可接触。而在Turbo C debuger 时用于检查堆栈情况。

.Find function 在运行Turbo C debugger时用于显示规定的函数。

.Refresh display 如果编辑窗口偶然被用户窗口重写了可用此恢复编辑窗口的内容。

Break/watch (断点及监视表达式)

---按Alt+B可进入Break/watch菜单, 该菜单有以下内容:

. Add watch 向监视窗口插入一监视表达式。

.Delete watch 从监视窗口中删除当前的监视表达式。

.Edit watch 在监视窗口中编辑一个监视表达式。

.Remove all watches 从监视窗口中删除所有的监视表达式。

.Toggle breakpoint 对光标所在的行设置或清除断点。

. Clear all breakpoints 清除所有断点。

. View next breakpoint 将光标移动到下一个断点处。

三、Turbo C 2.0的配置文件

所谓配置文件是包含Turbo C 2.0有关信息的文件, 其中存有编译、连接的选择和路径等信息。可以用下述方法建立Turbo C 2.0的配置:

1. 建立用户自命名的配置文件
可以从Options菜单中选择Options/Save options命令, 将当前集成开发环境的所有配置存入一个由用户命名的配置文件中。下次启动TC时只要在DOS下键入: tc/c <用户命名的配置文件就会按这个配置文件中的内容作为Turbo C 2.0的选择。

2. 若设置Options/Environment/Config auto save 为on, 则退出集成开发环境时, 当前的设置会自动存放到Turbo C 2.0配置文件TCCONFIG.TC中。Turbo C 在启动时会自动寻找这个配置文件。

3. 用TCINST设置Turbo C的有关配置, 并将结果存入TC.EXE中。Turbo C 在启动时, 若没有找到配置文件, 则取TC.EXE中的缺省值

阅读全文(921) | 评论:0 | 复制链接