2D-Array

Ein zweidimensionales (2D) Array ist ein Array von eindimensionalen (1D) Arrays. Die 1D-Array-Größen sind gleich. Das 2D-Array wird auch als Matrix mit Zeilen und Spalten bezeichnet.

Sehen wir uns das folgende Beispiel an:

Diese 3 1D-Arrays können wie folgt als 2D-Array dargestellt werden:

Sehen wir uns ein anderes Beispiel an:

Diese 3 1D-Arrays können nicht als 2D-Array dargestellt werden, da die Größen der Arrays unterschiedlich sind.

Deklaration des 2D-Arrays

Datentyp Array-Name[REIHE][COL]

Datentyp ist der Datentyp der Array-Elemente.
Array-Name ist der Name des Arrays.
Zwei tiefgestellte Indizes repräsentieren die Anzahl der Zeilen und Spalten des Arrays. Die Gesamtzahl der Elemente des Arrays ist ROW*COL.

int a[2][3];

Mit dem obigen C-Code können wir an we deklarieren ganze Zahl Array, ein der Größe 2*3 (2 Zeilen und 3 Spalten).

Zeichen b[3] [2];

Mit dem obigen C-Code können wir a . deklarieren Charakter Array, b der Größe 2*3 (3 Zeilen und 2 Spalten).

Initialisierung des 2D-Arrays

Wir können während der Deklaration auf folgende Weise initialisieren:

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;

Beachten Sie, dass wir in 2 und 4 die 1 nicht erwähnt haben^st Index. Der C-Compiler berechnet automatisch die Anzahl der Zeilen aus der Anzahl der Elemente. Aber die 2^nd tiefgestellt muss angegeben werden. Folgende Initialisierungen sind ungültig:

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
fünfzehn
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

//Beispiel 1.c
#einschließen
#define REIHE 3
#define COL 2
int main()

int i, j;
int a[ROW][COL] =
1,2,
3,4,
5,6
;
printf("Zeilenweise Elemente des Arrays a sind :\n");
für(i=0;i
printf("Zeile %d:",i);
für(j=0;j
printf(" %d",a[i][j]);

printf("\n");

printf("\n\nSpaltenweise Elemente des Arrays a sind :\n");
für(i=0;i
printf("Spalte %d:",i);
für(j=0;j
printf(" %d",a[j][i]);

printf("\n");

0 zurückgeben;

In Beispiel1.c haben wir ein ganzzahliges Array der Größe 3*2 deklariert und initialisiert. Um auf Array-Elemente zuzugreifen, verwenden wir zwei for-Schleifen.

Um zeilenweise zuzugreifen, ist die äußere Schleife für Zeilen und die innere Schleife für Spalten.

Für den spaltenweisen Zugriff gilt die äußere Schleife für Spalten und die innere Schleife für Zeilen.

Beachten Sie, dass wir bei der Deklaration eines 2D-Arrays a[2][3] verwenden, was 2 Zeilen und 3 Spalten bedeutet. Die Array-Indizierung beginnt bei 0. Um auf die 2 . zuzugreifen^nd Reihe und 3^rd Spalte müssen wir die Notation a[1][2] verwenden.

Speicherabbildung eines 2D-Arrays

Die logische Ansicht eines Arrays ein[3] [2] kann wie folgt sein:

Computerspeicher ist eine 1D-Sequenz von Bytes. In der Sprache C speichert ein 2D-Array im Speicher in Reihen-Großauftrag. Einige andere Programmiersprachen (z.G., FORTRAN), es speichert in Spalte-Hauptauftrag in der erinnerung.

Zeigerarithmetik eines 2D-Arrays

Um die Zeigerarithmetik des 2D-Arrays zu verstehen, werfen Sie zunächst einen Blick auf das 1D-Array.

Betrachten Sie ein 1D-Array:

Im 1D-Array, ein ist eine Konstante und ihr Wert ist die Adresse der 0^das Standort des Arrays ein[5]. Wert von a+1 ist die Adresse der 1^st Standort des Arrays ein[5]. a+i ist die Adresse des ich^das Standort des Arrays.

Wenn wir inkrementieren ein um 1 wird um die Größe des Datentyps erhöht.

ein[1] ist äquivalent zu *(a+1)

ein[2] ist äquivalent zu *(a+2)

a[i] ist äquivalent zu *(a+i)

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

//Beispiel2.c
#einschließen
#define REIHE 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));
0 zurückgeben;

In Beispiel2.c, die Speicheradresse wird hexadezimal angezeigt. Der Unterschied zwischen a und a+1 ist 4, das ist die Größe einer ganzen Zahl in Bytes.

Betrachten Sie nun ein 2D-Array:

b ist ein Zeiger vom Typ: int[ ][4] oder int(*)[4]

int[ ][4] ist eine Reihe von 4 ganzen. Wenn wir b um 1 inkrementieren, wird es um die Größe der Zeile inkrementiert.

b ist die Adresse des 0^das Reihe.

b+1 ist die Adresse des 1^st Reihe.

b+i ist die Adresse von ich^das Reihe.

Die Zeilengröße beträgt: (Anzahl der Spalte * sizeof(data-type)) bytes

Die Größe einer Zeile eines Integer-Arrays b[3][4] beträgt: 4 * sizeof(int) = 4 * 4 = 16 Byte

Eine Zeile eines 2D-Arrays kann als 1D-Array angesehen werden. b ist die Adresse des 0^das Reihe. Wir erhalten also Folgendes

*b+1 ist die Adresse des 1^st Element der 0^das
*b+j ist die Adresse des j^das Element der 0^das
*(b+i) ist die Adresse des 0^das Element der ich^das
*(b+i)+j ist die Adresse des j^das Element der ich^das
b[0][0] entspricht **b
b[0][1] entspricht *(*b+1)
b[1][0] entspricht *(*(b+1))
b[1][1] entspricht *(*(b+1)+1)
b[i][j] entspricht *(*(b+i)+j)

Adresse von b[i][j]: b + sizeof(data-type) * ( Spaltenanzahl * i + j)

Betrachten Sie ein 2D-Array: int b[3] [4]

Adresse von b[2][1] ist : b + sizeof(int) * (4*2 + 1)

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

//Beispiel3.c
#einschließen
#define REIHE 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("Größe einer Zeile: %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) );
0 zurückgeben;

In Beispiel3.c, wir haben gesehen, dass die Größe einer Zeile in Dezimalschreibweise 16 beträgt. Der Unterschied zwischen b+1 und b beträgt hexadezimal 10. 10 in hexadezimal entspricht 16 in dezimal.

Fazit

In diesem Artikel haben wir also etwas über . erfahren

Deklaration des 2D-Arrays
Initialisierung des 2D-Arrays
Speicherzuordnung des 2D-Arrays
Zeigerarithmetik des 2D-Arrays

Jetzt können wir ohne Zweifel 2D-Arrays in unserem C-Programm verwenden,

Verweise

Einige Ideen in dieser Arbeit wurden durch den Kurs Pointers and 2-D Arrays von Palash Dey, Department of Computer Science & Engg . inspiriert. Indisches Technologieinstitut Kharagpur