Creating the Grid

Vector vs 2D Array in Minesweeper

Why do we use a vector to store the cells instead of a 2D array?

Abstract art representing computer programming

In our Minesweeper implementation, we used a one-dimensional std::vector to store the cells, but a 2D array is also a viable option. Both approaches have their advantages, and the choice often depends on specific requirements and preferences. Let's explore both methods:

Using `std::vector`

We chose to use a std::vector for its flexibility and ease of use. Here's why:

Dynamic sizing: std::vector can easily resize at runtime, which is useful if we want to change the grid size dynamically.
Contiguous memory: std::vector stores elements in contiguous memory, which can lead to better cache performance.
Standard library support: std::vector comes with many useful functions like push_back(), emplace_back(), and range-based for loop support.

Here's how we implemented it:

1#include <vector>
2#include "Minesweeper/Cell.h"
3
4class MinesweeperGrid {
5public:
6  MinesweeperGrid(int x, int y) {
7    using namespace Config;
8    Children.reserve(GRID_COLUMNS * GRID_ROWS);
9    for (int Col{1}; Col <= GRID_COLUMNS;
10         ++Col) {
11      for (int Row{1}; Row <= GRID_ROWS;
12           ++Row) {
13        constexpr int Spacing{CELL_SIZE +
14                              PADDING};
15        Children.emplace_back(
16          x + (Spacing) * (Col - 1),
17          y + (Spacing) * (Row - 1), CELL_SIZE,
18          CELL_SIZE, Row, Col);
19      }
20    }
21  }
22
23  std::vector<MinesweeperCell> Children;
24};

Using a 2D Array

A 2D array could be implemented using std::array or a raw C-style array. Here's how it might look:

1#include <array>
2#include "Minesweeper/Cell.h"
3
4class MinesweeperGrid {
5public:
6  MinesweeperGrid(int x, int y) {
7    using namespace Config;
8    for (int Col{0}; Col < GRID_COLUMNS;
9         ++Col) {
10      for (int Row{0}; Row < GRID_ROWS; ++Row) {
11        constexpr int Spacing{CELL_SIZE +
12                              PADDING};
13        Children[Row][Col] = MinesweeperCell(
14          x + (Spacing)*Col, y + (Spacing)*Row,
15          CELL_SIZE, CELL_SIZE, Row + 1,
16          Col + 1);
17      }
18    }
19  }
20
21  std::array<std::array<MinesweeperCell,
22                        Config::GRID_COLUMNS>,
23             Config::GRID_ROWS>
24    Children;
25};

This approach has the advantage of more intuitive 2D indexing (Children[row][col]) and potentially better performance for fixed-size grids.

Both approaches are valid, and the choice often comes down to specific needs and personal preference. In our case, the vector approach provides more flexibility for potential future enhancements, such as dynamic grid sizing.

This Question is from the Lesson: