Griglie, array a due dimensioni

Un array di array

Una scacchiera, il tabellone del tris, una mappa di un videogioco, un foglio di calcolo: sono tutti griglie, righe e colonne. Per rappresentarle basta un’idea che conosci già: un array i cui elementi sono, a loro volta, array.

int[4][3] grid;

Il trucco per leggere questa dichiarazione è partire da sinistra, come si costruisce il tipo: int[4] è una riga di 4 interi; int[4][3] sono 3 di quelle righe. Quindi una griglia di 3 righe per 4 colonne.

Per raggiungere una casella servono due indici: prima la riga, poi la colonna.

grid[1][2] = 5;    // row 1, column 2
io::printn(grid);
io::printfn("rows: %d, columns: %d", grid.len, grid[0].len);

[[0, 0, 0, 0], [0, 0, 5, 0], [0, 0, 0, 0]]
rows: 3, columns: 4

grid[1] è la seconda riga, un int[4]; grid[1][2] è la terza casella di quella riga. E grid.len conta le righe, mentre grid[0].len conta le colonne (quanti elementi ha una riga).

Inizializzare una griglia

I valori si scrivono riga per riga, con un paio di graffe per ogni riga. Andare a capo aiuta a vedere la forma della griglia:

int[3][2] table = {
	{ 1, 2, 3 },
	{ 4, 5, 6 },
};
io::printn(table[1][0]);

4

int[3][2]: 2 righe da 3. Se inverti le dimensioni per abitudine dal C, il compilatore trova il numero di righe sbagliato:

int[3][2] bad = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
// error: Too many (3) elements in initializer, expected 2.

(La virgola dopo l’ultima riga, in table, è facoltativa: C3 la accetta, ed è comoda quando aggiungi righe.)

Scorrere righe e colonne

Una griglia si scorre con due cicli, uno dentro l’altro: quello esterno prende le righe, quello interno le caselle di ogni riga. Con foreach è quasi una traduzione della frase “per ogni riga, per ogni valore”:

foreach (row : table)
{
	foreach (value : row) io::printf("%3d", value);
	io::printn();
}

  1  2  3
  4  5  6

Ricordi %3d dal modulo 1? Larghezza minima 3, per incolonnare i numeri. L’io::printn() dopo il ciclo interno va a capo alla fine di ogni riga.

Se ti servono le coordinate, usa la forma con l’indice, o un for classico. Nell’esercizio finale della lezione ti serviranno per guardare le caselle vicine, quindi lì il for con r e c sarà più comodo.

Una griglia di caratteri

Una riga di caratteri si può inizializzare con una stringa tra virgolette: è il modo più leggibile per disegnare una mappa.

char[3][3] board = {
	"X.O",
	".X.",
	"O.X",
};
board[0][1] = 'O';
foreach (row : board)
{
	foreach (cell : row) io::printf("%c", cell);
	io::printn();
}

XOO
.X.
O.X

Ogni stringa deve avere esattamente la lunghezza della riga, qui 3 caratteri. E le caselle si modificano come quelle di qualsiasi array, con un carattere tra apici singoli: 'O'.

Passare una griglia a una funzione

Anche qui le slice fanno il loro lavoro. Una funzione che riceve int[3][] accetta un numero qualsiasi di righe da 3:

fn int total(int[3][] rows)
{
	int sum = 0;
	foreach (row : rows)
	{
		foreach (v : row) sum += v;
	}
	return sum;
}

io::printn(total(&table));       // 1 + 2 + ... + 6
io::printn(total(table[1..]));   // only the second row

21
15

Il numero di righe è libero, la lunghezza di ogni riga no: fa parte del tipo degli elementi.

const int ROWS = 4;
const int COLS = 6;

char[COLS][ROWS] field = {
	"*.....",
	"..*...",
	"....*.",
	"*....*",
};

import std::io;

const int ROWS = 4;
const int COLS = 6;

fn void main()
{
	char[COLS][ROWS] field = {
		"*.....",
		"..*...",
		"....*.",
		"*....*",
	};

	for (int r = 0; r < ROWS; r++)
	{
		for (int c = 0; c < COLS; c++)
		{
			if (field[r][c] == '*')
			{
				io::print("*");
				continue;
			}
			int count = 0;
			for (int dr = -1; dr <= 1; dr++)
			{
				for (int dc = -1; dc <= 1; dc++)
				{
					int nr = r + dr;
					int nc = c + dc;
					if (nr < 0 || nr >= ROWS || nc < 0 || nc >= COLS) continue;
					if (field[nr][nc] == '*') count++;
				}
			}
			if (count == 0)
			{
				io::print(".");
			}
			else
			{
				io::printf("%d", count);
			}
		}
		io::printn();
	}
}

Ricapitolando

• int[4][3] sono 3 righe da 4: il tipo si legge da sinistra, al contrario della dichiarazione in C.
• L’accesso è grid[riga][colonna]; grid.len conta le righe, grid[0].len le colonne.
• Si inizializza riga per riga, con graffe annidate; le righe di char anche con stringhe della lunghezza giusta.
• Si scorre con due cicli annidati; per le vicine di una casella, attenzione ai bordi.
• In memoria una griglia è una fila unica, riga dopo riga. Una funzione può ricevere int[4][]: righe libere, colonne fisse.

Nei char della mappa c’era un indizio: una stringa è una fila di byte. Nella prossima lezione guardiamo le stringhe da vicino.