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         109

Array 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]: 8

Operazioni 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]