c++10oop实现迷宫（未完）

1.思路

/*
用OOP完成迷宫路径的寻找问题，软件运行要求如下：
请输入迷宫的行列数： 5 5
请输入迷宫路径节点信息（1表示不能走，0表示能走）
0 0 1 0 1
0 0 1 0 0
1 0 0 1 0
0 1 0 0 0
开始寻找迷宫路径（从左上角到右下角的一个可通行的路径）:
迷宫不存在可通行的路径
。。 1 0 1
0 。1 0 0
1 。。 1 0
0 1 。。。

const int WAY_CNT = 4;   // 总的方向数目
const int WAY_RIGHT = 0;
const int WAY_DOWN = 1;
const int WAY_LEFT = 2;
const int WAY_UP = 3;
const int CSEQTACKSIZE=5;//eqtack
const int WAY_STATE_OK = 5; // 路径方向可以行走
const int WAY_STATE_ERR = 6;  // 路径方向不能行走

class MazeNode  // 迷宫节点类型
{
public :
	//MazeNode(int v=10,int x=1,int y=2,int s=3 );
	void setval(int val){_val=val;}
	void setX(int x){_x=x;}
	void setY(int y){_y=y;}
	/*void setWaystate(int way, int state)
	{
		_state[way] = state; 
	}*/
	int getval(){return _val;}
	int getX(){return _x;}
	int getY(){return _y;}
	void changeWaystate(int direction,int state )
	{
		_state[direction]=state;
	}
	int getstate(int direction){return _state[direction];}

private:
	int _val;
	int _x;
	int _y;
	int _state[WAY_CNT];
};
class CSeqtack  // 栈类型
{
public:
	CSeqtack(int size=10)
	{
		_top=0;
		_size=size;
		_stack=new MazeNode[_size*_size];
	}
	bool full(){return _top==_size;}
	bool empty(){return _top ==0;}
	void push(const MazeNode &node)//入栈
	{
		if(full())
		{
			MazeNode*ptmp=new MazeNode[(_size +1)*(_size +1)];//扩容
			for(int i=0;i<_size ;i++)
			{
				ptmp [i]=_stack [i];
			}
			delete []_stack ;
			_stack =ptmp ;
			_size =(_size +1)*(_size +1);
		}
		_stack [_top++]=node ;
	}
	void pop()//出栈
	{
		if(empty())
		{
			cout<<"栈空了"<<endl;
		}
		--_top;
	}
	MazeNode top()
	{
		return _stack [_top-1];
	}

private:
	MazeNode *_stack;
	int _top;
	int _size;
	CSeqtack(const CSeqtack&);
	CSeqtack& operator=(const CSeqtack&);
};
class Maze  // 迷宫类型
{
public:
	Maze(int r = 10, int c = 10):_row(r),_col (c)
	{
		_pMazes =new MazeNode *[_row ];
		for(int i=0;i<_row;i++)
		{
			_pMazes[i] =new MazeNode [_col ];
		}
	}
	void initMazeNode(int x,int y,int val)//初始化节点信息
	{
		_pMazes[x][y].setX(x);
		_pMazes[x][y].setY(y);
		_pMazes[x][y].setval(val);
		for (int i = 0; i < WAY_CNT; ++i)
		{
			_pMazes[x][y].changeWaystate(i, WAY_STATE_OK);
		}
	}
	//int getval(){return _pMazes}
	void adjustMazeNode()
	{
		for(int i=0;i<_row;++i)
		{
			for(int j=0;j<_col;++j)
			{
				if (_pMazes[i][j].getval() == 1)
					continue;
				if(i==0)//上边不能走
				{
					_pMazes [i][j].changeWaystate (WAY_UP,WAY_STATE_ERR);
				}
				if(j==0)//左边不能走
				{
					_pMazes [i][j].changeWaystate (WAY_LEFT ,WAY_STATE_ERR);
				}
				if(i==_row-1)//下面不能走
				{
					_pMazes [i][j].changeWaystate (WAY_DOWN,WAY_STATE_ERR);
				}
				if(j==_col-1)//右边不能走
				{
					_pMazes [i][j].changeWaystate (WAY_RIGHT,WAY_STATE_ERR);
				}
				if(j<_col-1&&_pMazes [i][j+1].getval() ==1)//看右边是不是1  [i][j+1]  j<col
				{
					_pMazes [i][j+1].changeWaystate (WAY_RIGHT,WAY_STATE_ERR);
				}
				if(i>0&&_pMazes[i-1][j].getval()==1)//看上边是不是为1  [i-1][j]  i>0
				{
					_pMazes[i-1][j].changeWaystate (WAY_UP ,WAY_STATE_ERR);
				}
				if(j>0&&_pMazes[i][j-1].getval()==1)//看左边是不是为1 [i][j-1]   j>0
				{
					_pMazes[i][j-1].changeWaystate (WAY_LEFT  ,WAY_STATE_ERR);
				}
				if(i<_row-1 &&_pMazes[i+1][j].getval()==1)//看下面是不是为1[i+1][j]   i<row
				{
					_pMazes[i+1][j].changeWaystate (WAY_DOWN,WAY_STATE_ERR);
				}
			}
		}
	}
	void findMazePath()//寻找路径
	{
		if (_pMazes[0][0].getval() == 1)
		{
			return;
		}
		_stack.push(_pMazes[0][0]);
 		
		while(!_stack .empty ())
		{
			MazeNode node = _stack.top();
			int i = node.getX();
			int j = node.getY();

			//MazeNode top=_stack .top();
			
			/*int x = node.getX();
			int y = node.getY();
			if (x == _row - 1 && y == _col - 1)
			{
				return;
			}*/
			if (i == _row - 1 && j == _col - 1)
			{
				return;
			}
					
					if(/*j>0&&*/node.getstate (WAY_LEFT)==WAY_STATE_OK)//左边可以走
					{
						
						_pMazes[i][j].changeWaystate (WAY_LEFT ,WAY_STATE_ERR);
						//_pMazes[i][j].setval ('*');
						_pMazes[i][j-1].changeWaystate (WAY_RIGHT ,WAY_STATE_ERR);
						_stack .push (_pMazes[i][j-1]);
						continue;
						//j=j-1;
					}
					if(/*i<_col&&*/node.getstate(WAY_DOWN)==WAY_STATE_OK)//下边可以走)
					{
						
						//_pMazes[i][j].setval ('*');
						_pMazes[i][j].changeWaystate (WAY_DOWN  ,WAY_STATE_ERR);
						_pMazes[i+1][j].changeWaystate (WAY_UP ,WAY_STATE_ERR);
						_stack .push (_pMazes[i+1][j]);
						continue;
						//i+=1;
					}
					if(/*j<_col-1&&*/node.getstate (WAY_RIGHT)==WAY_STATE_OK)//右边可以走	
					{
						
						_pMazes[i][j].changeWaystate(WAY_RIGHT ,WAY_STATE_ERR);//我的右边不能走
						_pMazes[i][j+1].changeWaystate(WAY_LEFT ,WAY_STATE_ERR);
						//_pMazes[i][j].setval('*');
						_stack.push(_pMazes[i][j+1]);//往右走
						continue;
						
					}
					if(/*i>0&&*/node.getstate(WAY_UP)==WAY_STATE_OK)//上边可以走
					{
						
						//_pMazes[i][j].setval ('*');
						_pMazes[i][j].changeWaystate (WAY_UP  ,WAY_STATE_ERR);
						_pMazes[i-1][j].changeWaystate (WAY_DOWN ,WAY_STATE_ERR);
						continue;
						_stack .push (_pMazes[i-1][j]);
						//i-=1;
					}
					else
					{
						continue;
					}
				
			//_stack.pop();
		}
	}
	void showMazePath()
	{
		if(_stack .empty ())
		{
			cout<<"迷宫不存在可通行的路径"<<endl;
			return;
		}
		while (!_stack.empty())
		{
			MazeNode top = _stack.top();
			_pMazes[top.getX()][top.getY()].setval('*');
			_stack.pop();
		}
		for (int i = 0; i < _row; ++i)
		{
			for (int j = 0; j < _col; ++j)
			{
				if (_pMazes[i][j].getval() == '*')
				{
					cout << "*" << " ";
				}
				else
				{
					cout << _pMazes[i][j].getval() << " ";
				}
			}
			cout<<endl;
		}
	}
private:
	int _row;
	int _col;
	MazeNode **_pMazes;
	CSeqtack _stack;
};
int main()
{
	cout << "请输入迷宫的行列数:";
	int row, col;
	cin >> row >> col;

	Maze maze(row, col);

	cout << "请输入迷宫路径节点信息（1表示不能走，0表示能走）:" << endl;
	for (int i = 0; i < row; ++i)
	{
		for (int j = 0; j < col; ++j)
		{
			int data;
			cin >> data;
			// data i, j
			maze.initMazeNode(i, j,data);
		}
	}
	// 调整迷宫节点方向的行走状态
	maze.adjustMazeNode();
	//maze.showMazePath();
	//cout<<endl;
	// 开始寻找迷宫路径
	maze.findMazePath();
	//maze.showMazePath();
	//cout<<endl;
	// 打印迷宫寻找的结果
	maze.showMazePath();
	return 0;
}

迷宫数组
0 0 1 0 1
0 0 1 0 0
1 0 0 1 0
0 1 0 0 0

0 0 1 0 1
0 0 1 0 0
1 0 0 1 0
0 1 0 0 0
右下左上0123