如何为std :: map实现std :: map的比较逻辑，该逻辑包含两个“ Pos”结构，每个结构均包含x和y坐标

Question

I am recreating Pac-Man and currently am implementing the ghost's path finding. I am using BFS. I am having trouble implementing my 'Pos' class comparison logic so that my std::map::find works as intended.

'BFS' map

std::map<Pos, Pos> bfs;

'Pos' Struct

struct Pos {
    int x_;
    int y_;

    bool operator==(const Pos &rhs) const { return (x_ == rhs.x_ && y_ == rhs.y_); };
    bool operator<(const Pos &rhs)  const { return (x_ < rhs.x_); };
};

The part of the function that uses std::map::find to check for unvisited XY positions.

if (bfs.find(neighbors.at(i)) == bfs.end()) {
    frontier.push(neighbors.at(i));
    bfs[neighbors.at(i)] = current;

    if (bfs[neighbors.at(i)] == end_tile) {
        quit = true;
    }
}

I used this website to learn how to use BFS for pathfinding: https://www.redblobgames.com/pathfinding/a-star/implementation.html#cpp-early-exit

I have tried multiple variations of <, and > for comparing x and or y, but it does not seem to work resulting in an empty map or a map with very few values - far from what is needed.

Answer 1

Considering you have put enough thought on the algorithm you're using, in order to use Pos objects as keys in a std::map , you'll need to find the correct strict weak ordering criterion (the operator<) that meets your requirement.

bool operator<(const Pos& rhs) const {
    if(x_ < rhs.x_) return true;
    if(x_ > rhs.x_) return false;

    //x == coord.x
    if(y_ < rhs.y_) return true;
    if(y_ > rhs.y_) return false;

    //*this == pos
    return false;
}

You could also use something like std::tie (in C++11) which will first compare x, and then y:

bool operator<(const Pos& rhs) const
{
    // compare x_ to rhs.x_,
    // then y_ to rhs.y_
    return std::tie(x_,y_) < std::tie(rhs.x_, rhs.y_);
}

Answer 2

The comparison used for the map key must obey some rules. See documentation for more information: http://www.cplusplus.com/reference/map/map/ .

Essentially, in you case as your operator< only compare x value and not y value, any position with the same x would be considered equivalent so if you have multiple position with the same x but different y as the key, only one those will exist in the map.

As you are using bfs[neighbors.at(i)] = current; to update the value, you will get the last current value for a specific x instead of the last value for a specific {x, y}.

You comparison should really be something like

 return x_ < rhs.x_ || x_ == rhs.x_ && y_ < rhs.y_;

Essentially when searching for the insertion position, the algorithm will only use operator< and not operator== .

Say that your map have the position { 3, 5 } and you want to insert { 3, 4 }.

{ 3, 5 } < { 3, 4 } is false

{ 3, 4 } < { 3, 5 } is false (since you only check x)

Since both are false, they are considered equivalent and the existing item is updated (instead of adding a new item as desired).