求大神看看这段代码，我已经给跪了..
本帖最后由 linliting45 于 2013-01-03 00:46:12 编辑 代码是生成一个迷宫，大小12*12,算法自己想的。
大一初学者，代码风格什么的求指正！！

//迷宫通路用 . 表示，墙用 # 表示
//这个迷宫是封闭的，外围仅有两个出入口点
//0.初始化设置所有点为Undiscovered（不包括最外围）
//1.确定迷宫入口，并将其最接近的一个点确定为初始点。确定初始点（setEntranc
//ePointandInitialization）并将其附近（上下左右，下同）为Undiscovered状态的
//点加入Queue中,并设置为Discovered（setEntrancePointandInitialization函数中
//调用的findPointtoQueue函数）。
//2.在队列Queue中随即取一个点（getPointfromQueue），设置为Open状态，将其从
//Queue中删除。
//3.将上一个点（currentPoint)附近为Discovered的点设置为Blocked，从Queue中
//删除这些点。(setNearPointBlocked_and_ErasethemfromQueue)
//4.将3中取得的点附近为Undiscovered状态的点设置为Discovered，并加入队列中
//。（findPointtoQueue）将currentPoint设置为新取得的点。
//5.重复2~4过程，直到队列Queue中无点。
//6.确定迷宫出口，并设置最外围点为Blocked，出入口为Open。（closeMaze）
//7.结果写入名为maze的char类型数组中，并输出（finalOutput）（Block状态的
//点为墙，Open状态的为通路)
//出现错误：map/set iterator not incrementable，有时还有各种访问冲突
//，getPointfromQueue函数有极大嫌疑，但不知道哪里出错
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <set>
using namespace std;

class Maze
{
private:
struct Cood//点坐标
{
int x;
int y;
#define y_axisMinusone 0
#define y_axisPlusone 1
#define x_axisMinusone 2
#define x_axisPlusone 3
friend Cood operator+(const Cood& input,const int& axisoperator)//上下左右移动
{
Cood output;
switch (axisoperator)
{
case y_axisMinusone:
output.x=input.x;
output.y=input.y-1;
return output;
case y_axisPlusone:
output.x=input.x;
output.y=input.y+1;
return output;
case x_axisMinusone:
output.x=input.x-1;
output.y=input.y;
return output;
case x_axisPlusone:
output.x=input.x+1;
output.y=input.y;
return output;
default:
exit(EXIT_FAILURE);
break;
}
}
friend bool operator<(const Cood& input_a,const Cood& input_b)//写着玩，不写这
//个编译通不过，因为set容器需要
{
if (input_a.x*input_a.x+input_a.y*input_a.y<input_b.x*input_b.x+input_b.y*input_b.y)
{
return true;
}
else
{
return false;
}
}
};

public:
Maze();
void mazeGenerator();
private:
void setEntrancePointandInitialization();
bool getPointfromQueue(Cood& Point);
void setNearPointBlocked_and_ErasethemfromQueue();
void findPointtoQueue();
void setExitPoint();
void closeMaze();
void finalOutput();
enum _PointState {Undiscovered,Discovered,Open,Blocked};
int PointState[12][12];//点状态，可能值如上
set<Cood> Queue;//队列
set<Cood>::iterator Queue_iter;
Cood EntrancePoint;
Cood ExitPoint;
Cood currentPoint;
char maze[12][12];
};

int main()
{
srand(time(0));
Maze sample;
sample.mazeGenerator();
}

Maze::Maze()
{
for (int i=1;i!=11;++i)
{
for (int j=1;j!=11;++j)
{
PointState[i][j]=Undiscovered;
}
}
}

void Maze::mazeGenerator()
{
setEntrancePointandInitialization();
static Cood nextPoint;
for (;getPointfromQueue(nextPoint);)
{
PointState[nextPoint.x][nextPoint.y]=Open;////2.在队列Queue中随即取一个点 
 
//（getPointfromQueue），设置为Open状态，将其从Queue中删除。
Queue.erase(Queue_iter);//删除点，Queue_iter为指向nextPoint的迭代器，在
//getPointfromQueue中得到
setNearPointBlocked_and_ErasethemfromQueue();
currentPoint=nextPoint;
findPointtoQueue();
}
setExitPoint();
closeMaze();
finalOutput();
}

void Maze::setEntrancePointandInitialization()
{
switch (rand()%4)
{
case 0:
EntrancePoint.x=rand()%10+1;
EntrancePoint.y=0;
currentPoint.x=EntrancePoint.x;
currentPoint.y=1;
PointState[currentPoint.x][currentPoint.y]=Open;
break;
case 1:
EntrancePoint.x=0;
EntrancePoint.y=rand()%10+1;
currentPoint.x=1;
currentPoint.y=currentPoint.y;
PointState[currentPoint.x][currentPoint.y]=Open;
break;
case 2:
EntrancePoint.x=rand()%10+1;
EntrancePoint.y=11;
currentPoint.x=EntrancePoint.x;
currentPoint.y=10;
PointState[currentPoint.x][currentPoint.y]=Open;
break;
case 3:
EntrancePoint.x=11;
EntrancePoint.y=rand()%10+1;
currentPoint.x=10;
currentPoint.y=EntrancePoint.y;
PointState[currentPoint.x][currentPoint.y]=Open;
break;
default:
break;
}
findPointtoQueue();
}

bool Maze::getPointfromQueue(Cood& Point)
{
if (Queue.empty())
{
return false;
}
else
{
Queue_iter=Queue.begin();
for (int i=0;i!=rand()%Queue.size();++i)
{
++Queue_iter;//有极大嫌疑，但还有什么方法可以定位的？
}
Point=*Queue_iter;
return true;
}
}

void Maze::setNearPointBlocked_and_ErasethemfromQueue()
{
static Cood temp;
temp=currentPoint+y_axisMinusone;
if (temp.y>0){
if (PointState[temp.x][temp.y]!=Open){
PointState[temp.x][temp.y]=Blocked;
Queue.erase(temp);
}
}
temp=currentPoint+y_axisPlusone;
if (temp.y<11)
{
if (PointState[temp.x][temp.y]!=Open){
PointState[temp.x][temp.y]=Blocked;
Queue.erase(temp);
}
}
temp=currentPoint+x_axisMinusone;
if (temp.x>0)
{
if (PointState[temp.x][temp.y]!=Open){
PointState[temp.x][temp.y]=Blocked;
Queue.erase(temp);
}
}
temp=currentPoint+x_axisPlusone;
if (temp.x<11)
{
if (PointState[temp.x][temp.y]!=Open){
PointState[temp.x][temp.y]=Blocked;
Queue.erase(temp);
}
}
}

void Maze::findPointtoQueue()
{
static Cood temp;
temp=currentPoint+y_axisMinusone;
if (temp.y>0){
if (PointState[temp.x][temp.y]==Undiscovered)
{
PointState[temp.x][temp.y]=Discovered;
Queue.insert(temp);
}
}
temp=currentPoint+y_axisPlusone;
if (temp.y<11)
{
if (PointState[temp.x][temp.y]==Undiscovered)
{
PointState[temp.x][temp.y]=Discovered;
Queue.insert(temp);
}
}
temp=currentPoint+x_axisMinusone;
if (temp.x>0)
{
if (PointState[temp.x][temp.y]==Undiscovered)
{
PointState[temp.x][temp.y]=Discovered;
Queue.insert(temp);
}
}
temp=currentPoint+x_axisPlusone;
if (temp.x<11)
{
if (PointState[temp.x][temp.y]==Undiscovered)
{
PointState[temp.x][temp.y]=Discovered;
Queue.insert(temp);
}
}
}

void Maze::setExitPoint()
{
static Cood temp;
switch (rand()%4)
{
case 0:
ExitPoint.x=rand()%10+1;
ExitPoint.y=0; 
 
temp=ExitPoint+y_axisPlusone;
if (PointState[temp.x][temp.y]==Blocked)
{
if (ExitPoint.x==10)
{
--ExitPoint.x;
}
else
{
++ExitPoint.x;
}
}
break;
case 1:
ExitPoint.x=0;
ExitPoint.y=rand()%10+1;
temp=ExitPoint+x_axisPlusone;
if (PointState[temp.x][temp.y]==Blocked)
{
if (ExitPoint.y==10)
{
--ExitPoint.y;
}
else
{
++ExitPoint.y;
}
}
break;
case 2:
ExitPoint.x=rand()%10+1;
ExitPoint.y=11;
temp=ExitPoint+y_axisMinusone;
if (PointState[temp.x][temp.y]==Blocked)
{
if (ExitPoint.x==10)
{
--ExitPoint.x;
}
else
{
++ExitPoint.x;
}
}
break;
case 3:
ExitPoint.x=11;
ExitPoint.y=rand()%10+1;
temp=ExitPoint+x_axisMinusone;
if (PointState[temp.x][temp.y]==Blocked)
{
if (ExitPoint.y==10)
{
--ExitPoint.y;
}
else
{
++ExitPoint.y;
}
}
break;
default:
break;
}
}

void Maze::closeMaze()
{
for (int y=0;y!=12;++y)
{
PointState[0][y]=Blocked;
PointState[11][y]=Blocked;
}
for (int x=1;x!=11;++x)
{
PointState[x][0]=Blocked;
PointState[x][11]=Blocked;
}
PointState[EntrancePoint.x][EntrancePoint.y]=Open;
PointState[ExitPoint.x][ExitPoint.y]=Open;
}

void Maze::finalOutput()
{
for (int x=0;x!=12;++x)
{
for (int y=0;y!=12;++y)
{
if (PointState[x][y]==Open)
{
maze[x][y]='.';
}
else
{
maze[x][y]='#';
}
printf("%c ",maze[x][y]);
}
printf("\n");
}
}