2D vector resizing needs default constructor of the object - c++

Question

I have a simple ball class. It takes a color name for its initialization.
Ball::Ball(ColorName color_name) : m_color_name{color_name} {
}
I try to create a 2d-vector board to contain some balls. The width and the height are given outside.
class Board {
private:
int m_width;
int m_height;
std::vector<std::vector<Ball>> m_grids;
public:
Board(int width, int height);
~Board();
};
Board::Board(int width, int height) : m_width{width}, m_height{height} {
m_grids.resize(height);
for (int row_num = 0; row_num < height; row_num ++) {
m_grids[row_num].resize(width);
}
}
Then the compiler complains that the ball class needs default constructor for resizing.
Then I try to change it to pointer.
class Board {
private:
int m_width;
int m_height;
std::vector<std::vector<Ball> *> *m_grids;
public:
Board(int width, int height);
~Board();
};
Board::Board(int width, int height) : m_width{width}, m_height{height} {
m_grids->resize(height);
for (int row_num = 0; row_num < height; row_num ++) {
m_grids->at(row_num)->resize(width);
}
}
Or
Board::Board(int width, int height) : m_width{width}, m_height{height} {
m_grids->resize(height, new std::vector<Ball>[width]);
for (int row_num = 0; row_num < height; row_num ++) {
m_grids->at(row_num)->resize(width);
}
}
They still complain the same thing.
So far I can only create the default constructor for workaround.
Ball::Ball() {
m_color_name = ColorName::Default;
}
But I really don't like it because the balls should not be "default_color". Thy should be like "yellow", "pink" or some color I defined elsewhere.
Is there a way to avoid creating that constructor?

Answer 1

Well, if you don't know what color the balls on a new empty board should be, C++ cannot help you with it. You did not provide a default constructor for the type, so C++ has no way of knowing which default value to use. You have several options here.
One. Use board of std::optional<ColorName>. In this case, you will have an explicit "default" state which is std::nullopt. However, you would need to be careful and always make sure the color is emplaced if you need it.
Two. Do not create the board beforehand. Create it only when you know what color should be there. E.g. it is ok to do m_grids[row_num].push_back(ColorName::Whatever);, you don't need a default constructor for that.
As for pointers (be it raw or smart) - forget it. You don't need pointers in this task.

Answer 2

Instead of making the vectors to pointers (which doesn't make any sense), the entries themselves should be pointers. Since pointers can be nullptr, the vectors will be resizable, like this:
std::vector<std::vector<Ball *>> m_grids_bad;
// Or even better:
std::vector<std::vector<std::unique_ptr<Ball>>> m_grids;
// You can then assign things like this (for example):
m_grids[4][5] = std::make_unique<Ball>(ColorName::RED, 5);
I would strongly recommend you always use std::unique_ptr where possible, or std::shared_ptr, since nothing speaks against it. It helps you with freeing memory when exceptions are thrown, or allows you to share ownership of some memory address, etc. Just do it.
Resizing the vectors will now work like you want to, because std::unique_ptr has a default constructor which just initializes its internal pointer to nullptr.
PS: Maybe I should elaborate on why storing vectors on the heap doesn't make sense. Vectors already can store their content on the heap, and dynamically reallocate memory when required.
Another thing: Vectors to pointers are also really useful if your element type is unmovable. This could come in handy in multithreading situations, where threads sometimes are initialized with a pointer to something, and rely on that something to stay exactly where it is in memory.