Programmazione D - Array
Il linguaggio di programmazione D fornisce una struttura dati, denominata arrays, che memorizza una raccolta sequenziale di dimensioni fisse di elementi dello stesso tipo. Un array viene utilizzato per memorizzare una raccolta di dati. Spesso è più utile pensare a un array come a una raccolta di variabili dello stesso tipo.
Invece di dichiarare variabili individuali, come numero0, numero1, ... e numero99, dichiari una variabile di matrice come numeri e utilizzi numeri [0], numeri [1] e ..., numeri [99] per rappresentare variabili individuali. Un elemento specifico in un array è accessibile da un indice.
Tutti gli array sono costituiti da posizioni di memoria contigue. L'indirizzo più basso corrisponde al primo elemento e l'indirizzo più alto all'ultimo elemento.
Dichiarazione di array
Per dichiarare un array in linguaggio di programmazione D, il programmatore specifica il tipo di elementi e il numero di elementi richiesti da un array come segue:
type arrayName [ arraySize ];Questo è chiamato array monodimensionale. L'arraysize deve essere un numero intero costante maggiore di zero e tipo può essere qualsiasi tipo di programmazione D dati lingua valido. Ad esempio, per dichiarare un array di 10 elementi chiamato balance di tipo double, usa questa istruzione:
double balance[10];Inizializzazione degli array
È possibile inizializzare gli elementi dell'array del linguaggio di programmazione D uno per uno o utilizzando una singola istruzione come segue
double balance[5] = [1000.0, 2.0, 3.4, 17.0, 50.0];Il numero di valori tra parentesi quadre [] sul lato destro non può essere maggiore del numero di elementi dichiarati per l'array tra parentesi quadre []. L'esempio seguente assegna un singolo elemento dell'array:
Se ometti la dimensione dell'array, viene creato un array abbastanza grande da contenere l'inizializzazione. Pertanto, se scrivi
double balance[] = [1000.0, 2.0, 3.4, 17.0, 50.0];quindi creerai esattamente lo stesso array che hai fatto nell'esempio precedente.
balance[4] = 50.0;L'istruzione precedente assegna all'elemento numero 5 ° nell'array un valore di 50,0. L'array con il 4 ° indice sarà il 5 °, cioè l'ultimo elemento perché tutti gli array hanno 0 come indice del loro primo elemento, chiamato anche indice di base. La seguente rappresentazione pittorica mostra lo stesso array di cui abbiamo discusso sopra:
Accesso agli elementi dell'array
Si accede a un elemento indicizzando il nome dell'array. Questo viene fatto inserendo l'indice dell'elemento tra parentesi quadre dopo il nome dell'array. Ad esempio:
double salary = balance[9];L'istruzione precedente tiene 10 esimo elemento dalla matrice e assegna il valore alla variabile stipendio . L'esempio seguente implementa la dichiarazione, l'assegnazione e l'accesso agli array:
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]);
}
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Element Value
0 100
1 101
2 102
3 103
4 104
5 105
6 106
7 107
8 108
9 109Array statici e array dinamici
Se la lunghezza di un array viene specificata durante la scrittura del programma, tale array è un array statico. Quando la lunghezza può cambiare durante l'esecuzione del programma, quell'array è un array dinamico.
La definizione di array dinamici è più semplice della definizione di array a lunghezza fissa perché l'omissione della lunghezza crea un array dinamico:
int[] dynamicArray;Proprietà array
Ecco le proprietà degli array:
| Sr.No. | Proprietà e descrizione |
|---|---|
| 1 |
.init Static array restituisce un array letterale con ogni elemento del letterale che è la proprietà .init del tipo di elemento array. |
| 2 |
.sizeof L'array statico restituisce la lunghezza dell'array moltiplicata per il numero di byte per elemento dell'array mentre gli array dinamici restituiscono la dimensione del riferimento all'array dinamico, che è 8 nelle build a 32 bit e 16 nelle build a 64 bit. |
| 3 |
.length L'array statico restituisce il numero di elementi nell'array mentre gli array dinamici vengono utilizzati per ottenere / impostare il numero di elementi nell'array. La lunghezza è di tipo size_t. |
| 4 |
.ptr Restituisce un puntatore al primo elemento dell'array. |
| 5 |
.dup Crea un array dinamico della stessa dimensione e copia il contenuto dell'array al suo interno. |
| 6 |
.idup Crea un array dinamico della stessa dimensione e copia il contenuto dell'array al suo interno. La copia viene digitata come immutabile. |
| 7 |
.reverse Inverte in posizione l'ordine degli elementi nella matrice. Restituisce l'array. |
| 8 |
.sort Ordina in posizione l'ordine degli elementi nell'array. Restituisce l'array. |
Esempio
L'esempio seguente spiega le varie proprietà di un array:
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);
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
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]Array multidimensionali in D
La programmazione D consente array multidimensionali. Ecco la forma generale di una dichiarazione di array multidimensionale:
type name[size1][size2]...[sizeN];Esempio
La seguente dichiarazione crea un 5 tridimensionale. 10. 4 array intero -
int threedim[5][10][4];Array bidimensionali in D
La forma più semplice dell'array multidimensionale è l'array bidimensionale. Un array bidimensionale è, in sostanza, un elenco di array unidimensionali. Per dichiarare un array intero bidimensionale di dimensione [x, y] dovresti scrivere la sintassi come segue:
type arrayName [ x ][ y ];Dove type può essere qualsiasi tipo di dati di programmazione D valido e arrayName sarà un identificatore di programmazione D valido.
Dove tipo può essere qualsiasi tipo di dati di programmazione D valido e arrayName è un identificatore di programmazione D valido.
Un array bidimensionale può essere pensato come una tabella, che ha un numero x di righe ey di colonne. Una matrice bidimensionalea contenente tre righe e quattro colonne può essere mostrato come di seguito:
Pertanto, ogni elemento in array a è identificato da un elemento come a[ i ][ j ], dove a è il nome dell'array e i e j sono i pedici che identificano in modo univoco ogni elemento in un file.
Inizializzazione di array bidimensionali
Gli array multidimensionali possono essere inizializzati specificando valori tra parentesi per ogni riga. Il seguente array ha 3 righe e ogni riga ha 4 colonne.
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 */
];Le parentesi graffe nidificate, che indicano la riga desiderata, sono facoltative. La seguente inizializzazione è equivalente all'esempio precedente:
int a[3][4] = [0,1,2,3,4,5,6,7,8,9,10,11];Accesso agli elementi di array bidimensionali
Si accede a un elemento in un array bidimensionale utilizzando i pedici, significa indice di riga e indice di colonna dell'array. Per esempio
int val = a[2][3];La dichiarazione precedente prende il 4 ° elemento dalla 3a riga dell'array. Puoi verificarlo nel digramma sopra.
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]);
}
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
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]: 8Operazioni di array comuni in D
Di seguito sono riportate varie operazioni eseguite sugli array:
Array Slicing
Spesso usiamo parte di un array e lo slicing array è spesso molto utile. Di seguito è mostrato un semplice esempio di affettatura di array.
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);
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
[2, 3.4]Copia di array
Usiamo anche la copia dell'array. Di seguito è mostrato un semplice esempio per la copia di array.
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);
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
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]Impostazione array
Di seguito è mostrato un semplice esempio per l'impostazione del valore in un array.
import std.stdio;
void main () {
// an array with 5 elements.
double a[5];
a[] = 5;
writeln("Array a:",a);
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Array a:[5, 5, 5, 5, 5]Concatenazione di array
Di seguito è mostrato un semplice esempio di concatenazione di due array.
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);
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Array c: [5, 5, 5, 5, 5, 10, 10, 10, 10, 10]