推箱子c语言程序代码（求助啊，谁有有趣的c语言小程序，并且要有源代码！！）

：暂无数据 2026-08-04 10:10:01 ：0

大家好，推箱子c语言程序代码相信很多的网友都不是很明白，包括求助啊，谁有有趣的c语言小程序，并且要有源代码！！也是一样，不过没有关系，接下来就来为大家分享关于推箱子c语言程序代码和求助啊，谁有有趣的c语言小程序，并且要有源代码！！的一些知识点，大家可以关注收藏，免得下次来找不到哦，下面我们开始吧！

本文目录

求助啊，谁有有趣的c语言小程序，并且要有源代码！！
用c语言编写一个简易的抽奖程序，
如何做一个C语言编程的汉诺塔游戏要有源代码
求帮忙编写c语言抽奖程序
c语言推箱子
c语言游戏代码大全（收录100多款经典游戏源码）
C语言编译过程详解
广度优先搜索C语言算法

求助啊，谁有有趣的c语言小程序，并且要有源代码！！

学习“推箱子”C语言编码：

#include 《stdio.h》

#include 《conio.h》

#include《stdlib.h》

#include《windows.h》

int m =0; //m代表第几关

struct maps{short a; };

struct maps map={ 0,0,0,0,0,0,0,0,0,0,0, //共5关,每关9行

0,1,1,1,1,1,1,1,0,0,0,

0,1,0,0,0,0,0,1,1,1,0,

1,1,4,1,1,1,0,0,0,1,0, //0空地,1墙

1,5,0,0,4,0,0,4,0,1,0, //4是箱子,5是人

1,0,3,3,1,0,4,0,1,1,0, //3是目的地

1,1,3,3,1,0,0,0,1,0,0, //7是箱子在目的地(4+3)

0,1,1,1,1,1,1,1,1,0,0, //8是人在目的地(5+3)

0,0,0,0,0,0,0,0,0,0,0,

0,0,1,1,1,1,0,0,0,0,0,

0,0,1,5,0,1,1,1,0,0,0,

0,0,1,0,4,0,0,1,0,0,0,

0,1,1,1,0,1,0,1,1,0,0,

0,1,3,1,0,1,0,0,1,0,0,

0,1,3,4,0,0,1,0,1,0,0,

0,1,3,0,0,0,4,0,1,0,0,

0,1,1,1,1,1,1,1,1,0,0,

0,0,0,0,0,0,0,0,0,0,0,

0,0,0,1,1,1,1,1,1,1,0,

0,0,1,1,0,0,1,0,5,1,0,

0,0,1,0,0,0,1,0,0,1,0,

0,0,1,4,0,4,0,4,0,1,0,

0,0,1,0,4,1,1,0,0,1,0,

1,1,1,0,4,0,1,0,1,1,0,

1,3,3,3,3,3,0,0,1,0,0,

1,1,1,1,1,1,1,1,1,0,0,

0,1,1,1,1,1,1,1,1,1,0,

0,1,0,0,1,1,0,0,0,1,0,

0,1,0,0,0,4,0,0,0,1,0,

0,1,4,0,1,1,1,0,4,1,0,

0,1,0,1,3,3,3,1,0,1,0,

1,1,0,1,3,3,3,1,0,1,1,

1,0,4,0,0,4,0,0,4,0,1,

1,0,0,0,0,0,1,0,5,0,1,

1,1,1,1,1,1,1,1,1,1,1,

0,0,0,0,0,0,0,0,0,0,0,

0,0,0,1,1,1,1,1,1,0,0,

0,1,1,1,0,0,0,0,1,0,0,

1,1,3,0,4,1,1,0,1,1,0,

1,3,3,4,0,4,0,0,5,1,0,

1,3,3,0,4,0,4,0,1,1,0,

1,1,1,1,1,1,0,0,1,0,0,

0,0,0,0,0,1,1,1,1,0,0,

0,0,0,0,0,0,0,0,0,0,0 };

void DrMap( ) //绘制地图

{ CONSOLE_CURSOR_INFO cursor_info={1,0}; //隐藏光标的设置

SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info);

printf("\n\n \t\t\b推箱子");

printf("\n \t");

for (int i = 0; i 《 9; i++)

{for (int j = 0; j 《 11; j++)

{switch (map)

{case 0: printf(" "); break;

case 1: printf("■"); break;

case 3: printf("◎");break;

case 4: printf("□"); break;

case 5: printf(":female_sign:"); break; //5是人

case 7: printf("□"); break; //4 + 3箱子在目的地中

case 8: printf(":female_sign:");break; // 5 + 3人在目的地中

}

printf("\n\t");

}

void gtxy(int x, int y) //控制光标位置的函数

{ COORD coord;

coord.X = x;

coord.Y = y;

SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);

}

void start( ) //开始游戏

{ int r, c; //r，c用于记录人的下标

for (int i = 0; i 《 9; i++)

{ for (int j = 0; j 《 11; j++)

{if (map==8) { r = i; c = j; } } //i j 人的下标

}

char key;

key = getch( );

switch (key)

{case ’W’:

case ’w’:

case 72:

if (map == 3)

{ gtxy(2*c+8,r-1+3); printf(":female_sign:"); // gtxy(2*c+8,r-1+3)是到指定位置输出字符

if(map == 5){gtxy(2*c+8,r+3); printf(" "); }

if(map == 8){gtxy(2*c+8,r+3); printf("◎");}

map -= 5; }

else if (map == 7)

{ if (map == 3)

{ gtxy(2*c+8,r-2+3); printf("□"); gtxy(2*c+8,r-1+3); printf(":female_sign:");

if(map == 5){gtxy(2*c+8,r+3); printf(" "); }

if(map == 8){gtxy(2*c+8,r+3); printf("◎");}

map += 1;

map -= 5; }

} break;

case ’S’:

case ’s’:

case 80:

if (map == 3)

{ gtxy(2*c+8,r+1+3); printf(":female_sign:");

if(map == 5){gtxy(2*c+8,r+3); printf(" "); }

if(map == 8){gtxy(2*c+8,r+3); printf("◎");}

map -= 5; }

else if (map == 7)

{ if (map == 3)

{ gtxy(2*c+8,r+2+3); printf("□"); gtxy(2*c+8,r+1+3); printf(":female_sign:");

if(map == 5){gtxy(2*c+8,r+3); printf(" "); }

if(map == 8){gtxy(2*c+8,r+3); printf("◎");}

map += 1;

map -= 5; }

}break;

case ’A’:

case ’a’:

case 75:

if (map == 3)

{ gtxy(2*(c-1)+8,r+3); printf(":female_sign:");

if(map == 5){gtxy(2*c+8,r+3); printf(" "); }

if(map == 8){gtxy(2*c+8,r+3); printf("◎");}

map -= 5; }

else if (map == 7)

{if (map == 3)

{ gtxy(2*(c-2)+8,r+3); printf("□"); gtxy(2*(c-1)+8,r+3); printf(":female_sign:");

if(map == 5){gtxy(2*c+8,r+3); printf(" "); }

if(map == 8){gtxy(2*c+8,r+3); printf("◎");}

map += 1;

map -= 5; }

}break;

case ’D’:

case ’d’:

case 77:

if (map == 3)

{ gtxy(2*(c+1)+8,r+3); printf(":female_sign:");

if(map == 5){gtxy(2*c+8,r+3); printf(" "); }

if(map == 8) {gtxy(2*c+8,r+3); printf("◎");}

map -= 5; }

else if (map == 7)

{ if (map == 3)

{ gtxy(2*(c+2)+8,r+3); printf("□"); gtxy(2*(c+1)+8,r+3); printf(":female_sign:");

if(map == 5){gtxy(2*c+8,r+3); printf(" "); }

if(map == 8){gtxy(2*c+8,r+3); printf("◎");}

map += 1;

map -= 5; }

}break;

}

int ifwan( ) //是否完成(1是0否)

{ if(m==0){if(map==7&&

map==7) return 1;}

if(m==1){if(map==7&&

map==7) return 1;}

if(m==2){if(map==7&&

map==7) return 1;}

if(m==3){if(map==7&&

map==7) return 1;}

if(m==4){if(map==7&&

map==7) return 1;}

return 0;

}

int main( ) //主函数

{ while (1)

{ system("cls");

DrMap( );

while (1)

{ start( );

if(ifwan()){printf("\007");break;} //完成后响铃

}

m+=1;

}

return 0;

}

用data.txt文件保存以下内容：
13725528132 李桂荣
13725528131 李二来
13725528133 张荣刚
13725528130 荣南
13725528137 王三
13725528138 吴立
13725528139 郭德纲
13725528140 周星驰
13725528141 张曼玉
13725528142 张艺谋
13725528152 秦香莲
13725528162 潘金莲
13725528172 李大嘴
13725528182 展堂
//源代码如下
#include 《stdio.h》
#include 《stdlib.h》
#include 《time.h》
#define MAX_NUM 9999
//定义保存人名和电话的数据结构
struct Person
{
char name;
char telno;
char award;
};
int num = 0; //统计人数
FILE *fp; //文件指针
Person persons; //定义数组
int awarder_1 = {-1}; //一等奖
int awarder_2 = {-1, -1}; //二等奖
int awarder_3 = {-1, -1, -1, -1, -1};//三等奖
//读取文件
void readdata()
{
int i = 0; //数组下标
Person person;
//文件打开
fp = fopen("data.txt", "r");
if (fp == NULL)
{
printf("打开文件data.txt失败!\n");
return;
}
//当文件不为空
while (!feof(fp))
{
num ++;
fscanf(fp, "%s", person.telno);
fscanf(fp, "%s", person.name);
person.award = ’F’;
persons = person;
}
}
//初始化标识
void init()
{
for(int i = 0; i 《 num; i++)
{
persons.award = ’F’;
}
}
//显示单个中奖信息
void info( int i)
{
printf("手机号码: %s 姓名: %s\n", persons.name);
}
void main()
{
char again = ’Y’;
//读取文件
readdata();
printf("简单抽奖程序\n");
srand((long)time(0));
while(again == ’Y’ || again == ’y’)
{
//初始化标识
init();
printf("\n开始抽第一等奖(1名)，按任意键开始...\n");
getchar();
awarder_1 = abs(rand() % num);
while (persons.award == ’T’)
{
awarder_1 = rand() % num;
}
persons.award = ’T’;
info(awarder_1);
printf("\n开始抽第二等奖(2名)\n");
for (int i = 0; i 《 2; i++)
{
printf("\n第%d个二等奖,按任意键开始...\n", i+1);
getchar();
awarder_2 = rand() % num;
while (persons.award == ’T’)
{
awarder_2 = rand() % num;
}
persons.award = ’T’;
info(awarder_2);
}
printf("\n\n开始抽第三等奖(5名)\n");
for (i = 0; i 《 5; i++)
{
printf("\n第%d个三等奖,按任意键开始...\n", i + 1);
getchar();
awarder_3 = rand() % num;
while (persons.award == ’T’)
{
awarder_3 = rand() % num;
}
persons.award = ’T’;
info(awarder_3);
}
printf("\n是否重新开始抽奖?(Y or N)...\n");
again = getchar();
}
getchar();
return;
}

如何做一个C语言编程的汉诺塔游戏要有源代码

#include《stdio.h》
void move(char x,char y)
{
printf("%c--》%c\n",x,y);
}
void hanoi(int n,char one ,char two,char three)
{
if(n==1) move(one,three);
else
{
hanoi(n-1,one,three,two);
move(one,three);
hanoi(n-1,two,one,three);
}
}
main()
{
int m;
printf("input the number of disks:");
scanf("%d",&m);
printf("the step to moving %3d diskes:\n",m);
hanoi(m,’A’,’B’,’C’);
}
算法介绍：
其实算法非常简单，当盘子的个数为n时，移动的次数应等于2^n – 1（有兴趣的可以自己证明试试看）。后来一位美国学者发现一种出人意料的简单方法，只要轮流进行两步操作就可以了。首先把三根柱子按顺序排成品字型，把所有的圆盘按从大到小的顺序放在柱子A上，根据圆盘的数量确定柱子的排放顺序：若n为偶数，按顺时针方向依次摆放 A B C；
若n为奇数，按顺时针方向依次摆放 A C B。
（1）按顺时针方向把圆盘1从现在的柱子移动到下一根柱子，即当n为偶数时，若圆盘1在柱子A，则把它移动到B；若圆盘1在柱子B，则把它移动到C；若圆盘1在柱子C，则把它移动到A。
（2）接着，把另外两根柱子上可以移动的圆盘移动到新的柱子上。即把非空柱子上的圆盘移动到空柱子上，当两根柱子都非空时，移动较小的圆盘。这一步没有明确规定移动哪个圆盘，你可能以为会有多种可能性，其实不然，可实施的行动是唯一的。
（3）反复进行（1）（2）操作，最后就能按规定完成汉诺塔的移动。
所以结果非常简单，就是按照移动规则向一个方向移动金片：
如3阶汉诺塔的移动：A→C,A→B,C→B,A→C,B→A,B→C,A→C
汉诺塔问题也是程序设计中的经典递归问题，下面我们将给出递归和非递归的不同实现源代码。

求帮忙编写c语言抽奖程序

自己看着修改一下就ok了，。。。
/*
预先将参加抽奖者的资料输入存储起来，主要用结构体数组实现，用结构体表示每项记录，包括身份证号码、姓名、电话、住址等信息。开始抽奖时，屏幕上快速闪动参与者的身份证号码，按任意键停止闪动，把中奖人的信息用显示在屏幕上。可反复抽出一、二、三等奖若干名。
设计实现以下功能：
（1）录入：完成抽奖者信息的输入；
（2）删除：完成抽奖者信息的删除；
（3）修改：允许对已经录入的数据重新进行、修改；
（4）显示：显示所有中奖者的信息；
（5）抽奖：
a. 抽出一等奖 1 名，如果抽过就不能再抽；
b. 抽出二等奖 2 名，如果抽完就不能再抽；
c. 抽出三等奖 5 名，如果抽完就不能再抽；
（6）退出程序。*/
#include《stdio.h》
#include 《conio.h》
#include 《stdlib.h》
#include 《memory.h》
#include 《string.h》
#include 《time.h》
#define AWARDER_NUM 10
typedef struct tag_award
{
char ID;
char name;
char telNo;
char address;
}AWARDER;
AWARDER * awarder = new AWARDER;
int first_award = {-1};
int second_award = {-1,-1};
int third_award ={-1,-1,-1,-1,-1};
int awarder_num = 0;
void info_login()
{
if(awarder_num 》= AWARDER_NUM)
{
AWARDER * new_awarder = new AWARDER;
memcpy(new_awarder,awarder,awarder_num*sizeof(AWARDER));
delete awarder;
awarder = new_awarder;
}

printf("身份证号：");
scanf("%s",awarder.ID);
printf("姓名：");
scanf("%s",awarder.name);
printf("电话号码：");
scanf("%s",awarder.telNo);
printf("家庭住址：");
scanf("%s",awarder.address);

awarder_num++;
}
void info_delete()
{
char name;
printf("输入您要删除的抽奖者的姓名：");
scanf("%s",name);
for(int i=0;i《awarder_num;i++)
{
if (strcmp(awarder.name,name) == 0)
{
printf("您选择删除的抽奖者的信息如下：\n");
printf("身份证号：%s\n",awarder.ID);
printf("姓名：%s\n",awarder.name);
printf("电话号码：%s\n",awarder.telNo);
printf("家庭住址：%s\n",awarder.address);
break;
}
}
if(i == awarder_num)
{
printf("没有找到您输入的抽奖者！\n");
}
else
{
char c;
printf("您确定要删除吗？(Y//N)");
fflush(stdin);
scanf("%c",&c);
if(c == ’Y’ || c == ’y’)
{
AWARDER * new_award = new AWARDER;
if(i 《= 0)
memcpy(new_award,awarder+1,sizeof(AWARDER) * (awarder_num - 1));
else if( i 》= awarder_num -1)
memcpy(new_award,awarder,sizeof(AWARDER) * (awarder_num - 1));
else
{
memcpy(new_award,awarder,sizeof(AWARDER) * i);
memcpy(new_award+i,awarder+i+1,sizeof(AWARDER) * (awarder_num - i - 1));
}
awarder_num--;
delete awarder;
awarder = new_award;
}
}

}
void info_modify()
{
char name;
printf("输入您要修改的抽奖者的姓名：");
scanf("%s",name);
for(int i=0;i《awarder_num;i++)
{
if (strcmp(awarder.name,name) == 0)
{
printf("您选择的抽奖者的信息如下：\n");
printf("身份证号：%s\n",awarder.ID);
printf("姓名：%s\n",awarder.name);
printf("电话号码：%s\n",awarder.telNo);
printf("家庭住址：%s\n",awarder.address);
break;
}
}
if(i == awarder_num)
{
printf("没有找到您输入的抽奖者！\n");
}
else
{
printf("请输入该抽奖者的新信息：\n");
printf("身份证号：");
scanf("%s",awarder.ID);
printf("姓名：");
scanf("%s",awarder.name);
printf("电话号码：");
scanf("%s",awarder.telNo);
printf("家庭住址：");
scanf("%s",awarder.address);
}
}
bool check_over(int cur_award,int awarderNo)
{
if(awarderNo == 1)
{
if(cur_award == first_award)
return true;
}
else if(awarderNo 《= 3)
{
if(cur_award == first_award)
return true;
for(int i=0;i《awarderNo-1;i++)
if(cur_award == second_award)
return true;
}
else if(awarderNo 《= 8)
{
if(cur_award == first_award)
return true;
for(int i=0;i《2;i++)
if(cur_award == second_award)
return true;
for(i=0;i《awarderNo-3;i++)
if(cur_award == third_award)
return true;
}
return false;
}
void award()
{
if(awarder_num 《 8)
{
printf("人数太少，请添加足够的人再抽奖！\n");
return;
}
srand((long)time(0));
char hit_id;
printf("\n开始抽第一等奖（1名），按任意键开始...\n");
getch();
while(!kbhit())
{
first_award = rand() % awarder_num;
memcpy(hit_id,awarder.ID,18);
printf("\r ");
printf("\r %s",hit_id);
}
printf("\n\n开始抽第二等奖（2名）");
for (int i=0;i《2;i++)
{
printf("\n第%d个二等奖,按任意键开始...\n",i+1);
getch();
while(!kbhit())
{
second_award = rand() % awarder_num;
while(check_over(second_award,1+i))
second_award = rand() % awarder_num;
memcpy(hit_id,awarder.ID,18);
printf("\r ");
printf("\r %s",hit_id);
}
}
printf("\n\n开始抽第三等奖（5名）");
for (i=0;i《5;i++)
{
printf("\n第%d个三等奖,按任意键开始...\n",i+1);
getch();
while(!kbhit())
{
third_award = rand() % awarder_num;
while(check_over(third_award,3+i))
third_award = rand() % awarder_num;
memcpy(hit_id,awarder.ID,20);
printf("\r ");
printf("\r %s",hit_id);
}
}
}
void info_show()
{
printf("一等奖获得者：\n");
printf("\t身份证号：%s\n",awarder.ID);
printf("\t姓名：%s\n",awarder.name);
printf("\t电话号码：%s\n",awarder.telNo);
printf("\t家庭住址：%s\n",awarder.address);
printf("二等奖获得者：\n");
for (int i=0;i《2;i++)
{
printf("第%d个二等奖获得者：\n");
printf("\t身份证号：%s\n",awarder.ID);
printf("\t姓名：%s\n",awarder.name);
printf("\t电话号码：%s\n",awarder.telNo);
printf("\t家庭住址：%s\n",awarder.address);
}
printf("三等奖获得者：\n");
for (int i=0;i《5;i++)
{
printf("第%d个三等奖获得者：\n");
printf("\t身份证号：%s\n",awarder.ID);
printf("\t姓名：%s\n",awarder.name);
printf("\t电话号码：%s\n",awarder.telNo);
printf("\t家庭住址：%s\n",awarder.address);
}

}
/*提示信息*/
bool raise()
{
printf("\n请输入你需要的操作代号：\n");
printf("\t1.录入：完成抽奖者信息的输入;\n");
printf("\t2.删除：完成抽奖者信息的删除;\n");
printf("\t3.修改：允许对已经录入的数据重新进行、修改;\n");
printf("\t4.抽奖：开始抽奖！\n");
printf("\t5.显示：显示所有中奖者的信息;\n");
printf("\t6.退出。\n");
printf("==》");
int operate;
fflush(stdin);
scanf("%d",&operate);
switch(operate)
{
case 1:
info_login();
break;
case 2:
info_delete();
break;
case 3:
info_modify();
break;
case 4:
award();
break;
case 5:
info_show();
break;
case 6:
return false;
default:
break;
}
printf("\n操作完成。\n");
return true;
}
void main()
{
while(raise());
}

c语言推箱子

//空:0  墙:1  箱子:3   巢:4   箱子与巢重合:5
map_count=8
w=8
h=8
nest_count=4
l1=0 0 0 1 1 1 0 0
l2=0 0 0 1 3 1 0 0
l3=1 1 1 1 0 1 0 0
l4=1 3 2 0 2 1 1 1
l5=1 1 1 4 2 0 3 1
l6=0 0 1 2 1 1 1 1
l7=0 0 1 3 1 0 0 0
l8=0 0 1 1 1 0 0 0
w=9
h=9
nest_count=3
l1=1 1 1 1 1 0 0 0 0
l2=1 4 0 0 1 0 0 0 0
l3=1 0 2 2 1 0 1 1 1
l4=1 0 2 0 1 0 1 3 1
l5=1 1 1 0 1 1 1 3 1
l6=0 1 1 0 0 0 0 3 1
l7=0 1 0 0 0 1 0 0 1
l8=0 1 0 0 0 1 1 1 1
l9=0 1 1 1 1 1 0 0 0
w=10
h=7
nest_count=4
l1=0 1 1 1 1 1 1 1 0 0
l2=0 1 0 0 0 0 0 1 1 1
l3=1 1 2 1 1 1 0 0 0 1
l4=1 0 4 0 2 0 0 2 0 1
l5=1 0 3 3 1 0 2 0 1 1
l6=1 1 3 3 1 0 0 0 1 0
l7=0 1 1 1 1 1 1 1 1 0
w=6
h=8
nest_count=5
l1=0 1 1 1 1 0
l2=1 1 0 0 1 0
l3=1 4 2 0 1 0
l4=1 1 2 0 1 1
l5=1 1 0 2 0 1
l6=1 3 2 0 0 1
l7=1 3 3 5 3 1
l8=1 1 1 1 1 1
//以上为地图数据文件,保存为boxdata.dat文件
//空:0  墙:1  箱子:3   巢:4   箱子与巢重合:5
#include 《stdio.h》
#include 《stdlib.h》
#include 《stdbool.h》
#include 《windows.h》
#include 《string.h》
typedef struct
{
int x;
int y;
} PT;
int** s;
PT man;
PT* nest=NULL;
PT prev;
int nest_count=0;
int map_count=0;
int gate=1;
int w,h;
char work_dir={’\0’};
char data_file={’\0’};
void GetDataFromFile();
void GetIntFromLineString(char* ch, int len, int i);
void Draw();
bool is_Success();
int main()
{
printf("Loading...");
CONSOLE_CURSOR_INFO cci;
cci.bVisible = FALSE;
cci.dwSize = sizeof(cci);
HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleCursorInfo(handle, &cci);
_getcwd(work_dir,100);
strcpy(data_file,work_dir);
strcat(data_file,"\\boxdata.dat");
if(access(data_file,0))
{
printf("Don’t find map data file !");
getch();
exit(0);
}
while(1)
{
GetDataFromFile();
int sel=0;
Draw();
while(1)
{
fflush(stdin);
sel=getch();
if(sel==224)
{
sel=getch();
prev=man;
if(sel==77)  //right
{
if(s==2)
{
if(s==3)
{
s=2;
s=4;
s=0;
}
else
{
continue;
}
}
else if(s==3)
{
s=4;
s=0;
}
else
{
continue;
}
}
else if(sel==80)  //down
{
if(s==2)
{
if(s==3)
{
s=2;
s=4;
s=0;
}
else
{
continue;
}
}
else if(s==3)
{
s=4;
s=0;
}
else
{
continue;
}
}
else if(sel==72)  //up
{
if(s==2)
{
if(s==3)
{
s=2;
s=4;
s=0;
}
else
{
continue;
}
}
else if(s==3)
{
s=4;
s=0;
}
else
{
continue;
}
}
else if(sel==75)  //left
{
if(s==2)
{
if(s==3)
{
s=2;
s=4;
s=0;
}
else
{
continue;
}
}
else if(s==3)
{
s=4;
s=0;
}
else
{
continue;
}
}
int i;
for(i=0;i《nest_count;i++)
{
if(nest.y==prev.y)
{
s=3;
break;
}
}
Draw();
if(is_Success()==true)
{
gate++;
if(gate》map_count)
{
printf("\n\nmap is end!");
fflush(stdin);
getch();
exit(0);
}
break;
}
}
else if(sel==’q’ || sel==’Q’)
{
exit(0);
}
else if(sel==’r’ || sel==’R’)
{
break;
}
}
}
return 0;
}
void GetDataFromFile()
{
int i;
if(s!=NULL)
{
if(h!=0)
{
for(i=0;i《h;i++)
{
free(s+i);
}
free(s);
}
else
{
printf("fail");
getch();
exit(0);
}
}
if(nest!=NULL)
{
free(nest);
}
map_count=GetPrivateProfileInt("MAPCOUNT","map_count",0,data_file);
if(map_count《gate)
{
printf("gate finish!");
getch();
exit(0);
}
char section={’\0’};
sprintf(section,"MAP%d",gate);
nest_count=GetPrivateProfileInt(section,"nest_count",0,data_file);
nest=(PT*)malloc(sizeof(PT)*nest_count);
w=GetPrivateProfileInt(section,"w",0,data_file);
h=GetPrivateProfileInt(section,"h",0,data_file);
if(w《5 || h《5 || nest_count《1)
{
printf("w or h or box_nest data error!");
getch();
exit(0);
}
s=(int**)malloc(sizeof(int*)*h);
for(i=0;i《h;i++)
{
*(s+i)=(int*)malloc(sizeof(int)*w);
}
char key={’\0’};
char line={’\0’};
int len;
int j;
for(i=0;i《h;i++)
{
memset(line,’\0’,50);
sprintf(key,"l%d",i+1);
GetPrivateProfileString(section,key,"\0",line,50,data_file);
len=strlen(line);
if(len》0)
{
line=’ ’;
line=’\0’;
}
GetIntFromLineString(line,strlen(line),i);
}
len=0;
for(i=0;i《h;i++)
{
for(j=0;j《w;j++)
{
if(s==3)
{
nest.y=i;
nest.x=j;
len++;
}
else if(s==5)
{
nest.y=i;
nest.x=j;
len++;
s=2;
}
}
}
}
void strmyncpy(char* source, char* target, int begin, int end)
{
int i=0;
while(1)
{
if(source!=’ ’)
{
target;
}
i++;
begin++;
if(begin》end)
{
target=’\0’;
break;
}
}
}
void GetIntFromLineString(char* ch, int len, int i)
{
int j=0;
char c={’\0’};
int b=0,e=0;
while(e《len)
{
if(ch==’ ’)
{
memset(c,’\0’,5);
strmyncpy(ch,c,b,e);
b=e+1;
e++;
s=atoi(c);
}
e++;
}
}
void Draw()
{
int i,j,k;
bool flag=false;
system("cls");
printf("\n\n");
for(i=0;i《h;i++)
{
printf("\n\n");
for(j=0;j《w;j++)
{
if(s==0)
{
printf("    ");
}
else if(s==1)
{
printf(" ■ ");
}
else if(s==2)
{
printf(" ★ ");
}
else if(s==3)
{
printf(" ☆ ");
}
else if(s==4)
{
printf(" ◎ ");
man.x=j;
man.y=i;
}
}
}
}
bool is_Success()
{
int i,j;
for(i=0;i《h;i++)
{
for(j=0;j《w;j++)
{
if(s==3)
{
return false;
}
}
}
for(i=0;i《nest_count;i++)
{
if(man.x==nest.y)
{
return false;
}
}
return true;
}

c语言游戏代码大全（收录100多款经典游戏源码）

C语言是一种广泛使用的编程语言，其强大的功能和高效的性能使其成为游戏开发的首选语言。本文将介绍100多款经典游戏的C语言源码，供游戏开发者学习和参考。

操作步骤

Step1:下载源码

访问Github上的C语言游戏代码大全仓库，找到需要的游戏源码，点击“Download”按钮下载源码压缩包。

Step2:解压源码

使用解压软件将下载的源码压缩包解压到本地硬盘上。

Step3:编译源码

使用C语言编译器（如GCC）编译源码，生成可执行文件。

Step4:运行游戏

运行生成的可执行文件，开始游戏。

经典游戏源码

1.俄罗斯方块

俄罗斯方块是一款经典的益智游戏，玩家需要通过旋转和移动方块，使其在下落过程中排列成完整的一行或多行，从而消除方块并得分。

操作步骤

使用方向键控制方块移动和旋转，按空格键加速方块下落。

2.扫雷

扫雷是一款经典的单人益智游戏，玩家需要根据周围的数字推断出隐藏在方格中的地雷位置，最终揭开所有非地雷方格并得分。

操作步骤

使用鼠标左键点击方格揭开，使用鼠标右键标记可能的地雷位置。

3.贪吃蛇

贪吃蛇是一款经典的单人游戏，玩家需要通过控制一条蛇在屏幕上移动，吃掉食物并不断成长，直到撞到墙壁或自己的身体为止。

操作步骤

使用方向键控制蛇的移动方向，吃到食物后蛇的长度加1。

4.五子棋

五子棋是一款经典的两人对弈游戏，玩家需要通过在棋盘上下棋，先在横、竖、斜方向上连成五子的一方获胜。

操作步骤

使用鼠标点击棋盘上的空格下棋，先连成五子的一方获胜。

5.推箱子

推箱子是一款经典的益智游戏，玩家需要通过推动箱子使其到达指定位置，最终完成所有关卡。

操作步骤

使用方向键控制人物移动和推动箱子，将箱子推到指定位置即可过关。

C语言编译过程详解

C语言编译过程详解
C语言的编译链接过程是要把我们编写的一个C程序(源代码)转换成可以在硬件上运行的程序(可执行代码)，需要进行编译和链接。编译就是把文本形式源代码翻译为机器语言形式的目标文件的过程。链接是把目标文件、操作系统的启动代码和用到的库文件进行组织形成最终生成可执行代码的过程。过程图解如下：

从图上可以看到，整个代码的编译过程分为编译和链接两个过程，编译对应图中的大括号括起的部分，其余则为链接过程。
一、编译过程
编译过程又可以分成两个阶段：编译和汇编。
1、编译
编译是读取源程序(字符流)，对之进行词法和语法的分析，将高级语言指令转换为功能等效的汇编代码，源文件的编译过程包含两个主要阶段：
第一个阶段是预处理阶段，在正式的编译阶段之前进行。预处理阶段将根据已放置在文件中的预处理指令来修改源文件的内容。如#include指令就是一个预处理指令，它把头文件的内容添加到.cpp文件中。这个在编译之前修改源文件的方式提供了很大的灵活性，以适应不同的计算机和操作系统环境的限制。一个环境需要的代码跟另一个环境所需的代码可能有所不同，因为可用的硬件或操作系统是不同的。在许多情况下，可以把用于不同环境的代码放在同一个文件中，再在预处理阶段修改代码，使之适应当前的环境。
主要是以下几方面的处理：
(1)宏定义指令，如 #define a b。
对于这种伪指令，预编译所要做的是将程序中的所有a用b替换，但作为字符串常量的 a则不被替换。还有 #undef，则将取消对某个宏的定义，使以后该串的出现不再被替换。
(2)条件编译指令，如#ifdef，#ifndef，#else，#elif，#endif等。
这些伪指令的引入使得程序员可以通过定义不同的宏来决定编译程序对哪些代码进行处理。预编译程序将根据有关的文件，将那些不必要的代码过滤掉
(3) 头文件包含指令，如#include "FileName"或者#include 《FileName》等。
在头文件中一般用伪指令#define定义了大量的宏(最常见的是字符常量)，同时包含有各种外部符号的声明。采用头文件的目的主要是为了使某些定义可以供多个不同的C源程序使用。因为在需要用到这些定义的C源程序中，只需加上一条#include语句即可，而不必再在此文件中将这些定义重复一遍。预编译程序将把头文件中的定义统统都加入到它所产生的输出文件中，以供编译程序对之进行处理。包含到C源程序中的头文件可以是系统提供的，这些头文件一般被放在/usr/include目录下。在程序中#include它们要使用尖括号(《》)。另外开发人员也可以定义自己的头文件，这些文件一般与C源程序放在同一目录下，此时在#include中要用双引号("")。
(4)特殊符号，预编译程序可以识别一些特殊的符号。
例如在源程序中出现的LINE标识将被解释为当前行号(十进制数)，FILE则被解释为当前被编译的C源程序的名称。预编译程序对于在源程序中出现的这些串将用合适的值进行替换。
预编译程序所完成的基本上是对源程序的“替代”工作。经过此种替代，生成一个没有宏定义、没有条件编译指令、没有特殊符号的输出文件。这个文件的含义同没有经过预处理的源文件是相同的，但内容有所不同。下一步，此输出文件将作为编译程序的输出而被翻译成为机器指令。
第二个阶段编译、优化阶段。经过预编译得到的输出文件中，只有常量；如数字、字符串、变量的定义，以及C语言的关键字，如main,if,else,for,while,{,}, +,-,*,\等等。
编译程序所要作得工作就是通过词法分析和语法分析，在确认所有的指令都符合语法规则之后，将其翻译成等价的中间代码表示或汇编代码。
优化处理是编译系统中一项比较艰深的技术。它涉及到的问题不仅同编译技术本身有关，而且同机器的硬件环境也有很大的关系。优化一部分是对中间代码的优化。这种优化不依赖于具体的计算机。另一种优化则主要针对目标代码的生成而进行的。
对于前一种优化，主要的工作是删除公共表达式、循环优化(代码外提、强度削弱、变换循环控制条件、已知量的合并等)、复写传播，以及无用赋值的删除，等等。
后一种类型的优化同机器的硬件结构密切相关，最主要的是考虑是如何充分利用机器的各个硬件寄存器存放的有关变量的值，以减少对于内存的访问次数。另外，如何根据机器硬件执行指令的特点(如流水线、RISC、CISC、VLIW等)而对指令进行一些调整使目标代码比较短，执行的效率比较高，也是一个重要的研究课题。
2、汇编
汇编实际上指把汇编语言代码翻译成目标机器指令的过程。对于被翻译系统处理的每一个C语言源程序，都将最终经过这一处理而得到相应的目标文件。目标文件中所存放的也就是与源程序等效的目标的机器语言代码。目标文件由段组成。通常一个目标文件中至少有两个段：
代码段：该段中所包含的主要是程序的指令。该段一般是可读和可执行的，但一般却不可写。
数据段：主要存放程序中要用到的各种全局变量或静态的数据。一般数据段都是可读，可写，可执行的。
UNIX环境下主要有三种类型的目标文件：
(1)可重定位文件
其中包含有适合于其它目标文件链接来创建一个可执行的或者共享的目标文件的代码和数据。
(2)共享的目标文件
这种文件存放了适合于在两种上下文里链接的代码和数据。
第一种是链接程序可把它与其它可重定位文件及共享的目标文件一起处理来创建另一个目标文件；
第二种是动态链接程序将它与另一个可执行文件及其它的共享目标文件结合到一起，创建一个进程映象。
(3)可执行文件
它包含了一个可以被操作系统创建一个进程来执行之的文件。汇编程序生成的实际上是第一种类型的目标文件。对于后两种还需要其他的一些处理方能得到，这个就是链接程序的工作了。
二、链接过程
由汇编程序生成的目标文件并不能立即就被执行，其中可能还有许多没有解决的问题。
例如，某个源文件中的函数可能引用了另一个源文件中定义的某个符号(如变量或者函数调用等)；在程序中可能调用了某个库文件中的函数，等等。所有的这些问题，都需要经链接程序的处理方能得以解决。
链接程序的主要工作就是将有关的目标文件彼此相连接，也即将在一个文件中引用的符号同该符号在另外一个文件中的定义连接起来，使得所有的这些目标文件成为一个能够被操作系统装入执行的统一整体。
根据开发人员指定的同库函数的链接方式的不同，链接处理可分为两种：
(1)静态链接
在这种链接方式下，函数的代码将从其所在地静态链接库中被拷贝到最终的可执行程序中。这样该程序在被执行时这些代码将被装入到该进程的虚拟地址空间中。静态链接库实际上是一个目标文件的集合，其中的每个文件含有库中的一个或者一组相关函数的代码。
(2) 动态链接
在此种方式下，函数的代码被放到称作是动态链接库或共享对象的某个目标文件中。链接程序此时所作的只是在最终的可执行程序中记录下共享对象的名字以及其它少量的登记信息。在此可执行文件被执行时，动态链接库的全部内容将被映射到运行时相应进程的虚地址空间。动态链接程序将根据可执行程序中记录的信息找到相应的函数代码。
对于可执行文件中的函数调用，可分别采用动态链接或静态链接的方法。使用动态链接能够使最终的可执行文件比较短小，并且当共享对象被多个进程使用时能节约一些内存，因为在内存中只需要保存一份此共享对象的代码。但并不是使用动态链接就一定比使用静态链接要优越。在某些情况下动态链接可能带来一些性能上损害。
我们在linux使用的gcc编译器便是把以上的几个过程进行捆绑，使用户只使用一次命令就把编译工作完成，这的确方便了编译工作，但对于初学者了解编译过程就很不利了，下图便是gcc代理的编译过程：

从上图可以看到：
预编译
将.c 文件转化成 .i文件
使用的gcc命令是：gcc –E
对应于预处理命令cpp
编译
将.c/.h文件转换成.s文件
使用的gcc命令是：gcc –S
对应于编译命令 cc –S
汇编
将.s 文件转化成 .o文件
使用的gcc 命令是：gcc –c
对应于汇编命令是 as
链接
将.o文件转化成可执行程序
使用的gcc 命令是： gcc
对应于链接命令是 ld
总结起来编译过程就上面的四个过程：预编译、编译、汇编、链接。了解这四个过程中所做的工作，对我们理解头文件、库等的工作过程是有帮助的，而且清楚的了解编译链接过程还对我们在编程时定位错误，以及编程时尽量调动编译器的检测错误会有很大的帮助的。
是否可以解决您的问题？

广度优先搜索C语言算法

广度优先搜索算法，是按层遍历各个结点，以求出最短或最优的解，
常用于计算路径的最短距离，和最佳通路。
例如：迷宫的最短路径计算，推箱子的移动最小步数等小游戏，都是按广度搜索来进行的。
这个算法是教程中很经典的，有很多例子和代码。你可以好好研究！
如下是一段迷宫的最佳路径求解算法。
#include
const int dx={-1,0,1,0};
const int dy={0,1,0,-1};
int maze;
int que;
int qn;
void print(int x,int y)
{
if(prev!=-2)
{
print(prev&7);
}
printf("(%d, %d)\n",x,y);
}
int main()
{
int i,j,cx,cy,nx,ny;
for(i=0;i《5;i++)
{
for(j=0;j《5;j++)
{
scanf("%d",&maze);
}
}
memset(prev,-1,sizeof(prev));
prev=-2;
que=0;
qn=1;
for(i=0;i《qn;i++)
{
cx=que》》3;
cy=que&7;
for(j=0;j《4;j++)
{
nx=cx+dx;
ny=cy+dy;
if((nx》=0)&&(nx=0)&&(ny《5)&&(maze==-1))
{
prev=(cx《《3)|cy;
que=(nx《《3)|ny;
if((nx==4)&&(ny==4))
{
print(nx,ny);
return 0;
}
}
}
}
return 0;
}