Scelta tra matrice monodimensionale e bidimensionale

Bene, nello spazio del problema i 64 quadrati sono formati dalla dimensione 8 x 8 della tua scheda, quindi il design più adeguato sarebbe utilizzare un array tridimensionale:

 transformed_board[8][8][8]

Le prestazioni dipenderanno dalla tua implementazione, dalle operazioni che farai su quella matrice e dal compilatore che stai utilizzando. Non cadere nella trappola di ottimizzazione prematura . Il miglior approccio qui è probabilmente quello di fornire funzioni di accesso come

 SQUARE_TYPE GetSquare(int row,int column, int symmetry)
 {
      assert(0<=row && row<MAX_ROWS);
      assert(0<=column && column <MAX_COLUMNS);
      assert(0<=symmetry&& symmetry<MAX_SYMMETRIES);
      return transformed_board[row][col][symmetry];
 }

e limitare tutti gli accessi alla scheda all'uso di tali accessori. Quindi sarà facile cambiare la decisione sulle dimensioni dell'array utilizzate per transformed_board in seguito, semplicemente modificando le funzioni di accesso.

probabilmente non è necessario memorizzare tutte le possibili trasformazioni in modo da poterle calcolare quando necessario quando si accede a loro

Se vuoi essere intelligente nell'accedere alle schede, puoi utilizzare una variante di trasformazioni di matrici:

int[6][MAX_SYMMETRIES] transforms={{ 1, 0, 0,
                                     0, 1, 0},
                                   { 0, 1, 0,
                                     1, 0, 0},
                                   {-1, 0, 7,
                                     0, 1, 0},...};

SQUARE_TYPE GetSquare(int[8][8]& board, int row, int column, int symmetry)
{
     assert(0<=row && row<MAX_ROWS);
     assert(0<=column && column <MAX_COLUMNS);
     assert(0<=symmetry&& symmetry<MAX_SYMMETRIES);

     int newRow = transforms[symmetry][0]*row+ transforms[symmetry][1]*column+ transforms[symmetry][2]
     int newCollumn = transforms[symmetry][3]*row+ transforms[symmetry][4]*column+ transforms[symmetry][5]

     return board[newRow][newCollumn];
}

puoi anche farlo con l'array 64 se necessario

Gli array a 1 dimensione o a 2 dimensioni hanno in realtà la stessa struttura dati in memoria.
Gli elementi saranno in un blocco di memoria contiguo. Quindi, per quanto riguarda le prestazioni, sarà lo stesso, se si utilizza la stessa indicizzazione.

2 dimensioni è probabilmente più facile da leggere e manipolare (più facile scrivere board [1] [3] che board [1 * 64 + 3])