How to efficiently fill a 2D std::array with enum - c++

Question

I am trying to find an efficient and proper way to fill a 2D std::array matrix with an enum value. I am doing this:
#include <iostream>
#include <array>
template<class T, size_t ROW, size_t COL>
using Matrix = std::array<std::array<T, COL>, ROW>;
enum class State { FREE = 0, BUSY, BLOCKED, RESERVED };
int main() {
const int mapX = 4;
const int mapY = 9;
// create a 5x10 2D array
Matrix<State, mapY, mapX> MapMatrix;
// fill array with State::RESERVED value
for (int y = 0; y <= mapY; y++) MapMatrix[y].fill(State::RESERVED);
std::cout << "MapMatrix contains:\n";
for (int y = 0; y <= mapY; ++y) {
for (int x = 0; x <= mapX; ++x) {
std::cout << static_cast<int>(MapMatrix[x][y]) << " ";
}
std::cout << std::endl;
}
return 0;
}
Is the for loop I am doing the best way to fill the matrix with the enum value? Is there a way to fill the matrix during the declaration of Matrix<State, mapY, mapX> MapMatrix (like a constructor)?
Thanks!

Answer 1

You can't fill it on initialization unless you are filling it with zeros, or you specify every element explicitly. If you rearranged your enum so that RESERVED is zero, then you could initialize it like this:
Matrix<State, mapY, mapX> MapMatrix = {};
If you can't do that, then yes, a for loop is probably the best option. Keep it simple. But you have a few problems. First, your comment says that you are creating a 5x10 array, but you are not. You are creating a 4x9 array. If you want to create a 5x10 array, then you need to pass 5 and 10 as your template parameters. I think you're probably getting confused by the fact that the last element of an array of size N is N - 1. This off-by-one issue is only relevant to accessing elements of an array, not in specifying the size of an array.
Second, you are iterating past the end of your array, because your loop condition is y <= mapY, rather than y < mapY. But it would be better if you just used a range-for loop.
for (auto& arr : MapMatrix)
arr.fill(State::RESERVED);

Answer 2

I think that a loop based initialization is a good solution.
But, just for fun, I propose you another solution std::index_sequence and template pack expansion based.
A working example (with index corrected)
#include <iostream>
#include <utility>
#include <array>
template <typename T, std::size_t ROW, std::size_t COL>
using Matrix = std::array<std::array<T, COL>, ROW>;
enum class State { FREE = 0, BUSY, BLOCKED, RESERVED };
template <typename T, std::size_t ... Rs, std::size_t ... Cl>
Matrix<T, sizeof...(Rs), sizeof...(Cl)> initMat
(T const & tVal,
std::index_sequence<Rs...> const &,
std::index_sequence<Cl...> const &)
{
auto col = std::array<T, sizeof...(Cl)>{ { ((void)Cl, tVal)... } };
return Matrix<T, sizeof...(Rs), sizeof...(Cl)>
{ { ((void)Rs, col)... } };
}
int main()
{
constexpr std::size_t mapX = 5U;
constexpr std::size_t mapY = 10U;
// create a 5x10 2D array
auto MapMatrix = initMat(State::RESERVED,
std::make_index_sequence<mapX>(),
std::make_index_sequence<mapY>());
std::cout << "MapMatrix contains:\n";
for ( auto y = 0U ; y < mapY ; ++y )
{
for ( auto x = 0U ; x < mapX ; ++x )
std::cout << static_cast<int>(MapMatrix[x][y]) << " ";
std::cout << std::endl;
}
return 0;
}