2D -Array

Ein zweidimensionales (2D) -Array ist ein Array von einem dimensionalen (1D) Arrays. Die 1D -Arraygröß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:

Lassen Sie uns ein anderes Beispiel sehen:

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

Erklärung des 2D -Arrays

Datentyp Array-Namen[REIHE] [Col]

Datentyp ist der Datentyp der Array -Elemente.
Array-Name ist der Name des Arrays.
Zwei Indexs geben die Anzahl der Zeilen und Spalten des Arrays dar. Die Gesamtzahl der Elemente des Arrays ist eine Reihe*col.

int a [2] [3];

Mit dem obigen C -Code können wir eine deklarieren ganze Zahl Array, A von Größe 2*3 (2 Zeilen und 3 Spalten).

Char B [3] [2];

Mit dem obigen C -Code können wir a deklarieren Charakter Array, B von 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 Das Einweis muss angegeben werden. Die folgenden 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
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

//Beispiel 1.C
#enthalten
#define Reihe 3
#define col 2
int main ()

int i, j;
int a [row] [col] =
1,2,
3,4,
5,6
;
printf ("Zeilen weise Elemente des Arrays A sind: \ n");
für (i = 0; i
printf ("row %d:", i);
für (j = 0; J
printf (" %d", a [i] [j]);

printf ("\ n");

printf ("\ n \ ncolumn weise 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");

Rückkehr 0;

In Beispiel1.c, wir haben ein ganzzahliges Array der Größe 3*2 deklariert und initialisiert. Um auf Arrayelemente zuzugreifen, verwenden wir zwei für die Schleife.

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

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

Beachten Sie, dass wir beim Deklarieren eines 2D -Arrays eine [2] [3] verwenden, was 2 Zeilen und 3 Spalten bedeutet. Die Array -Indexierung beginnt ab 0. Zugriff auf die 2^nd Reihe und 3^Rd Spalte, wir müssen die Notation A [1] [2] verwenden.

Speicherzuordnung eines 2D -Arrays

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

Der Computerspeicher ist eine 1D -Abfolge von Bytes. In der C -Sprache ein 2D -Array -Speicher im Speicher in Reihen-Major-Bestellung. Einige andere Programmiersprachen (e.G., Fortran) speichert es in Säule-Major-Reihenfolge im Gedächtnis.

Zeigerarithmetik eines 2D -Arrays

Um die Zeigerarithmetik des 2D -Arrays zu verstehen, schauen Sie sich zunächst das 1D -Array an.

Betrachten Sie ein 1D -Array:

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

Wenn wir inkrementieren A Durch 1 wird es durch die Größe des Datentyps erhöht.

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

A [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
15
16
17
18
19
20
21

// Beispiel2.C
#enthalten
#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));
Rückkehr 0;

In Beispiel2.C, die Speicheradresse wird in hexadezimal angezeigt. Der Unterschied zwischen A und A+1 beträgt 4, was die Größe einer Ganzzahl in Bytes hat.

Betrachten Sie nun ein 2D -Array:

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

int [] [4] ist eine Reihe von 4 Ganzzahl. Wenn wir B um 1 erhöhen, wird es durch die Größe der Zeile erhöht.

B ist die Adresse der 0^th Reihe.

B+1 ist die Adresse der 1^st Reihe.

B+i ist die Adresse von ich^th Reihe.

Die Größe einer Reihe ist: (Anzahl der Spalten * Größe (Data-Typ)) Bytes

Größe einer Reihe eines Ganzzahl -Arrays B [3] [4] lautet: 4 * sizeof (int) = 4 * 4 = 16 Bytes

Eine Reihe eines 2D -Arrays kann als 1D -Array angesehen werden. B ist die Adresse der 0^th Reihe. Also bekommen wir Folgendes

*B+1 ist die Adresse der 1^st Element der 0^th
*b+j ist die Adresse der J^th Element der 0^th
*(b+i) ist die Adresse der 0^th Element der ich^th
*(b+i)+j ist die Adresse der J^th Element der ich^th
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 (Datentyp) * (Anzahl der Spalten * 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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Beispiel3.C
#enthalten
#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) );
Rückkehr 0;

In Beispiel3.c, wir haben gesehen, dass diese Größe einer Reihe 16 in Dezimalnotation beträgt. Der Unterschied zwischen B+1 und B beträgt 10 in Hexadezimal. 10 In Hexadezimal entspricht 16 in Dezimal.

Abschluss

In diesem Artikel haben wir also etwas gelernt

Erklärung des 2D -Arrays
Initialisierung des 2D -Arrays
Speicherzuordnung von 2D -Array
Zeigerarithmetik des 2D -Arrays

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

Verweise

Die Gutschrift für einige Ideen in dieser Arbeit wurde von dem Kurs, den Zeigern und den 2-D-Arrays inspiriert, von Palash Dey Department of Computer Science & Engg. Indian Institute of Technology Kharagpur

Docker

Wie man einen Docker -Container tötet?

Um einen Docker -Container zu töten, wählen Sie zunächst einen bestimmten Container, der getötet wer...

Stephan Harms

Java

Beispiele für Java Treemap

Praktisches Tutorial über die Methoden zum Einfügen, Entfernen und Drucken der Elemente des Java -Tr...

Stephan Harms

Bash -Programmierung

So finden Sie die Länge eines Arrays im Shell -Skript

Die drei Möglichkeiten, die Länge eines Array in Shell zu finden....

Jessica Schimmer