how to declare an array of objects without calling object constructor - c++

Question

Given a struct like
struct Square
{
Square(Color p_color): color_(p_color) {}
Color color_;
};
how can i declare a two dimensional array and later initialize it. For example,
typedef Square (&Square8x8)[8][8];
Square8x8 initSquares()
{
Square board[ROWS][COLS]; //declare the array
for(int row=0;row<ROWS;row++)
for(int col=0;col<COLS;col++)
{
if(col%2 == 0)
board[row][col]= Square(WHITE); //actual initlization
else
board[row][col] = Square(BLACK);
}
return board;
}

Answer 1

You misunderstand the point of a constructor, which is to ensure an object is always initialized and valid during its entire lifecycle. Thus the invocation of a constructor cannot be in any way delayed or postponed.
It's a typical XY-problem though - you're asking for help with an intended solution, not a problem. The real problem is that you don't want to postpone the constructor, but initialize it later on. Construction and initialization are related subjects, but not identical.
The best solution is to give your class a setColor or initialize function, separate from the constructor. An alternative solution (which is closer to your question) is to declare the array not as objects, but as pointers, and then really instantiate the object later on with new Square(WHITE). I'd go for the first though, the second requires a lot more lifecycle control with explicit deletion.

Answer 2

You need a default constructor for Square which is able to call without parameters. For example:
struct Square
{
Square() {} // <------------------------- For example
Square(Color p_color): color_(p_color) {}
Color color_;
};
Otherwise, you should use pointer to Square and new them later. For example:
struct Square
{
Square(Color p_color): color_(p_color) {}
Color color_;
};
const int ROWS = 8;
const int COLS = 8;
In this case, you should use pointers:
std::unique_ptr<Square> board[ROWS][COLS];
for (int i=0; i<ROWS; i++)
for (int j=0; j<COLS; j++)
board[i][j] = std::unique_ptr<Square>(new Square(RED));
or (for bare pointers)
Square* board[ROWS][COLS];
for (int i=0; i<ROWS; i++)
for (int j=0; j<COLS; j++)
board[i][j] = new Square(RED);
....
// Be careful, you should delete them all

Answer 3

In case you don't want to use a default constructor you can use the constructor you already have.
This solution uses std::vector, which I also recommend you use.
std::vector<Square> myVector( ROWS*COLS, Square(WHITE) );
this will create an array of ROWS * COLS elements, each initialized to the value of Square(WHITE).
You could create a Board class, which uses such a vector inside and offers functionalities such as initializing a board of arbitrary size and indexing a Square in the linear vector based on Row and Column information.
You can also do:
Square board[2][2] = {Square(WHITE), Square(WHITE), Square(WHITE), Square(WHITE) };
but it doesn't really scale well.

Answer 4

Create an array of (smart) pointers instead of an array. One purpose of pointers is so objects can be initialized later.