typedef struct 
{ 
    unsigned short int doorEncoding; // Range 0..15. 
         north = doorEncoding & 0x08   // 8 = 1000 ( north position has 1)
         east  = doorEncoding & 0x04  // 4 = 0100 ( east position has 1)
         south = doorEncoding & 0x02
         west  = doorEncoding & 0x01
 
    bool      visited; 
    int         parentRow; 
    int         parentCol; 
    char      direction; // From parent. 
 
 
} MazeCell;

// Read and initialize all the cells. 
	int x = 0; 
	while(txtfile >> x)  
	{	
		for (int i = 0; i < rows; i++)
		{
			for (int j = 0; j < cols; j++)
			{
				maze[i][j].doorEncoding = x;
			}
		}
	}

void MazeCell::doorEncoding(unsigned short int x)
{
      /* Cells are maped by chars.
      1st bit maps West door
      2nd bit maps south  door
      3rd bit maps east door
      4th bit maps North  door*/
 
	//The 4 directions (North, South, East and West)
	enum {west, south, east, north};
 
	//find the state of a door (state of door will be given by "x & 0x08")
	 int north = x & 0x08;
	 int east = x & 0x04;
	 int south = x & 0x02;
	 int west = x & 0x01;
}
 
void Maze::Solve() //need help
{ 
	CellPosition c; 
	stack<CellPosition> cpos; 
	c.row = mouseRow; 
	c.col = mouseCol; 
	cpos.push(c); 
 
	maze[mouseRow][mouseCol].parentRow = -1;
	maze[mouseRow][mouseCol].parentCol = -1;
 
	bool visited = false;
	while(!cpos.empty())
	{
		while(maze[mouseRow][mouseCol] != maze[cheeseRow][cheeseCol])
		{
			if()
 
 
			visited = true;
		}
	}
	cout << "Maze has no solution" << endl;
}

Given:
 
1) a fixed maze with:
  a) defined room for mouse to start and 
  b) defined room for placement of cheese 
and
2) each room has:
  a) a flag for being visited, and
  b) 4 sides which may either be a wall or a door, and
  c) a variable to keep track of next side to look at 
     (side numbers range from 1-4, with side number set to 1 on construction),
 
then one approach using iterative style might be something like this:
 
//special case
 designate that mouse starting room has been visited 
 push mouse starting room on stack
 
//general case
while stack not empty and maze not solved
  current room will be top of stack
  //check for solution
  if current room same as cheese room
     maze solved
  else if current room side number is 5 //means no more neighbors to look in
    pop current room from stack  //go back to a prior room  
  else //look for new room
     while(current room side number is less than 5 and need new room) 
       if this side is a door
         new room is selected based on what side this is
         current room side number is incremented by 1
         if new room not visited 
            need new room is false 
            new room marked as visited
            push new room on stack      
       else
         current room side number is incremented by 1

void Maze::Solve() //need help
{ 
	The 4 sides (North, South, East and West)
	 enum {w, s, e, n};
 
	CellPosition c; 
	stack<CellPosition> cpos; 
	maze[mouseRow][mouseCol].visited = true;
	maze[mouseRow][mouseCol].parentRow = -1;
	maze[mouseRow][mouseCol].parentCol = -1;
	c.row = mouseRow; 
	c.col = mouseCol; 
	cpos.push(c); 
 
 
	bool visited = false;
	while(!cpos.empty())
	{
	//check for solution
	while(maze[mouseRow][mouseCol] != maze[cheeseRow][cheeseCol])
	{
	if(maze[mouseRow][mouseCol] == maze[cheeseRow][cheeseCol])
	{
	   c.row = mouseRow;
	   c.col = mouseCol;
	   cpos.push(c);
	   visited = true;
	   cout<< "Maze has been solved!!" << endl;
	   break;
	}
	else if (north == 8)  // does this say north = binary value(1000)?
	{
	  maze[mouseRow][mouseCol] = maze[i][j-1];
	  maze[mouseRow][mouseCol].direction = n;
	  maze[i][j-1].parentRow = maze[i];
	  maze[i][j-1].parentCol = maze[j+1];
	  c.row = mouseRow;
	  c.col = mouseCol;
	  cpos.push(c);
	if(north != 8 && east == 6)
	{
		maze[mouseRow][mouseCol] = maze[i+1][j];
		maze[mouseRow][mouseCol].direction = e;
		maze[i+1][j].parentRow = maze[i-1];
		maze[i+1][j].parentCol = maze[j];
		c.row = mouseRow;
		c.col = mouseCol;
		cpos.push(c);
	}
	if(north != 8 && east != 4 && south == 2)
	{
		maze[mouseRow][mouseCol] = maze[i][j+1];
		maze[mouseRow][mouseCol].direction = s;
		maze[i][j+1].parentRow = maze[i];
		maze[i][j+1].parentCol = maze[j-1];
		c.row = mouseRow;
		c.col = mouseCol;
		cpos.push(c);
	}
	if(north != 8 && east != 4 && south != 2 && west == 1)
	{
		maze[mouseRow][mouseCol] = maze[i-1][j];
		maze[mouseRow][mouseCol].direction = w;
		maze[i-1][j].parentRow = maze[i+1];
		maze[i-1][j].parentCol = maze[j];
		c.row = mouseRow;
		c.col = mouseCol;
		cpos.push(c);
	}
	}
	maze[mouseRow][mouseCol].visited = true;
 
  if (north !=8 && east !=4 && south !=2 && west !=1)
   {
     // go back to parent cell and choose other available direction
     maze[mouseRow][mouseCol]=
   }
}
}
	cout << "Maze has no solution" << endl;
}

class Cell
{
  public:
   int rowNumber;
   int colNumber;
   bool doors[4]; //true == door, false == wall
   bool visited;  //set to false in constructor
   int sideNumber; //range 0-3, set to zero in constructor
   bool operator == //useful, but not necessary
   etc
};
 
void Maze::initialize()
{
  read data from file to establish:
  1) mouse starting position
  2) cheese location
  3) Cells in the maze
  4) values for sides of all Cells in maze      
}
 
void Maze::Solve() 
{		 
  Cell * newRoom; 
  stack<Cell> path;
 
  bool solutionNeeded = true;
  bool needNewRoom;
 
  maze[mouseStartRow][mouseStartCol].visited = true;
  path.push(maze[mouseStartRow][mouseStartCol]);
 
  while(!path.empty() && solutionNeeded)
  {
    //mouse is path.top();
 
    if(path.top() == cheeseLocation)
      solutionNeeded = false;
    else if(path.top().sideNumber == 4) //dead end
      path.pop(); //go back to prior room.
    else
    {
      needNewRoom = true;
      while(path.top().sideNumber < 4 && needNewRoom)
      {
        if(path.top().doors[path.top().sideNumber]) //if this side is a door
        {
          switch(path.top().sideNumber)
          {
            case 0: //west side of current cell is a door, so move 1 col to left
              newRoom = &maze[path.top().rowNumber][path.top().colNumber - 1];
              break;
            //etc
          }
          path.top().sideNumber++;
          if(!newRoom->visited)
          {
            needNewRoom = false;
            newRoom->visited = true;
            path.push(*newRoom);
          }
        }
        else
          path.top().sideNumber++;
      }
    }
  }
  if(solutionNeeded)
    cout << "no solution" << endl;
}