跪求老鼠走迷宫游戏，必须用C++编写，用栈来实现，因为是数据结构课程设计所以只要现成代码，越快越好。

Question

【设计题目】

走迷宫游戏
说明：程序开始运行时显示一个迷宫地图，迷宫中央有一只老鼠，迷宫的右下方有一个粮仓。游戏的任务是使用键盘上的方向键操纵老鼠在规定的时间内走到粮仓处。
【问题描述和基本要求】

老鼠形象可辨认，可用键盘操纵老鼠上下左右移动；
1、 迷宫的墙足够结实，老鼠不能穿墙而过；
2、 正确检测结果，若老鼠在规定时间内走到粮仓处，提示成功，否则提示失败；
3、 添加编辑迷宫功能，可修改当前迷宫，修改内容：墙变路、路变墙；
4、找出走出迷宫的所有路径，以及最短路径。

注意：必须用C++编写，网上大量的代码都是C，老师说不行，还有就是必须用“栈”实现，其他要求就是上面的说明，要是哪位大神或贵人之前做过或会做就在最好能在今天晚上回复我并把代码发至我的邮箱：[email protected]，最迟明天中午，跪求大神相助，之后必有重谢！！！！！！！

Answer 1

#include "stdafx.h"

#include <stack>

using namespace std;

const int rows = 8,cols = 8;

HINSTANCE hInst;

HBITMAP ball;

HDC hdc,mdc,bufdc;

HWND hWnd;

DWORD tPre,tNow;

char *str;

int nowPos,prePos;

bool find;

stack<int> path;

int mapIndex[rows*cols] = { 0,2,0,0,0,0,0,0,   //材1&#59049;

0,1,0,1,1,1,1,0,   //材2&#59049;

0,1,0,1,0,1,1,0,   //材3&#59049;

0,1,0,0,0,1,1,0,   //材4&#59049;

0,1,1,1,1,1,1,0,   //材5&#59049;

0,1,0,0,0,0,1,0,   //材6&#59049;

0,0,1,1,1,1,1,0,   //材7&#59049;

0,0,0,0,0,0,3,0 }; //材8&#59049;

int  record[rows*cols];

ATOM MyRegisterClass(HINSTANCE hInstance);

BOOL InitInstance(HINSTANCE, int);

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

void MyPaint(HDC hdc);

int APIENTRY WinMain(HINSTANCE hInstance,

                     HINSTANCE hPrevInstance,

                     LPSTR     lpCmdLine,

                     int       nCmdShow)

{

MSG msg;

MyRegisterClass(hInstance);

if (!InitInstance (hInstance, nCmdShow)) 

{

return FALSE;

}

    while( msg.message!=WM_QUIT )

    {

        if( PeekMessage( &msg, NULL, 0,0 ,PM_REMOVE) )

        {

            TranslateMessage( &msg );

            DispatchMessage( &msg );

        }

else

{

tNow = GetTickCount();

if(tNow-tPre >= 100)

MyPaint(hdc);

}

    }

return msg.wParam;

}

//****注册窗口*************************

ATOM MyRegisterClass(HINSTANCE hInstance)

{

WNDCLASSEX wcex;

wcex.cbSize = sizeof(WNDCLASSEX); 

wcex.style = CS_HREDRAW | CS_VREDRAW;

wcex.lpfnWndProc = (WNDPROC)WndProc;

wcex.cbClsExtra = 0;

wcex.cbWndExtra = 0;

wcex.hInstance = hInstance;

wcex.hIcon = NULL;

wcex.hCursor = NULL;

wcex.hCursor = LoadCursor(NULL, IDC_ARROW);

wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);

wcex.lpszMenuName = NULL;

wcex.lpszClassName = "canvas";

wcex.hIconSm = NULL;

return RegisterClassEx(&wcex);

}

//****初始化*************************************

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)

{

HBITMAP bmp;

hInst = hInstance;

hWnd = CreateWindow("canvas", "迷宫" , WS_OVERLAPPEDWINDOW,

CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

if (!hWnd)

{

return FALSE;

}

MoveWindow(hWnd,10,10,430,450,true);

ShowWindow(hWnd, nCmdShow);

UpdateWindow(hWnd);

hdc = GetDC(hWnd);

mdc = CreateCompatibleDC(hdc);

bufdc = CreateCompatibleDC(hdc);

bmp = CreateCompatibleBitmap(hdc,cols*50,rows*50);

SelectObject(mdc,bmp);

HBITMAP tile;

int rowNum,colNum;

int i,x,y;

tile = (HBITMAP)LoadImage(NULL,"tile.bmp",IMAGE_BITMAP,50,50,LR_LOADFROMFILE);

ball = (HBITMAP)LoadImage(NULL,"ball.bmp",IMAGE_BITMAP,50,50,LR_LOADFROMFILE);

for (i=0;i<rows*cols;i++)

{

record[i] = mapIndex[i];

rowNum = i / cols;

colNum = i % cols;

x = colNum * 50;

y = rowNum * 50;

SelectObject(bufdc,tile);

if(!mapIndex[i])

BitBlt(mdc,x,y,50,50,bufdc,0,0,SRCCOPY);

else

{

  if(mapIndex[i] == 2)

{

nowPos = i;

path.push(i);

record[i] = 0;

}

BitBlt(mdc,x,y,50,50,bufdc,0,0,WHITENESS);

}

}

prePos = cols * rows + 1;

MyPaint(hdc);

return TRUE;

}

//****核心代码*********************************

void MyPaint(HDC hdc)

{

int rowNum,colNum;

int x,y;

int up,down,left,right;

rowNum = prePos / cols;

colNum = prePos % cols;

x = colNum * 50;

y = rowNum * 50;

SelectObject(bufdc,ball);

BitBlt(mdc,x,y,50,50,bufdc,0,0, WHITENESS);

rowNum = nowPos / cols;

colNum = nowPos % cols;

x = colNum * 50;

y = rowNum * 50;

SelectObject(bufdc,ball);

BitBlt(mdc,x,y,50,50,bufdc,0,0, SRCCOPY);

if(!find)

{

str = "迷宫入口";

up    = nowPos - cols;

down  = nowPos + cols;

left  = nowPos - 1;

right = nowPos + 1;

if(up>=0 && record[up])

{

path.push(up);

record[up] = 0;

prePos = nowPos;

nowPos = up;

        if(mapIndex[nowPos] == 3)

find = true;

}

else if(down<=cols*rows-1 && record[down]) 

{

path.push(down);

record[down] = 0;

prePos = nowPos;

nowPos = down;

if(mapIndex[nowPos] == 3)

find = true;

}

else if(left>=rowNum*cols && record[left])  

{

path.push(left);

record[left] = 0;

prePos = nowPos;

nowPos = left;

if(mapIndex[nowPos] == 3)

find = true;

}

else if(right<=(rowNum+1)*cols-1 && record[right])  

{

path.push(right);

record[right] = 0;

prePos = nowPos;

nowPos = right;

if(mapIndex[nowPos] == 3)

find = true;

}

else

{

if(path.size() <= 1) //&#59076;&#59343;&#58864;&#58892;

str = "xxxxx";

else

{

path.pop();

prePos = nowPos;

nowPos = path.top();

}

}

}

else

{

str = "找到出口";

}

TextOut(mdc,0,0,str,strlen(str));

BitBlt(hdc,10,10,cols*50,rows*50,mdc,0,0,SRCCOPY);

tPre = GetTickCount();

}

//****消息函数***********************************

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

switch (message)

{

case WM_KEYDOWN:

if(wParam==VK_ESCAPE)

PostQuitMessage(0);

break;

case WM_DESTROY:

DeleteDC(mdc);

DeleteDC(bufdc);

DeleteObject(ball);

ReleaseDC(hWnd,hdc);

PostQuitMessage(0);

break;

default:

return DefWindowProc(hWnd, message, wParam, lParam);

   }

   return 0;

}

//  可以运行   请采纳   

有不懂的可以联系我

这个可是标准c++的   这是结果

这是源代码 

追问

这个用的是MFC吗？我用的是VC++6.0，既然整成Windows程序也可以。但说好的老鼠和谷仓在哪里呢？貌似没有ctime.h函数，没有时间限定啊，这个能实现墙变路、路变墙的变换吗？找出最短路径数据结构里的内容，这个程序能实现吗？希望你能帮我找个简单一点的。

关键我们没学过Windows编程，我还是希望你帮我做个传统DOS界面黑框的，就是用VC++6.0新建Win32 Console Application，只要用*号表示就行！要符合上面要求，这个题在网上完全相同的有好多，但都不行，希望你能参照http://www.pudn.com/downloads22/sourcecode/windows/detail71822.html上面的代码。

追答

图形界面多好啊 dos 界面每移动一步 你还的重新输出 还的写钩子函数响应键盘消息
同学你真是为难人啊 真没弄过这程序

Answer 2

当你进入地图：1表示无法通行，0代表差强人意，自动增加边框（墙），网格的左侧和左上角到右下角的右侧的一个网格入口出口
编译的代码如下：
 
＃包括 
＃包括 
＃N 50 
 
数组的迷宫; 
诠释行; 
整数关口; 
 
 int的堆栈[50] ;/ /堆栈
 
无效CreateMaze存储路径（）/ /动态创建的迷宫
 {
 INT I，J; 
 printf的（“请输入的迷宫的行数：”）; <BR / scanf函数（“％d”，＆行）; 
 
 printf的（“请输入迷宫的列数：”）; 
 scanf的（“％d”，＆COL） 
 
（行<= 0 | | COL <= 0）
 {
 printf的（“请输入行或列的数量是不符合规则的！ \ n“）; 
出口（1）; 
} 
 
 / /动态地创建一个二维数组的指针的指针
迷宫=（INT *）malloc的（（2行）*表示sizeof（int *））; 
为（i = 0;我行+2，我+ +）
 {
迷宫[ ] =（*）malloc的（（山坳+2）*表示sizeof（int））; 
} 
 / /添加侧壁
（i = 0;我行+2;我+ +）
 
 {
迷宫[I] [0] = 1; 
迷宫[I] [COL +1] = 1; 
} <BR / （i = 0; <山坳+2;我+ +）
 {
（== 1）
 {
迷宫[0] [] = 0; 
} 
其他迷宫[0] [I] = 1; 
（== COL）
 {
迷宫[行+1] [COL ] = 0; 
} 
其他迷宫行+1]在[i] = 1; 
} 
 
（i = 1; <=行; + +）
 {
 
为（J = 1; <=山坳; + +）
 {
 printf（“请输入第％d行％d号：\ n“，I，J）; 
 scanf的（”％d“，＆迷宫[I] [J]）; 
} 
 
}  BR /> 
 / /输入电流和侧壁的迷宫，以验证输入的是正确
 printf的（“请输入完毕！电流和侧壁的迷宫：\ n”）; />（i = 0;我行+2，我+ +）
 {
为（J = 0，J <山坳+2; J + +）
 { />输出（“％d”，迷宫[I] [J]）; 
} 
 printf的（“\ n”）; 
} 
} 
  BR />的无效ShowMaze（）/ /输出迷宫
 {
 INT I，J; 
（i = 1; <=行，我+ +）
 { BR />（J = 1; <=山坳; + +）
 {
 printf的（“％d”，迷宫[I] [J]）; 
} 
 printf（“请\ n”）; 
} 
} 
 
 / /释放的迷宫阵列
无效DestroyMaze（）
 {
 >; 
为（i = 0;我行+2，我+ +）
（迷宫[I]）; 
免费（迷宫）; 
} 
 
 / /的DFS方法来实现回溯找到迷宫路径的解决方案
 
 FindPath（）
 {
 INT I，J，K ，计数，X，Y，方向; 
 
计数= 0; 
 X = 1，Y = 1; 
方向= 0; 
 J = 0，K表= 0; 
 
为（i = 0; <N; + +）
 {
堆栈[I] = 0; 
} 
 i = 0; 
（1）
 {
计数= 0 ;/ /计算，以确定是否有很长的路要走
 {
（X = 
迷宫= 1 && Y == 1）[X] [Y] = 2; 
（迷宫[X] [Y +1] == 0）/ /东
 { 
计数+ +; 
迷宫[X] [Y +1] = 2; 
 Y = Y +1; 
栈[我] = -1; 
 i + +; 
（X =行&& Y == COL）
返回1; 
} 
其他（迷宫[+1] [Y] == 0）/ /南
 {
（迷宫[+1] [Y] == 0）
计数+ +; 
 {
迷宫[X + 1] [Y] = 2; 
 X = X +1; 
栈[I] = -2; 
我+ +; 
（X =行&&? == COL）返回1 
 
} 
} 
其他（迷宫[X] [Y-1] == 0）/ /西
 { BR />数+ +; 
（迷宫[X] [Y-1] == 0）
 {
迷宫[X] [Y-1] = 2; 
 > Y = Y-1; 
栈[I] = -3; 
 + +; 
（X =行&& Y == COL）
返回1; 
} 
} 
其他（迷宫[-1] [Y] == 0）/ /北
 {
数+ +; 
如果（迷宫〔x-1] [Y] == 0）
 {
迷宫〔x-1] [] = 2; 
 = x-1的; 
栈[我] = -4; 
 + +; 
（X =行&& Y == COL）返回1 
 
} 
}  BR />} 
（数== 0）
 {
（<0）
返回0; 
方向=堆栈[ - ]; BR />开关（方向）
 {
情况下，-1：Y = Y-1;突破; 
情况下，-2：X = X-1;突破; 
情况下 - 3：Y = Y +1;突破; 
情况下-4：X = X +1;突破; 
默认值：打破; 
} 
} 
}  BR />} 
 
廉政的main（）
 {
 CreateMaze（）; 
（FindPath（））
 
 { BR /> printf的（“已找到了一条路径，如下所示：\ n”）; 
 ShowMaze（）; 
} 
其他
 {
 printf的（“不在正确的道路上走出迷宫！\ n“）; 
 
}} 
 DestroyMaze（）;
 //没啥区别 把printf改成cout scanf改成cin

追问

乱七八糟的，你学过C++和数据结构吗，麻烦问一句你到百度上搜过了吗？？？

追答

帮你找到 不行也别喷我 一片好意 谢谢

Answer 3

#include <stdio.h>
#include <iostream>
#include <conio.h>
#include <windows.h>
#include <time.h>
using namespace std;
#define Height 25//高度，必须为奇数
#define Width 25 //宽度，必须为奇数
#define Wall 1 //用1表示墙
#define Road 0 //用0表示路
#define Start 2
#define End 3
#define up 72
#define down 80
#define left 75
#define right 78
#define flag 5
int map[Height+2][Width+2];
int x=2,y=1; //玩家当前位置，刚开始在入口处

class Migong
{
public:
void gotoxy(int x,int y); //移动坐标的函数声明
void shengcheng(int x,int y); //随机生成迷宫的函数声明
void display(int x,int y); //显示迷宫的函数声明
void chushi(); //初始化迷宫的函数声明
};

class Wanjia:public Migong //玩家类由迷宫类派生来
{
public:

void gonglue(int x,int y);
void shang(int x,int y);
void xia(int x,int y);
void zuo(int x,int y);
void you(int x,int y);
void game(); //游戏运行包括移动的函数声明
};

void Migong::gotoxy(int x,int y) //移动坐标 这是使光标 到（x，y）这个位置的函数.调用 COORD 需要#include.
{
COORD coord;
coord.X=x;
coord.Y=y;
SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord );
}

void Migong::shengcheng(int x,int y) //随机生成迷宫
{
int c[4][2]={0,1,1,0,0,-1,-1,0}; //四个方向 //数组c 0 1 向右
// 1 0 向下
// -1 0 向上
// 0 -1 向左

int i,j,t;
//将方向打乱
for(i=0;i<4;i++)
{
j=rand()%4; //随机生成j
t=c[i][0];c[i][0]=c[j][0];c[j][0]=t; //将c[i][0]和c[j][0]交换
t=c[i][1];c[i][1]=c[j][1];c[j][1]=t; //类似上
}
map[x][y]=Road; //当前位置设为路
for(i=0;i<4;i++) //沿四个方向设置
if(map[x+2*c[i][0]][y+2*c[i][1]]==Wall) //沿c[i][0]、c[i][1]方向前2步如果是墙
{
map[x+c[i][0]][y+c[i][1]]=Road; //让该方向前一步设为路
shengcheng(x+2*c[i][0],y+2*c[i][1]); //在该方向前两步继续生成地图 因为这里是递归函数，当执行到最后一点发现都不能走的时候，
//会返回到上一个函数，也就是上一个点，再次判断是否可以产生地图 ，知道地图上所有点被遍历完。
}
}
void Migong::display(int x,int y) //显示迷宫
{
gotoxy(2*y-2,x-1);
switch(map[x][y])
{
case Start:
cout<<"入";break; //显示入口
case End:
cout<<"出";break; //显示出口
case Wall:
cout<<"■";break; //显示墙
case Road:
cout<<" ";break; //显示路
case up:
cout<<"↑";break; //在攻略中的标记 下同
case down:
cout<<"↓";break;
case left:
cout<<"←";break;
case right:
cout<<"→";break;
case flag:
cout<<" ";break; //标记，防止攻略遍历时候无线循环
}
}

void Migong::chushi()
{
int i,j;
srand((unsigned)time(NULL)); //初始化随机种子
for(i=0;i<=Height+1;i++)
for(j=0;j<=Width+1;j++)
if(i==0||i==Height+1||j==0||j==Width+1) //初始化迷宫 默认四周是路
map[i][j]=Road;
else map[i][j]=Wall;
shengcheng(2*(rand()%(Height/2)+1),2*(rand()%(Width/2)+1)); //从随机一个点开始生成迷宫，该点行列都为偶数
for(i=0;i<=Height+1;i++) //边界处理 把最开始默认为路的堵上,以免跑出迷宫
{
map[i][0]=Wall;
map[i][Width+1]=Wall;
}
for(j=0;j<=Width+1;j++) //边界处理
{
map[0][j]=Wall;
map[Height+1][j]=Wall;
}
map[2][1]=Start; //给定入口
map[Height-1][Width]=End; //给定出口
for(i=1;i<=Height;i++) //i初始为1,结束为height,以免画出外围
for(j=1;j<=Width;j++) //画出迷宫 同上
display(i,j);
}

void Wanjia::game()
{
int x=2,y=1; //玩家当前位置，刚开始在入口处
int c; //用来接收按键
while(1)
{
gotoxy(2*y-2,x-1);
cout<<"☆"; //画出玩家当前位置
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(30,24); //到达此坐标
cout<<"到达终点，按任意键结束";

getch();
break;
c=getch();
}
if(c!=-32)
{
c=getch();
switch(c)
{
case 72: //向上走
if(map[x-1][y]!=Wall)
{
display(x,y);
x--;

}
break;
case 80: //向下走
if(map[x+1][y]!=Wall)
{
display(x,y);
x++;

}
break;
case 75: //向左走
if(map[x][y-1]!=Wall)
{
display(x,y);
y--;

}
break;
case 77: //向右走
if(map[x][y+1]!=Wall)
{

display(x,y);
y++;

}
break;
case 112: //按下P
gonglue(2,1);break; //如果按下P执行攻略函数
}
}
}
}
void Wanjia::shang(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout<<"到达终点，按任意键结束";

getch();
exit(0);
}
if(map[x-1][y]!=Wall&&map[x-1][y]!=up&&map[x-1][y]!=down&&map[x-1][y]!=left&&map[x-1][y]!=right&&map[x-1][y]!=flag)
{ //当移动后的下一个位置没有被走过且不是墙

map[x][y]=up;
display(x,y);
x--;
gonglue(x,y); //递归，攻略下一个点
}
}
void Wanjia::xia(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout<<"到达终点，按任意键结束";

getch();
exit(0);
}
if(map[x+1][y]!=Wall&&map[x+1][y]!=up&&map[x+1][y]!=down&&map[x+1][y]!=left&&map[x+1][y]!=right&&map[x+1][y]!=flag) //当移动后的下一个位置没有被走过且不是墙
{

map[x][y]=down;
display(x,y);
x++;
gonglue(x,y); //递归，攻略下一个点
}
}
void Wanjia::zuo(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout<<"到达终点，按任意键结束";
getch();
exit(0);
}
if(map[x][y-1]!=Wall&&map[x][y-1]!=up&&map[x][y-1]!=down&&map[x][y-1]!=left&&map[x][y-1]!=right&&map[x][y-1]!=flag) //当移动后的下一个位置没有被走过且不是墙
{

map[x][y]=left;
display(x,y);
y--;

gonglue(x,y); //递归，攻略下一个点
}
}
void Wanjia::you(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout<<"到达终点，按任意键结束";
getch();
exit(0);
}
if(map[x][y+1]!=Wall&&map[x][y+1]!=up&&map[x][y+1]!=down&&map[x][y+1]!=left&&map[x][y+1]!=right&&map[x][y+1]!=flag) //当移动后的下一个位置没有被走过且不是墙
{

map[x][y]=right;
display(x,y);
y++;
gonglue(x,y); //递归，攻略下一个点
}
}
void Wanjia::gonglue (int x,int y)
{
gotoxy(2*y-2,x-1);
cout<<"☆"; //画出玩家当前位置
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout<<"到达终点，按任意键结束";
getch();
exit(0);
}
shang(x,y); //上下左右
xia(x,y);
zuo(x,y);
you(x,y);
map[x][y]=flag; //当上下左右都无法走的时候，即为死路，因为递归函数开始向后，所以讲死路点值置为flag，变成无形之墙。
display(x,y);
}

int main()
{
cout<<" 移动迷宫 "<<endl;
cout<<"--------------------"<<endl;
cout<<"欢迎来到移动迷宫游戏"<<endl;
cout<<"--------------------"<<endl;
cout<<"游戏说明：给定一出口和入口"<<endl;
cout<<"玩家控制一个五角星（☆）从入口走到出口"<<endl;
cout<<"系统会记录你所走的步数"<<endl;
cout<<"按回车进入游戏";
cout<<"(按下P键可以获得攻略。)";
getch();
system("cls"); //清屏函数 ，清除开始界面
Wanjia w1;
w1.chushi();
w1.game(); //开始游戏
// w1.gonglue(2,1); //功略显示
getch();
return 0;
}

————————————————
版权声明：本文为CSDN博主「失落之风」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41572774/java/article/details/84035598
对不起，本人能力有限，希望大家能支持