1. ## .empty()

I am implementing a path-finding algorithm and I can't understand the following:

First of all this function is called:

Code:
```int UpdateMap(unsigned int startx, unsigned int starty, unsigned int endx, unsigned int endy)
{
PathFind<WorldSearchNode> pathfind;

WorldSearchNode StartNode;
StartNode.x = startx;
StartNode.y = starty;

WorldSearchNode EndNode;
EndNode.x = endx;
EndNode.y = endy;

pathfind.SetStartandGoalStates(StartNode, EndNode);

unsigned int xSearchState;
unsigned int xSearchSteps = 0;

do
{
xSearchState = pathfind.PathFindStep();

xSearchSteps++;
}
while(xSearchState == PathFind<WorldSearchNode>::PATH_FIND_PROCESSING);

if (xSearchState == PathFind<WorldSearchNode>::PATH_FIND_SUCCEEDED)
{
WorldSearchNode *Node = pathfind.GetSolutionStart();

int steps = 0;

Node->CopyNodeToWorld();

for(;;)
{
Node = pathfind.GetSolutionNext();

if (!Node)
{
break;
}

Node->CopyNodeToWorld();
steps++;
}

pathfind.FreeSolutionNodes();
return 1;

}
else if (xSearchState == PathFind<WorldSearchNode>::PATH_FIND_FAILED)
{
return 0;
}

return 0;
}```
As can be seen, the first function to be called from within this function is the SetStartandGoalStates, which is here:

Code:
```void SetStartandGoalStates(RobotState &Start, RobotState &Goal)
{
xCancelRequest = FALSE;

xStart = AllocateNode();
xGoal = AllocateNode();

xStart->xRobotState = Start;
xGoal->xRobotState = Goal;

xState = PATH_FIND_PROCESSING;

xStart->c = 0;
xStart->h = xStart->xRobotState.GoalDistanceEstimate(xGoal->xRobotState);

xStart->f = xStart->c + xStart->h;
xStart->parent = 0;

//push the start node onto the open list

xOpenList.push_back(xStart);//this has made the heap unsorted

//sort heap

push_heap(xOpenList.begin(),xOpenList.end(),CompareHeap());

//initialise path find steps counter
xSteps = 0;
}```
Next is the FindPathStep() function, the beginning of which is here:

Code:
```unsigned int PathFindStep()
{
assert((xState>PATH_FIND_UNINITIALISED) && (xState<PATH_FIND_INVALID)); //evaluates expression, exits program if false, continues if true.

if ((xState == PATH_FIND_SUCCEEDED) || (xState == PATH_FIND_FAILED))
{
return xState;
}//ensures that if PathFindStep is run after the search has succeeded, we want to return a success.

//If there is nothing left to search then the OpenList will be emptied, we can use this to define failure

//We also need to incorporate the event that the search has been aborted

if (xOpenList.empty())
{
exit(0);
xState = PATH_FIND_FAILED;
FreeAllNodes();
return xState;
}```
As can be seen I have a check at the beginning of this function to see if xOpenList.empty() returns true, ending the program if it is. And this is exactly what it is doing. I ran a similar check on xOpenList.empty() directly after push_heap(xOpenList.begin(),xOpenList.end(),Compar eHeap()); and it returned false. So why is xOpenList being emptied by the time I come to check it in FindPathStep?

Any help would be much appreciated.

2. And another thing, I know that assert(....) at the beginning of FindPathStep() is not aborting the program because I commented it out and it made no difference.