List Iterator not dereferenceable - c++

Question

I've been working on a lowest cost algorithm for airports where the user enters the name of an airport, and then I run this algorithm to spit out all the destinations you can go to, and the lowest cost, including connecting flights. I use a list iterator to iterate through the reachable destinations from the source location, but after just one iteration, the code breaks and a message comes up telling me that the iterator is not dereferenceable. here is my code
//Finds minimum cost
void findPaths(std::string source)
{
std::list<int> Reachable;
int min = INTMAX_MAX;
int lowestIndex = -1;
bool existsInList = true;
std::stack<std::string> connectingFlights;
//Make arrays
//Initialize costs to a high value so any value will be smaller
int costs[MAX]{INTMAX_MAX};
//Initialize paths to negative one so that we know there is no location
int path[MAX]{ -1 };
//Find where the source is
int srcIndex = findOrInsert(source);
//Put the costs into the array, leaving the high number for where there is no path
for (int i = 0; i < MAX; i++)
{
costs[i] = priceEdges[srcIndex][i];
}
//Put the source index in places that have a path
for (int i = 0; i < MAX; i++)
{
if (priceEdges[srcIndex][i] == 0)
{
path[i] = -1;
}
else
{
path[i] = srcIndex;
Reachable.push_back(i);
}
}
//If the list is empty, we are done;
while (!Reachable.empty())
{
//Find the index that has the lowest value in costs
for (std::list<int>::iterator it = Reachable.begin(); *it < Reachable.size(); it)
{
if (costs[*it] < min)
{
min = costs[*it];
int lowestIndex = *it;
}
//Remove the index with the lowest value in costs
Reachable.erase(it);
//Save the previous cost to compare after a change may occur
int prevCost = costs[lowestIndex];
//Assign the value to the lowest cost it can find
costs[lowestIndex] = FindMin(costs[lowestIndex], costs[srcIndex] + priceEdges[srcIndex][lowestIndex]);
//If the price has changed
if (prevCost != costs[lowestIndex])
{
path[lowestIndex] = srcIndex;
}
existsInList = std::find(Reachable.begin(), Reachable.end(), lowestIndex) != Reachable.end();
if (!existsInList)
{
Reachable.push_back(lowestIndex);
}
}
}

Answer 1

Your for loop is just plain wrong. You are dereferencing an iterator without validating that it is even valid, and you are comparing a destination value the iterator refers to against the size of the vector, which makes no sense since they are two completely different things.
You need to replace the loop with this instead:
for (std::list<int>::iterator it = Reachable.begin(); it != Reachable.end(); )
Or even this:
std::list<int>::iterator it = Reachable.begin();
while (it != Reachable.end())
Then, to satisfy the loop's stop condition, you need to change this line:
Reachable.erase(it);
To this instead:
it = Reachable.erase(it);
You are removing an item from the list, which invalidates the iterator, but you are never updating the iterator to point at the next item, so the code will have problems when it tries to dereference the iterator again. erase() returns an iterator to the next item in the list following the item that is being removed.
Also, on this line:
int lowestIndex = *it;
You are declaring a new temp variable that goes out of scope immediately afterwards, so it is never used. You have a previous lowestIndex variable declared at the start of the function that you are never assigning a value to after initialization, so it is always -1. You need to remove the int from the assignment:
lowestIndex = *it;

Answer 2

//Remove the index with the lowest value in costs
Reachable.erase(it);
This is invalidating the iterator but the for loop performs *it < Reachable.size(), which dereferences the invalid iterator. Instead, should probably do.
it = Reachable.erase(it);
Furthermore, the *it < Reachable.size() should probably be replaced with it != Reachable.end().
Lastly, the increment portion of your for loop should probably be empty since it's not doing anything. You could also use a while loop instead.
auto it = Reachable.begin();
while (it != Reachable.end())
{
// ...
it = Reachable.erase(it);
// ...
}