Matrice 2D

Un array bidimensionale (2D) è un array di array monodimensionali (1D). Le dimensioni dell'array 1D sono uguali. L'array 2D è anche chiamato matrice con righe e colonne.

Vediamo il seguente esempio:

Questi 3 array 1D possono essere rappresentati come array 2D come segue:

Vediamo un altro esempio:

Questi 3 array 1D non possono essere rappresentati come array 2D perché le dimensioni degli array sono diverse.

Dichiarazione dell'array 2D

tipo di dati nome-array[RIGA][COL]

Tipo di dati è il tipo di dati degli elementi dell'array.
Array-name è il nome dell'array.
Due pedici rappresentano il numero di righe e colonne dell'array. Il numero totale di elementi dell'array sarà ROW*COL.

int a[2][3];

Usando il codice C sopra, possiamo dichiarare an numero intero Vettore, un di taglia 2*3 (2 righe e 3 colonne).

carattere b[3][2];

Usando il codice C sopra, possiamo dichiarare a personaggio Vettore, b di taglia 2*3 (3 righe e 2 colonne).

Inizializzazione dell'array 2D

Possiamo inizializzare durante la dichiarazione nei seguenti modi:

int a[3][2] = 1,2,3,4,5,6;
int a[][2] = 1,2,3,4,5,6;
int a[3][2] = 1, 2,3, 4,5, 6;
int a[][2] = 1, 2,3, 4,5, 6;

Nota che in 2 e 4 non abbiamo menzionato l'1^sto pedice. Il compilatore C calcola automaticamente il numero di righe dal numero di elementi. Ma il 2^nd deve essere specificato il pedice. Le seguenti inizializzazioni non sono valide:

int a[3][] = 1,2,3,4,5,6;
int a[][] = 1,2,3,4,5,6;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

//Esempio 1.c
#includere
#define RIGA 3
#define COL 2
intero principale()

int io,j;
int a[RIGA][COL] =
1,2,
3,4,
5,6
;
printf("Gli elementi per riga dell'array a sono :\n");
for(i=0;i
printf("Riga %d:",i);
for(j=0;j
printf("%d",a[i][j]);

printf("\n");

printf("\n\nGli elementi a colonna dell'array a sono :\n");
for(i=0;i
printf("Colonna %d:",i);
for(j=0;j
printf("%d",a[j][i]);

printf("\n");

restituisce 0;

Nell'esempio1.c, abbiamo dichiarato un array intero di dimensione 3*2 e inizializzato. Per accedere agli elementi dell'array, usiamo due for loop.

Per accedere a livello di riga, il ciclo esterno è per le righe e il ciclo interno è per le colonne.

Per accedere a livello di colonna, il ciclo esterno è per le colonne e il ciclo interno è per le righe.

Nota che quando dichiariamo un array 2D, usiamo a[2][3], che significa 2 righe e 3 colonne. L'indicizzazione dell'array inizia da 0. Per accedere al 2^nd riga e 3^rd colonna, dobbiamo usare la notazione a[1][2].

Mappatura della memoria di un array 2D

La vista logica di un array un[3][2] può essere il seguente:

La memoria del computer è una sequenza 1D di byte. In linguaggio C, un array 2D memorizza nella memoria in ordine principale. Alcuni altri linguaggi di programmazione (e.g., FORTRAN), memorizza in ordine maggiore di colonna nella memoria.

Aritmetica del puntatore di un array 2D

Per comprendere l'aritmetica del puntatore dell'array 2D, per prima cosa dai un'occhiata all'array 1D.

Considera un array 1D:

Nella matrice 1D, un è una costante e il suo valore è l'indirizzo dello 0^questo posizione dell'array un[5]. Valore di a+1 è l'indirizzo del 1^sto posizione dell'array un[5]. a+i è l'indirizzo del io^questo posizione dell'array.

Se incrementiamo un di 1, viene incrementato della dimensione del tipo di dati.

un[1] è equivalente a *(a+1)

un[2] è equivalente a *(a+2)

un[io] è equivalente a *(a+i)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

//Esempio2.c
#includere
#define RIGA 3
#define COL 2
intero principale()

int a[5]=10,20,30,40,50;
printf("sizeof(int): %ld\n\n",sizeof(int));
printf("a: %p\n",a);
printf("a+1: %p\n",a+1);
printf("a+2: %p\n\n",a+2);
printf("a[1]: %d, *(a+1): %d\n",a[1],*(a+1));
printf("a[2]: %d, *(a+2): %d\n",a[1],*(a+1));
printf("a[3]: %d, *(a+3): %d\n",a[1],*(a+1));
restituisce 0;

Nell'esempio2.c, l'indirizzo di memoria viene visualizzato in esadecimale. La differenza tra a e a+1 è 4, che è la dimensione di un numero intero in byte.

Ora, considera un array 2D:

b è un puntatore di tipo: int[ ][4] o intero(*)[4]

int[ ][4] è una riga di 4 interi. Se incrementiamo b di 1, viene incrementato della dimensione della riga.

b è l'indirizzo del 0^questo riga.

b+1 è l'indirizzo del 1^sto riga.

b+io è l'indirizzo di io^questo riga.

La dimensione di una riga è: (Numero di colonne * sizeof (tipo di dati)) byte

La dimensione di una riga di un array di interi b[3][4] è: 4 * sizeof(int) = 4 * 4 = 16 byte

Una riga di un array 2D può essere vista come un array 1D. b è l'indirizzo del 0^questo riga. Quindi, otteniamo quanto segue

*b+1 è l'indirizzo del 1^sto elemento del 0^questo
*b+j è l'indirizzo del j^questo elemento del 0^questo
*(b+i) è l'indirizzo del 0^questo elemento del io^questo
*(b+i)+j è l'indirizzo del j^questo elemento del io^questo
b[0][0] è equivalente a **b
b[0][1] è equivalente a *(*b+1)
b[1][0] è equivalente a *(*(b+1))
b[1][1] è equivalente a *(*(b+1)+1)
b[i][j] è equivalente a *(*(b+i)+j)

Indirizzo di b[i][j]: b + sizeof (tipo di dati) * ( Numero di colonne * i + j)

Considera un array 2D: int b[3][4]

L'indirizzo di b[2][1] è : b + sizeof(int) * (4*2 + 1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

//Esempio3.c
#includere
#define RIGA 3
#define COL 4
intero principale()

int io,j;
int b[RIGA][COL] =
10,20,30,40,
50,60,70,80,
90,100,110,120
;
printf("sizeof(int): %ld\n",sizeof(int));
printf("Dimensione di una riga: %ld\n",COL*sizeof(int));
printf("b: %p\n",b);
printf("b+1: %p\n",b+1);
printf("b+2: %p\n",b+2);
printf("*b: %p\n",*b);
printf("*b+1: %p\n",*b+1);
printf("*b+2: %p\n",*b+2);
printf("b[0][0]: %d **b: %d\n",b[0][0],**b);
printf("b[0][1]: %d *(*b+1): %d\n",b[0][1],*(*b+1));
printf("b[0][2]: %d *(*b+2): %d\n",b[0][2],*(*b+2));
printf("b[1][0]: %d *(*(b+1)): %d\n",b[1][0],*(*(b+1)));
printf("b[1][1]: %d *(*(b+1)+1): %d\n",b[1][1],*(*(b+1)+1) );
restituisce 0;

Nell'esempio 3.c, abbiamo visto che la dimensione di una riga è 16 in notazione decimale. La differenza tra b+1 e b è 10 in esadecimale. 10 in esadecimale equivale a 16 in decimale.

Conclusione

Quindi, in questo articolo, abbiamo appreso di

Dichiarazione dell'array 2D
Inizializzazione dell'array 2D
Mappatura della memoria dell'array 2D
Aritmetica del puntatore dell'array 2D

Ora possiamo usare l'array 2D nel nostro programma C senza alcun dubbio,

Riferimenti

Il credito per alcune idee in questo lavoro è stato ispirato dal corso, Pointers and 2-D Arrays, di Palash Dey Department of Computer Science & Engg. Istituto indiano di tecnologia Kharagpur