Programowanie D - tablice

Język programowania D zapewnia strukturę danych o nazwie arrays, który przechowuje sekwencyjną kolekcję elementów tego samego typu o stałym rozmiarze. Tablica służy do przechowywania kolekcji danych. Często bardziej przydatne jest myślenie o tablicy jako o zbiorze zmiennych tego samego typu.

Zamiast deklarować pojedyncze zmienne, takie jak liczba0, liczba1, ... i liczba99, deklarujesz jedną zmienną tablicową, taką jak liczby, i używasz liczb [0], liczb [1] i ..., liczb [99] do reprezentowania indywidualne zmienne. Dostęp do określonego elementu w tablicy uzyskuje się za pomocą indeksu.

Wszystkie tablice składają się z ciągłych lokalizacji pamięci. Najniższy adres odpowiada pierwszemu elementowi, a najwyższy adres ostatniemu elementowi.

Deklarowanie tablic

Aby zadeklarować tablicę w języku programowania D, programista określa typ elementów i liczbę elementów wymaganych przez tablicę w następujący sposób -

type arrayName [ arraySize ];

Nazywa się to tablicą jednowymiarową. ArraySize musi być liczbą całkowitą większą od zera stała i typ może być dowolny poprawny typ danych języka programowania D. Na przykład, aby zadeklarować 10-elementową tablicę o nazwie balance typu double, użyj tej instrukcji -

double balance[10];

Inicjowanie tablic

Elementy tablicy języka programowania D można inicjować pojedynczo lub za pomocą pojedynczej instrukcji w następujący sposób

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

Liczba wartości w nawiasach kwadratowych [] po prawej stronie nie może być większa niż liczba elementów zadeklarowanych w tablicy w nawiasach kwadratowych []. Poniższy przykład przypisuje pojedynczy element tablicy -

Jeśli pominiesz rozmiar tablicy, zostanie utworzona tablica wystarczająco duża, aby pomieścić inicjalizację. Dlatego jeśli piszesz

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

następnie utworzysz dokładnie taką samą tablicę, jak w poprzednim przykładzie.

balance[4] = 50.0;

Powyższa instrukcja przypisuje elementowi numerowi 5 w tablicy wartość 50,0. Tablica z czwartym indeksem będzie piątym, czyli ostatnim elementem, ponieważ wszystkie tablice mają 0 jako indeks pierwszego elementu, który jest również nazywany indeksem bazowym. Poniższe przedstawienie graficzne przedstawia tę samą tablicę, którą omówiliśmy powyżej -

Dostęp do elementów tablicy

Dostęp do elementu uzyskuje się poprzez indeksowanie nazwy tablicy. Odbywa się to poprzez umieszczenie indeksu elementu w nawiasach kwadratowych po nazwie tablicy. Na przykład -

double salary = balance[9];

Powyższe stwierdzenie ma 10 ^th elementu z tablicy i przypisuje się wartość zmiennej wynagrodzenia . Poniższy przykład implementuje deklarację, przypisanie i dostęp do tablic -

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]); 
   } 
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

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

Tablice statyczne a tablice dynamiczne

Jeśli długość tablicy jest określona podczas pisania programu, tablica ta jest tablicą statyczną. Gdy długość może się zmienić podczas wykonywania programu, tablica ta jest tablicą dynamiczną.

Definiowanie tablic dynamicznych jest prostsze niż definiowanie tablic o stałej długości, ponieważ pominięcie długości powoduje utworzenie tablicy dynamicznej -

int[] dynamicArray;

Właściwości tablicy

Oto właściwości tablic -

Sr.No.	Właściwość i opis
1	.init Tablica statyczna zwraca literał tablicowy, w którym każdy element literału jest właściwością .init typu elementu tablicy.
2	.sizeof Tablica statyczna zwraca długość tablicy pomnożoną przez liczbę bajtów na element tablicy, podczas gdy tablice dynamiczne zwracają rozmiar odwołania do tablicy dynamicznej, który wynosi 8 w kompilacjach 32-bitowych i 16 w kompilacjach 64-bitowych.
3	.length Tablica statyczna zwraca liczbę elementów w tablicy, podczas gdy tablice dynamiczne są używane do pobierania / ustawiania liczby elementów w tablicy. Długość jest typu size_t.
4	.ptr Zwraca wskaźnik do pierwszego elementu tablicy.
5	.dup Utwórz tablicę dynamiczną o tym samym rozmiarze i skopiuj do niej zawartość tablicy.
6	.idup Utwórz tablicę dynamiczną o tym samym rozmiarze i skopiuj do niej zawartość tablicy. Kopia jest wpisywana jako niezmienna.
7	.reverse Odwraca kolejność elementów w tablicy. Zwraca tablicę.
8	.sort Sortuje w kolejności elementów w tablicy. Zwraca tablicę.

Przykład

Poniższy przykład wyjaśnia różne właściwości tablicy -

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); 
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

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]

Tablice wielowymiarowe w D

Programowanie D umożliwia tworzenie tablic wielowymiarowych. Oto ogólna forma wielowymiarowej deklaracji tablicy -

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

Przykład

Poniższa deklaracja tworzy trójwymiarową 5. 10. 4 tablica liczb całkowitych -

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

Tablice dwuwymiarowe w D

Najprostszą formą tablicy wielowymiarowej jest tablica dwuwymiarowa. Dwuwymiarowa tablica to w istocie lista tablic jednowymiarowych. Aby zadeklarować dwuwymiarową tablicę liczb całkowitych o rozmiarze [x, y], należy napisać składnię w następujący sposób -

type arrayName [ x ][ y ];

Gdzie type może być dowolnym poprawnym typem danych programowania D i arrayName będzie prawidłowym identyfikatorem programowania D.

Gdzie typ może być dowolnym prawidłowym typem danych programowania D, a arrayName jest prawidłowym identyfikatorem programowania D.

Dwuwymiarową tablicę można traktować jako tabelę, która ma x liczbę wierszy i y liczbę kolumn. Dwuwymiarowa tablicaa zawierający trzy wiersze i cztery kolumny można wyświetlić jak poniżej -

Zatem każdy element w tablicy a jest identyfikowany przez element jako a[ i ][ j ], gdzie a to nazwa tablicy, a i i j to indeksy, które jednoznacznie identyfikują każdy element w.

Inicjowanie tablic dwuwymiarowych

Tablice wielowymiarowe można zainicjować, określając wartości w nawiasach kwadratowych dla każdego wiersza. Poniższa tablica ma 3 wiersze, a każdy wiersz ma 4 kolumny.

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 */ 
];

Zagnieżdżone nawiasy klamrowe, które wskazują zamierzony wiersz, są opcjonalne. Następująca inicjalizacja jest równoważna z poprzednim przykładem -

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

Dostęp do dwuwymiarowych elementów tablicy

Dostęp do elementu w dwuwymiarowej tablicy uzyskujemy za pomocą indeksów, czyli indeksu wiersza i kolumny tablicy. Na przykład

int val = a[2][3];

Powyższa instrukcja przyjmuje czwarty element z trzeciego wiersza tablicy. Możesz to zweryfikować w powyższym digramie.

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]); 
   }
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

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

Typowe operacje na tablicach w D

Oto różne operacje wykonywane na tablicach -

Wycinanie szyku

Często używamy części tablicy, a dzielenie tablicy jest często bardzo pomocne. Poniżej przedstawiono prosty przykład podziału na tablice.

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); 
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

[2, 3.4]

Kopiowanie w tablicy

Używamy również kopiowania tablicy. Poniżej przedstawiono prosty przykład kopiowania macierzy.

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); 
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

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]

Ustawienie tablicy

Poniżej przedstawiono prosty przykład ustawiania wartości w tablicy.

import std.stdio;

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

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

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

Konkatenacja tablic

Poniżej przedstawiono prosty przykład konkatenacji dwóch tablic.

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); 
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

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