c++ - C++中的QHashIterator

我用C ++开发了一个游戏，并希望确保一切都正确完成。
使用QHashIterator检查列表中哪个项的值最低（寻路的F成本）是一个好的解决方案。

我的代码段：

 while(!pathFound){ //do while path is found

        QHashIterator<int, PathFinding*> iterator(openList);
        PathFinding* parent;
        iterator.next();
        parent = iterator.value();

        while(iterator.hasNext()){ //we take the next tile, and we take the one with the lowest value
            iterator.next();
            //checking lowest f value
            if((iterator.value()->getGcost() + iterator.value()->getHcost()) < (parent->getGcost() + parent->getHcost())){
                parent = iterator.value();
            }
        }

        if(!atDestionation(parent,endPoint)){ //here we check if we are at the destionation. if we are we return our pathcost.
            clearLists(parent);
            filllists(parent,endPoint);
        }else{
            pathFound = true;
            while(parent->hasParent()){
                 mylist.append(parent);
                 parent = parent->getParent();
            }
            pathcost = calculatePathCost(mylist);    //we calculate what the pathcost is and return it
        }
     }

如果不？有更好的改进吗？

我还发现了有关std :: priority_queue的内容。这比QHashIterator好吗？

对于游戏世界来说，这可能不是什么大问题。但是当游戏世界很大时（例如+ 10000次计算），我正在寻找合适的解决方案。

最佳答案

在这里，您基本上可以扫描整个地图，以根据一些值找到最小的元素：

while(iterator.hasNext()){ //we take the next tile, and we take the one with the lowest value
    iterator.next();
    //checking lowest f value
    if((iterator.value()->getGcost() + iterator.value()->getHcost()) < (parent->getGcost() + parent->getHcost())){
        parent = iterator.value();
    }
}

如果您拥有一个stl容器（例如地图），那么所有这些代码都可以简化为：

auto parent = std::min_element(iterator.begin(), iterator.end(), [](auto& lhs, auto& rhs)
  { lhs.value()->getGcost() + lhs.value()->getHcost()) < (rhs.value()->getGcost() + rhs.value()->getHcost() }

一旦有了一些易于理解的内容，就可以使用不同的容器，例如，在这种情况下，保存排序的向量可能会更快。
  ）

您的代码本身并不存在任何明显的问题，通常，通过优化小循环并不能克服性能提升，更多的是代码的组织方式。例如，我看到您有很多间接访问，这些间接访问会导致高速缓存未命中。或者，如果您必须始终找到最小元素，则可以将其缓存在另一个结构中，并且始终在固定的时间获取它。