C ++初始化2D结构数组

Question

I'm writing a program that allows the user to play sudoku puzzles. Each puzzle is a 2d array of structs, but I'm unable to intialize the array in one go. Is there any way to do this without needing to intialize each part of the structure for each element of the array? Here is some of my code.

class Sudoku {
   protected:
   struct Puzz {
      int Ans;
      // IsClue is used further in the program so the user cannot change the clues given.
      bool IsClue;  
   };
   Puzz Puzzle[9][9]; // I chose a 2D array so represent the 9 rows and columns of a sudoku puzzle
};

I've tried some of the following:

Puzzle[][9] = {{0, false, 8, true,  0, false, 6, true,  7, true,  0, false, 0, false, 0, false, 0, false}, //...etc, going on for each row
Puzzle[9][9] = // etc, etc, but I get an error saying "Expected an expression

Is the only way to initialize each element to do

Puzzle[x][y].Ans = x; Puzzle[x][y].IsClue = true/false;?

Answer 1

The problem is that you try to assign to an array, and it's simply not possible. You need to actually initialize it, which is something completely different.

If you don't mind writing lot of lines that are almost the same, then you could use a constructor member initializer list . Like eg

Sudoku::Sudoku()
    : Puzzle{{...}, {... }, ... }
{}

If only a few structures in the arrays differ from some default values, then you could set all entries in the arrays to the same default value, using eg std::fill and then change those few entries that have special values.

Answer 2

To initialize a two-dimensional array, use a for-loop. As in:

 for (int i = 0; i < row_count; i++) {
    for (int j = 0; j < col_count; j++) {
       item[i][j] = initial_value;
    }
 }

If you want to use an initializer list like in the above, you can do so by simply wrapping each instance of the struct in brackets. However, initializing your sodoku board with a literal is not a particularly scalable approach to generating a sodoku board for the player. That is, instead of:

Puzzle puzz[9][9] = {{0, false, 8, true,  0, false, 6, true,  7, true,  0, false, 0, false, 0, false, 0, false, ...}};

You would use:

Puzzle puzz[9][9] = {
  {  // First row
     {0, false}, // first column
     {8, true}, // second column
     ...
  },
  {  // Second row
     ...
  },
  ...
};

Since this is C++, though, you may wish to consider representing your board using nested vectors (that is vector<vector<Cell>> ). While this may be overkill, especially for a Sodoku board (especially if it is always 9x9), that will allow you to more easily represent non-standard board sizes, and the vector data structure comes with the ability to default initialize/fill all members with a pre-specifed value. As @paddy aptly notes in the comments, however, there are also other functions (like std::fill that can be used with ordinary arrays to handle common use cases.

Answer 3

You can initialize with an initializer list in c++11 or higher:

Puzz Puzzle[2][2] = {
    { {8, true}, {9, false} },
    { {10, true}, {11, false} }
};

If in a class you can default construct it the same way:

class PuzzHolder {
    PuzzHolder() : Puzzle{
        { {8, true}, {9, false} },
        { {10, true}, {11, false} }
    } { }

    Puzz Puzzle[2][2];
};

Although, if it is very big, this might get pretty messy. So the final approach could be to initialize it in a loop.

Live example.

Answer 4

Here's an example showing how a 2 x 2 array can be initialized. I'll leave it to you to extend that to a 9 x 9 array.

class Sudoku {
   Sudoku();
   protected:
   struct Puzz {
      int Ans;
      bool IsClue;  
   };
   Puzz Puzzle[2][2];
};

Sudoku::Sudoku() : Puzzle{{{0, false}, {1, true}}, {{2, false}, {3, true}}}
{
}

Having said that, it might be easier to create a default constructor of Puzz which does the sensible thing for most objects and then modify only a select elements of Puzzle in Sudoku 's constructor.

class Sudoku {
   Sudoku();
   protected:
   struct Puzz {
      int Ans;
      bool IsClue;  
      Puzz() : Ans(0), IsClue(false) {}
   };
   Puzz Puzzle[2][2];
};

Sudoku::Sudoku()
{
   // Change specific elements of Puzzle
}