Array 2D

Sarita Negri

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 un array 2D come segue:

Vediamo un altro esempio:

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

Dichiarazione di array 2D

tipo di dati Array-Name[RIGA] [COL"

Tipo di dati è il tipo di dati degli elementi dell'array.
Array-Name è il nome dell'array.
Due abbonamenti rappresentano il numero di righe e colonne dell'array. Il numero totale di elementi dell'array sarà riga*Col.

int a [2] [3];

Usando il codice C sopra, possiamo dichiarare un numero intero vettore, UN di dimensioni 2*3 (2 righe e 3 colonne).

Char B [3] [2];

Usando il codice C sopra, possiamo dichiarare a carattere vettore, B di dimensioni 2*3 (3 righe e 2 colonne).

Inizializzazione di 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;

Si noti che in 2 e 4 non abbiamo menzionato il 1^st Sobbrotteria. Il compilatore C calcola automaticamente il numero di righe dal numero di elementi. Ma il 2^nd Il pedice deve essere specificato. 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
int main ()

int i, j;
int a [riga] [col] =
1,2,
3,4,
5,6
;
printf ("elementi saggi di riga dell'array a sono: \ n");
per (i = 0; i
printf ("riga %d:", i);
per (j = 0; j
printf (" %d", a [i] [j]);

printf ("\ n");

printf ("\ n \ nColumn Elements of the Array a are: \ n");
per (i = 0; i
printf ("colonna %d:", i);
per (j = 0; j
printf (" %d", a [j] [i]);

printf ("\ n");

restituzione 0;

Nell'esempio1.C, abbiamo dichiarato una matrice intera di dimensione 3*2 e inizializzato. Per accedere agli elementi dell'array, ne usiamo due per loop.

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

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

Si noti che quando dichiariamo un array 2D, utilizziamo un [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 A [3] [2] può essere il seguente:

La memoria del computer è una sequenza 1D di byte. In lingua C, un negozio di array 2D nella memoria in Ordine di riga-Major. Alcuni altri linguaggi di programmazione (E.G., Fortran), memorizza in Ordine di colonna-Major nella memoria.

Puntatore aritmetico di un array 2d

Per capire l'aritmetica puntatore dell'array 2D, prima, dai un'occhiata all'array 1D.

Considera un array 1D:

In un array 1D, UN è una costante e il suo valore è l'indirizzo di 0^th Posizione dell'array a [5]. Valore di A+1 è l'indirizzo del 1^st Posizione dell'array a [5]. a+i è l'indirizzo del io^th Posizione dell'array.

Se incrediamo UN di 1, è incrementato dalla dimensione del tipo di dati.

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

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

a [i] è 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
int main ()

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));
restituzione 0;

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

Ora, considera un array 2D:

B è un puntatore di tipo: int [] [4] O int (*) [4]

int [] [4] è una fila di 4 interi. Se incrediamo B di 1, è incrementato dalla dimensione della riga.

B è l'indirizzo del 0^th riga.

B+1 è l'indirizzo del 1^st riga.

b+i è l'indirizzo di io^th riga.

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

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

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

*B+1 è l'indirizzo del 1^st elemento del 0^th
*B+J è l'indirizzo del J^th elemento del 0^th
*(B+i) è l'indirizzo del 0^th elemento del io^th
*(b+i)+j è l'indirizzo del J^th elemento del io^th
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 colonna * 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
int main ()

int i, j;
int b [row] [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) );
restituzione 0;

Nell'esempio3.C, abbiamo visto quella 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 imparato

Dichiarazione di array 2D
Inizializzazione di array 2D
Mappatura della memoria di array 2D
Puntatore aritmetico di array 2d

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

Riferimenti

Il merito di alcune idee in questo lavoro è stato ispirato dal corso, dai puntatori e dalle array 2-D, dal Dipartimento di Informatica e Engg di Palash Dey. Indian Institute of Technology Kharagpur

Sqlite

A cosa serve sqlite? È meglio di SQL?

SQLite è un database basato su file autonomo, senza server e non richiede alcuna installazione separ...

Nick Marini

Programmazione C

Cos'è l'indirizzo di memoria nella programmazione C e come trovarlo?

Indirizzo di memoria nella programmazione C si riferisce alla posizione in cui i dati sono archiviat...

Dr. Folco Leone

Powershell

Quali sono i passaggi per eseguire comandi remoti in PowerShell?

I comandi remoti possono essere eseguiti abilitando la remoto di PowerShell. Per abilitare PowerShel...

Dr. Ursula Marini