What causes this vector subscript out of range Error?

Question

I am currently mapping a Graph to a Minesweeper like grid, where every Block represents a node. Here is my Graph class:

    class Graph : public sf::Drawable
    {
        public:
            Graph(uint32_t numNodesWidth, uint32_t numNodesHeight);

            [[nodiscard]] std::vector<Node> & operator[](std::size_t i) 
            { return data[i]; }


            [[nodiscard]] sf::Vector2u dimension() const 
            { return {static_cast<uint32_t>(data.size()), 
              static_cast<uint32_t>(data[0].size())};}
            ...
            ...
        private:
            std::vector<std::vector<Node>> data;
    };

here is the implementation of the constructor:

    Graph::Graph(uint32_t numNodesWidth, uint32_t numNodesHeight)
    {
        data.resize(numNodesHeight);
        for(auto & row : data)
        {
            row.resize(numNodesWidth);
        }
    }

Somewhere in another class I read mouse coordinates and convert them to "Graph Coordinates":

sf::Vector2u translatedCoords = toGraphCoords(sf::Mouse::getPosition(window), nodeSize_);
bool inBounds = checkGraphBounds(translatedCoords, graph.dimension());

Here are the helper functions:

        sf::Vector2u toGraphCoords(sf::Vector2i mouseCoord, sf::Vector2f nodeSize)
        {
            return {static_cast<uint32_t>(mouseCoord.y / nodeSize.y), 
                    static_cast<uint32_t>(mouseCoord.x / nodeSize.x)};
        }

        bool checkGraphBounds(sf::Vector2u mouseCoord, sf::Vector2u bounds)
        {
            return mouseCoord.x >= 0 && 
                    mouseCoord.y >= 0 && 
                    mouseCoord.x < bounds.x && 
                    mouseCoord.y < bounds.y ;
        }

Somehow I get the vector subscript out of range 1655 error when I try to use these new checked Coordinates which is somehow strange, can someone explain to me what I am doing wrong. This error always shows when I try to hover beyond the "Bounds" of the Interactive area, slightly behind or in front the first or the last Node.

Thanks in advance.

Answer 1

There is no guarantee that bounds <= num_nodes * node_size. This is especially risky since there are integer divisions involved, which means that you are at the mercy of rounding.

You could shuffle code around until such a guarantee is present, but there's a better way.

If the checkGraphBounds() function operated on the same math that the grid does, you could be sure that the result would be consistent with grid, no matter how that relates to the bounds.

The ideal way to do so would be to actually use toGraphCoords() as part of it:

bool checkGraphBounds(sf::Vector2u mouseCoord, const Graph& graph, 
                      sf::Vector2f nodeSize)
{
    auto coord = toGraphCoords(mouseCoord, nodeSize);

    return coord.x >= 0 && 
           coord.y >= 0 && 
           coord.x < graph.dimensions().x && 
           coord.y < graph.dimensions().y) ;
}

With this, you can formally guarantee that should a mouseCoord pass that test, static_cast<uint32_t>(mouseCoord.x / nodeSize.x)} will for certain return a value no greater than graph.dimensions().x.

Personally, I would combine both functions as a method of Graph like so:

class Graph : public sf::Drawable {
    // Make nodeSize a member of the Graph
    sf::Vector2f nodeSize_; 

    // This is one of the cases where caching an inferable value is worth it.
    sf::Vector2u dimensions_; 

  public:
    std::optional<sf::Vector2u> toGraphCoords(sf::Vector2i mouseCoord) {
      sf::Vector2u coord{
        static_cast<uint32_t>(mouseCoord.y / nodeSize_.y), 
        static_cast<uint32_t>(mouseCoord.x / nodeSize_.x)};
      };

      // No need to compare against 0, we are dealing with unsigned ints
      if(coord.x < dimensions_.x &&
         coord.y < dimensions_.y ) {
        return coord;
      }
      return std::nullopt;
    }

    // ...
};

Usage:

void on_click(sf::Vector2i mouse_loc) {
  auto maybe_graph_coord = the_graph.toGraphCoords(mouse_loc);

  if(maybe_graph_coord) {
    sf::Vector2u graph_coord = *maybe_graph_coord;
    // ...
  }
}