C++ Passing 2D Arrays - c++

Question

I am trying to create a minesweeper game that loads the board from a flat file (no, it's not random). As per the assignment instructions, I am to pass a 2d array to a load function which will then parse the file which was passed as a command-line arguement.
Anyway, my problem is passing the 2D array. What is the proper way to go about doing it? Below is the code that I have thus-far:
#include <iostream>
using namespace std;
struct Tile
{
bool mine, visible;
int danger;
};
bool loadBoard( Tile **board, string filename );
const int gridSize = 6;
int main( int argc, char* argv[] )
{
Tile board[ gridSize ][ gridSize ];
loadBoard( board, argv[ 1 ] );
system("PAUSE");
return EXIT_SUCCESS;
}
bool loadBoard( Tile **board, string filename ) {
}

Answer 1

Since you're using C++, why not use
std::vector<std::vector<Tile>>
in preference to a C-style array?
Since you seem to need to use C-style arrays, you could use the approach arpanchaudhury suggests or you could pass Tile* and do something like
static void loadBoard(Tile *board, int rows, int cols, string filename) {
for (int row = 0; row < rows; row++) {
for (int col = 0; col < cols; col++) {
Tile* tile = &board[(row*gridSize)+col];
// populate Tile
}
}
}

Answer 2

In case you want to to pass the 2d-array please specify number of columns in the array.
bool loadBoard( Tile board[][size], string filename ) {}
though it is preferable to use vectors instead of simple arrays since you need not specify a pre-defined size

Answer 3

As long as you're using C++...
#include <iostream>
using namespace std;
struct Tile
{
bool mine, visible;
int danger;
};
// load a square board of declared-size.
template<size_t N>
void loadboard( Tile (&board)[N][N], const std::string& filename)
{
// load board here.
cout << "Loading from file: " << filename << endl;
for (size_t i=0;i<N;++i)
{
cout << "board[" << i << "]: [ ";
for (size_t j=0;j<N;++j)
{
// load element board[i][j] here
cout << j << ' ';
}
cout << ']' << endl;
}
cout << endl;
}
int main()
{
Tile board[6][6];
loadboard(board, "yourfilename.bin"); // OK dims are the same
Tile smaller[3][3];
loadboard(smaller, "anotherfile.bin"); // OK. dims are the same
// Tile oddboard[5][6];
// loadboard(oddboard, "anotherfile.bin"); // Error: dims are not the same.
return 0;
}
Output
Loading from file: yourfilename.bin
board[0]: [ 0 1 2 3 4 5 ]
board[1]: [ 0 1 2 3 4 5 ]
board[2]: [ 0 1 2 3 4 5 ]
board[3]: [ 0 1 2 3 4 5 ]
board[4]: [ 0 1 2 3 4 5 ]
board[5]: [ 0 1 2 3 4 5 ]
Loading from file: anotherfile.bin
board[0]: [ 0 1 2 ]
board[1]: [ 0 1 2 ]
board[2]: [ 0 1 2 ]
Of course, there are probably "specific instructions" to not use the templates feature of the language either. Then again, I bet those instructions don't include having SO users solve your problem either, so I don't take much stock in those being followed rigorously anytime soon.