Programmation D - Tableaux
Le langage de programmation D fournit une structure de données, nommée arrays, qui stocke une collection séquentielle de taille fixe d'éléments du même type. Un tableau est utilisé pour stocker une collection de données. Il est souvent plus utile de considérer un tableau comme une collection de variables du même type.
Au lieu de déclarer des variables individuelles, telles que nombre0, nombre1, ... et nombre99, vous déclarez une variable de tableau telle que des nombres et utilisez les nombres [0], les nombres [1] et ..., les nombres [99] pour représenter variables individuelles. Un élément spécifique d'un tableau est accessible par un index.
Tous les tableaux sont constitués d'emplacements de mémoire contigus. L'adresse la plus basse correspond au premier élément et l'adresse la plus élevée au dernier élément.
Déclaration de tableaux
Pour déclarer un tableau en langage de programmation D, le programmeur spécifie le type des éléments et le nombre d'éléments requis par un tableau comme suit -
type arrayName [ arraySize ];C'est ce qu'on appelle un tableau à une seule dimension. La valeur arraySize doit être une constante entière supérieure à zéro et le type peut être n'importe quel type de données de langage de programmation D valide. Par exemple, pour déclarer un tableau de 10 éléments appelé balance de type double, utilisez cette instruction -
double balance[10];Initialisation des tableaux
Vous pouvez initialiser les éléments du tableau du langage de programmation D un par un ou en utilisant une seule instruction comme suit
double balance[5] = [1000.0, 2.0, 3.4, 17.0, 50.0];Le nombre de valeurs entre crochets [] sur le côté droit ne peut pas être supérieur au nombre d'éléments que vous déclarez pour le tableau entre crochets []. L'exemple suivant affecte un seul élément du tableau -
Si vous omettez la taille du tableau, un tableau juste assez grand pour contenir l'initialisation est créé. Par conséquent, si vous écrivez
double balance[] = [1000.0, 2.0, 3.4, 17.0, 50.0];alors vous créerez exactement le même tableau que vous l'avez fait dans l'exemple précédent.
balance[4] = 50.0;L'instruction ci-dessus attribue au numéro d'élément 5e du tableau une valeur de 50,0. Le tableau avec le 4ème index sera le 5ème, c'est-à-dire le dernier élément car tous les tableaux ont 0 comme index de leur premier élément qui est également appelé index de base. La représentation picturale suivante montre le même tableau que nous avons discuté ci-dessus -
Accès aux éléments de la baie
Un élément est accessible en indexant le nom du tableau. Cela se fait en plaçant l'index de l'élément entre crochets après le nom du tableau. Par exemple -
double salary = balance[9];L'instruction ci-dessus prend le 10 e élément du tableau et affecte la valeur au salaire variable . L'exemple suivant implémente la déclaration, l'affectation et l'accès aux tableaux -
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]);
}
}Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -
Element Value
0 100
1 101
2 102
3 103
4 104
5 105
6 106
7 107
8 108
9 109Tableaux statiques et tableaux dynamiques
Si la longueur d'un tableau est spécifiée lors de l'écriture du programme, ce tableau est un tableau statique. Lorsque la longueur peut changer pendant l'exécution du programme, ce tableau est un tableau dynamique.
La définition de tableaux dynamiques est plus simple que la définition de tableaux de longueur fixe car l'omission de la longueur crée un tableau dynamique -
int[] dynamicArray;Propriétés du tableau
Voici les propriétés des tableaux -
| N ° Sr. | Propriété et description |
|---|---|
| 1 |
.init Le tableau statique renvoie un littéral de tableau avec chaque élément du littéral étant la propriété .init du type d'élément de tableau. |
| 2 |
.sizeof Le tableau statique renvoie la longueur du tableau multipliée par le nombre d'octets par élément de tableau tandis que les tableaux dynamiques renvoie la taille de la référence de tableau dynamique, qui est de 8 dans les versions 32 bits et de 16 dans les versions 64 bits. |
| 3 |
.length Le tableau statique renvoie le nombre d'éléments dans le tableau tandis que les tableaux dynamiques sont utilisés pour obtenir / définir le nombre d'éléments dans le tableau. La longueur est de type size_t. |
| 4 |
.ptr Renvoie un pointeur vers le premier élément du tableau. |
| 5 |
.dup Créez un tableau dynamique de la même taille et copiez-y le contenu du tableau. |
| 6 |
.idup Créez un tableau dynamique de la même taille et copiez-y le contenu du tableau. La copie est saisie comme étant immuable. |
| sept |
.reverse Inverse en place l'ordre des éléments du tableau. Renvoie le tableau. |
| 8 |
.sort Trie en place l'ordre des éléments dans le tableau. Renvoie le tableau. |
Exemple
L'exemple suivant explique les différentes propriétés d'un tableau -
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);
}Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -
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]Tableaux multidimensionnels en D
La programmation en D permet des tableaux multidimensionnels. Voici la forme générale d'une déclaration de tableau multidimensionnel -
type name[size1][size2]...[sizeN];Exemple
La déclaration suivante crée un 5 en trois dimensions. dix . 4 tableau d'entiers -
int threedim[5][10][4];Tableaux bidimensionnels en D
La forme la plus simple du tableau multidimensionnel est le tableau à deux dimensions. Un tableau à deux dimensions est, par essence, une liste de tableaux à une dimension. Pour déclarer un tableau d'entiers à deux dimensions de taille [x, y], vous écrirez la syntaxe comme suit -
type arrayName [ x ][ y ];Où type peut être n'importe quel type de données de programmation D valide et arrayName sera un identifiant de programmation D valide.
Où type peut être n'importe quel type de données de programmation D valide et arrayName est un identifiant de programmation D valide.
Un tableau à deux dimensions peut être considéré comme un tableau, qui a x nombre de lignes et y nombre de colonnes. Un tableau bidimensionnela contenant trois lignes et quatre colonnes peut être affiché comme ci-dessous -
Ainsi, chaque élément du tableau a est identifié par un élément comme a[ i ][ j ], où a est le nom du tableau, et i et j sont les indices qui identifient de manière unique chaque élément dans un fichier.
Initialisation de tableaux bidimensionnels
Les tableaux multidimensionnels peuvent être initialisés en spécifiant des valeurs entre crochets pour chaque ligne. Le tableau suivant a 3 lignes et chaque ligne a 4 colonnes.
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 */
];Les accolades imbriquées, qui indiquent la ligne voulue, sont facultatives. L'initialisation suivante est équivalente à l'exemple précédent -
int a[3][4] = [0,1,2,3,4,5,6,7,8,9,10,11];Accès aux éléments de matrice bidimensionnelle
Un élément dans un tableau à 2 dimensions est accessible à l'aide des indices, signifie l'index de ligne et l'index de colonne du tableau. Par exemple
int val = a[2][3];L'instruction ci-dessus prend le 4ème élément de la 3ème ligne du tableau. Vous pouvez le vérifier dans le digramme ci-dessus.
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]);
}
}Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -
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]: 8Opérations de baie courantes en D
Voici différentes opérations effectuées sur les tableaux -
Tranchage de matrice
Nous utilisons souvent une partie d'un tableau et le découpage d'un tableau est souvent très utile. Un exemple simple de découpage de tableau est présenté ci-dessous.
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);
}Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -
[2, 3.4]Copie de baies
Nous utilisons également un tableau de copie. Un exemple simple de copie de tableau est présenté ci-dessous.
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);
}Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -
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]Paramètre de matrice
Un exemple simple de définition de valeur dans un tableau est présenté ci-dessous.
import std.stdio;
void main () {
// an array with 5 elements.
double a[5];
a[] = 5;
writeln("Array a:",a);
}Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -
Array a:[5, 5, 5, 5, 5]Concaténation de tableaux
Un exemple simple de concaténation de deux tableaux est présenté ci-dessous.
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);
}Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -
Array c: [5, 5, 5, 5, 5, 10, 10, 10, 10, 10]