D Programmierung - Arrays

Die Programmiersprache D bietet eine Datenstruktur mit dem Namen arrays, in dem eine sequentielle Sammlung von Elementen desselben Typs mit fester Größe gespeichert wird. Ein Array wird zum Speichern einer Sammlung von Daten verwendet. Es ist oft sinnvoller, sich ein Array als eine Sammlung von Variablen desselben Typs vorzustellen.

Anstatt einzelne Variablen wie Nummer 0, Nummer 1, ... und Nummer 99 zu deklarieren, deklarieren Sie eine Array-Variable wie Zahlen und verwenden Zahlen [0], Zahlen [1] und ..., Zahlen [99] zur Darstellung einzelne Variablen. Auf ein bestimmtes Element in einem Array wird über einen Index zugegriffen.

Alle Arrays bestehen aus zusammenhängenden Speicherstellen. Die niedrigste Adresse entspricht dem ersten Element und die höchste Adresse dem letzten Element.

Arrays deklarieren

Um ein Array in der Programmiersprache D zu deklarieren, gibt der Programmierer den Typ der Elemente und die Anzahl der für ein Array erforderlichen Elemente wie folgt an:

type arrayName [ arraySize ];

Dies wird als eindimensionales Array bezeichnet. Die arraySize muss eine Ganzzahlkonstante größer als Null sein und der Typ kann ein beliebiger gültiger Datentyp der Programmiersprache D sein. Verwenden Sie diese Anweisung, um beispielsweise ein Array mit 10 Elementen zu deklarieren, das als Balance vom Typ double bezeichnet wird.

double balance[10];

Arrays initialisieren

Sie können D-Programmiersprachen-Array-Elemente entweder einzeln oder mit einer einzelnen Anweisung wie folgt initialisieren

double balance[5] = [1000.0, 2.0, 3.4, 17.0, 50.0];

Die Anzahl der Werte zwischen eckigen Klammern [] auf der rechten Seite darf nicht größer sein als die Anzahl der Elemente, die Sie für das Array zwischen eckigen Klammern [] deklarieren. Im folgenden Beispiel wird ein einzelnes Element des Arrays zugewiesen.

Wenn Sie die Größe des Arrays weglassen, wird ein Array erstellt, das gerade groß genug ist, um die Initialisierung aufzunehmen. Deshalb, wenn Sie schreiben

double balance[] = [1000.0, 2.0, 3.4, 17.0, 50.0];

Dann erstellen Sie genau das gleiche Array wie im vorherigen Beispiel.

balance[4] = 50.0;

Die obige Anweisung weist dem Element Nummer 5 im Array einen Wert von 50,0 zu. Array mit 4. Index ist 5., dh letztes Element, da alle Arrays 0 als Index ihres ersten Elements haben, das auch als Basisindex bezeichnet wird. Die folgende bildliche Darstellung zeigt dasselbe Array, das wir oben besprochen haben -

Zugriff auf Array-Elemente

Auf ein Element wird zugegriffen, indem der Arrayname indiziert wird. Dazu wird der Index des Elements in eckige Klammern nach dem Namen des Arrays gesetzt. Zum Beispiel -

double salary = balance[9];

Die obige Erklärung nimmt 10 - ^te Element aus dem Array und weist den Wert des variablen Gehalt . Im folgenden Beispiel werden Deklaration, Zuweisung und Zugriff auf Arrays implementiert.

import std.stdio;  
void main() { 
   int n[ 10 ]; // n is an array of 10 integers  
   
   // initialize elements of array n to 0 
   for ( int i = 0; i < 10; i++ ) { 
      n[ i ] = i + 100; // set element at location i to i + 100 
   }
   
   writeln("Element \t Value");
   
   // output each array element's value 
   for ( int j = 0; j < 10; j++ ) { 
      writeln(j," \t ",n[j]); 
   } 
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Element   Value 
0         100 
1         101 
2         102 
3         103 
4         104 
5         105 
6         106 
7         107 
8         108 
9         109

Statische Arrays versus dynamische Arrays

Wenn beim Schreiben eines Programms die Länge eines Arrays angegeben wird, handelt es sich bei diesem Array um ein statisches Array. Wenn sich die Länge während der Ausführung des Programms ändern kann, ist dieses Array ein dynamisches Array.

Das Definieren dynamischer Arrays ist einfacher als das Definieren von Arrays mit fester Länge, da das Weglassen der Länge ein dynamisches Array ergibt.

int[] dynamicArray;

Array-Eigenschaften

Hier sind die Eigenschaften von Arrays -

Sr.Nr.	Objektbeschreibung
1	.init Das statische Array gibt ein Array-Literal zurück, wobei jedes Element des Literal die Eigenschaft .init des Array-Elementtyps ist.
2	.sizeof Statisches Array gibt die Array-Länge multipliziert mit der Anzahl der Bytes pro Array-Element zurück, während dynamische Arrays die Größe der dynamischen Array-Referenz zurückgeben, die 8 in 32-Bit-Builds und 16 in 64-Bit-Builds beträgt.
3	.length Statisches Array gibt die Anzahl der Elemente im Array zurück, während dynamische Arrays zum Abrufen / Festlegen der Anzahl der Elemente im Array verwendet werden. Die Länge ist vom Typ size_t.
4	.ptr Gibt einen Zeiger auf das erste Element des Arrays zurück.
5	.dup Erstellen Sie ein dynamisches Array derselben Größe und kopieren Sie den Inhalt des Arrays hinein.
6	.idup Erstellen Sie ein dynamisches Array derselben Größe und kopieren Sie den Inhalt des Arrays hinein. Die Kopie wird als unveränderlich eingegeben.
7	.reverse Kehrt die Reihenfolge der Elemente im Array um. Gibt das Array zurück.
8	.sort Sortiert die Reihenfolge der Elemente im Array. Gibt das Array zurück.

Beispiel

Im folgenden Beispiel werden die verschiedenen Eigenschaften eines Arrays erläutert.

import std.stdio;

void main() {
   int n[ 5 ]; // n is an array of 5 integers 
   
   // initialize elements of array n to 0 
   for ( int i = 0; i < 5; i++ ) { 
      n[ i ] = i + 100; // set element at location i to i + 100 
   }
   
   writeln("Initialized value:",n.init); 
   
   writeln("Length: ",n.length); 
   writeln("Size of: ",n.sizeof); 
   writeln("Pointer:",n.ptr); 
   
   writeln("Duplicate Array: ",n.dup); 
   writeln("iDuplicate Array: ",n.idup);
   
   n = n.reverse.dup; 
   writeln("Reversed Array: ",n);
   
   writeln("Sorted Array: ",n.sort); 
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Initialized value:[0, 0, 0, 0, 0] 

Length: 5 
Size of: 20 

Pointer:7FFF5A373920 
Duplicate Array: [100, 101, 102, 103, 104]
iDuplicate Array: [100, 101, 102, 103, 104] 
Reversed Array: [104, 103, 102, 101, 100] 
Sorted Array: [100, 101, 102, 103, 104]

Mehrdimensionale Arrays in D.

Die D-Programmierung ermöglicht mehrdimensionale Arrays. Hier ist die allgemeine Form einer mehrdimensionalen Array-Deklaration -

type name[size1][size2]...[sizeN];

Beispiel

Die folgende Deklaration erzeugt eine dreidimensionale 5. 10. 4 Integer Array -

int threedim[5][10][4];

Zweidimensionale Arrays in D.

Die einfachste Form des mehrdimensionalen Arrays ist das zweidimensionale Array. Ein zweidimensionales Array ist im Wesentlichen eine Liste eindimensionaler Arrays. Um ein zweidimensionales ganzzahliges Array der Größe [x, y] zu deklarieren, schreiben Sie die Syntax wie folgt:

type arrayName [ x ][ y ];

Wo type kann ein beliebiger gültiger D-Programmierdatentyp sein und arrayName wird eine gültige D-Programmierkennung sein.

Wobei Typ ein beliebiger gültiger D-Programmierdatentyp sein kann und arrayName eine gültige D-Programmierkennung ist.

Ein zweidimensionales Array kann als Tabelle betrachtet werden, die x Zeilen und y Spalten enthält. Ein zweidimensionales Arraya mit drei Zeilen und vier Spalten kann wie folgt dargestellt werden -

Somit ist jedes Element im Array a wird durch ein Element als identifiziert a[ i ][ j ], wo a ist der Name des Arrays und i und j sind die Indizes, die jedes Element in a eindeutig identifizieren.

Initialisieren zweidimensionaler Arrays

Mehrdimensionale Arrays können durch Angabe von Werten in Klammern für jede Zeile initialisiert werden. Das folgende Array hat 3 Zeilen und jede Zeile hat 4 Spalten.

int a[3][4] = [   
   [0, 1, 2, 3] ,   /*  initializers for row indexed by 0 */ 
   [4, 5, 6, 7] ,   /*  initializers for row indexed by 1 */ 
   [8, 9, 10, 11]   /*  initializers for row indexed by 2 */ 
];

Die verschachtelten geschweiften Klammern, die die beabsichtigte Zeile angeben, sind optional. Die folgende Initialisierung entspricht dem vorherigen Beispiel -

int a[3][4] = [0,1,2,3,4,5,6,7,8,9,10,11];

Zugriff auf zweidimensionale Array-Elemente

Auf ein Element in einem zweidimensionalen Array wird mithilfe der Indizes zugegriffen, dh Zeilenindex und Spaltenindex des Arrays. Zum Beispiel

int val = a[2][3];

Die obige Anweisung übernimmt das 4. Element aus der 3. Zeile des Arrays. Sie können dies im obigen Digramm überprüfen.

import std.stdio; 
  
void main () { 
   // an array with 5 rows and 2 columns. 
   int a[5][2] = [ [0,0], [1,2], [2,4], [3,6],[4,8]];  
   
   // output each array element's value                       
   for ( int i = 0; i < 5; i++ ) for ( int j = 0; j < 2; j++ ) {
      writeln( "a[" , i , "][" , j , "]: ",a[i][j]); 
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

a[0][0]: 0 
a[0][1]: 0 
a[1][0]: 1 
a[1][1]: 2 
a[2][0]: 2 
a[2][1]: 4 
a[3][0]: 3 
a[3][1]: 6 
a[4][0]: 4 
a[4][1]: 8

Allgemeine Array-Operationen in D.

Hier sind verschiedene Operationen, die an den Arrays ausgeführt werden -

Array Slicing

Wir verwenden oft einen Teil eines Arrays und das Schneiden von Arrays ist oft sehr hilfreich. Ein einfaches Beispiel für das Aufteilen von Arrays ist unten dargestellt.

import std.stdio;
  
void main () { 
   // an array with 5 elements. 
   double a[5] = [1000.0, 2.0, 3.4, 17.0, 50.0]; 
   double[] b;
   
   b = a[1..3]; 
   writeln(b); 
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

[2, 3.4]

Array-Kopieren

Wir verwenden auch das Kopieren von Arrays. Ein einfaches Beispiel für das Kopieren von Arrays ist unten dargestellt.

import std.stdio;

void main () { 
   // an array with 5 elements. 
   double a[5] = [1000.0, 2.0, 3.4, 17.0, 50.0]; 
   double b[5]; 
   writeln("Array a:",a); 
   writeln("Array b:",b);  
   
   b[] = a;      // the 5 elements of a[5] are copied into b[5] 
   writeln("Array b:",b);  
   
   b[] = a[];   // the 5 elements of a[3] are copied into b[5] 
   writeln("Array b:",b); 
   
   b[1..2] = a[0..1]; // same as b[1] = a[0] 
   writeln("Array b:",b); 
   
   b[0..2] = a[1..3]; // same as b[0] = a[1], b[1] = a[2]
   writeln("Array b:",b); 
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Array a:[1000, 2, 3.4, 17, 50] 
Array b:[nan, nan, nan, nan, nan] 
Array b:[1000, 2, 3.4, 17, 50] 
Array b:[1000, 2, 3.4, 17, 50] 
Array b:[1000, 1000, 3.4, 17, 50] 
Array b:[2, 3.4, 3.4, 17, 50]

Array-Einstellung

Ein einfaches Beispiel zum Festlegen eines Werts in einem Array ist unten dargestellt.

import std.stdio;

void main () { 
   // an array with 5 elements. 
   double a[5]; 
   a[] = 5; 
   writeln("Array a:",a); 
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Array a:[5, 5, 5, 5, 5]

Array-Verkettung

Ein einfaches Beispiel für die Verkettung von zwei Arrays ist unten dargestellt.

import std.stdio;

void main () { 
   // an array with 5 elements. 
   double a[5] = 5; 
   double b[5] = 10; 
   double [] c; 
   c = a~b; 
   writeln("Array c: ",c); 
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Array c: [5, 5, 5, 5, 5, 10, 10, 10, 10, 10]