D語言陣列

D程式設計語言提供了一種資料結構，陣列用於儲存相同型別的元素的一個固定大小的連續集合。陣列是用於儲存資料的集合，但它往往認為陣列為相同型別的變數的集合。

相反宣告個別變數，如number0, number1, ..., 和number99，宣告一個陣列變數，如使用數位numbers[0], numbers[1], 和..., numbers[99]來表示各個變數。在陣列中的特定元素是通過索引來存取。

所有陣列組成的連續的儲存單元。最低的地址對應於所述第一元素，而最高地址的最後一個元素。

宣告陣列：

在D程式設計語言宣告陣列，程式員指定的元素和如下由陣列所需元素的數量的型別：

type arrayName [ arraySize ];

這就是所謂的單維陣列。arraySize必須是整數常數大於零且型別可以是任何有效的D程式設計語言資料型別。例如，要宣告一個10個元素的陣列為double型別，使用此語句：

double balance[10];

初始化陣列：

可以初始化D程式設計語言的陣列元素或者一個接一個，或使用一個單獨的語句如下：

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

方括號內[]的值的個數在右邊不能比，我們的宣告方括號[]之間的陣列元素的個數較大。下面是一個範例來指定陣列的單個元素：

如果省略陣列的大小，建立陣列的大小剛好能容納初始化。因此，如果編寫：

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

將建立完全相同的陣列，和在前面的例子中那樣。

balance[4] = 50.0;

上述宣告陣列的值50.0在指定元素數第5位。與第四索引陣列將是第五次，即最後一個元素，因為所有的陣列都是讓 0作為他們的第一個元素，也被稱為基本索引的索引。以下是我們上面討論的相同陣列的圖案表現出來：

存取陣列元素：

元素是由索引陣列名存取。這是通過將一個元素的索引陣列的名稱之後方括號內進行。例如：

double salary = balance[9];

上面的語句將第10元素從陣列並賦值給變數salary。下面是一個例子，這將使用所有上述三個概念即：宣告，賦值和存取陣列：

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 	 Value");

   // output each array element's value
   for ( int j = 0; j < 10; j++ )
   {
      writeln(j," 	 ",n[j]);
   }
}

讓我們編譯和執行上面的程式，這將產生以下結果：

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

靜態陣列與動態陣列

當在程式被寫入所指定的陣列的長度，該陣列是一個靜態陣列。當長度可以在程式的執行過程中發生變化，該陣列是一個動態陣列。

定義動態陣列不是定義固定長度的陣列，因為省略長度使得一個動態陣列簡單：

int[] dynamicArray;

陣列屬性

下面的例子說明可用於陣列的各種屬性。

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("Yiibaier:",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);
}

讓我們編譯和執行上面的程式，這將產生以下結果：

Initialized value:[0, 0, 0, 0, 0]
Length: 5
Size of: 20
Yiibaier: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]

多維陣列

D程式設計允許多維陣列。這裡是一個多維陣列宣告的一般形式為：

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

例如，下面的宣告建立一個三維： 5 . 10 . 4整數陣列：

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

二維陣列：

多維陣列的最簡單的形式是二維陣列。二維陣列在本質上是一維陣列的列表。宣告大小為x,y的二維整型陣列，編寫如下：

type arrayName [ x ][ y ];

其中type可以是任何有效的D程式設計的資料型別和arrayName中會是一個有效的D程式設計識別符號。

一個二維陣列可以想作是一個表，有行和列：x行y列的數量，它包含三行四列可以如下所示：

因此，在陣列每個元素是確定的形式的元素名為[i][j]時，其中a是陣列的名稱，並且i和j是用來唯一地標識每一個元素的下標。

初始化二維陣列：

多維陣列可以通過指定每一行括號內的值進行初始化。以下是3行，每行一個陣列有4列。

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

巢狀的括號，這表明預定的行，是可選的。下面的初始化等同於前面的例子：

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

存取二維陣列元素：

在2維陣列的元素是通過使用下標，即行索引和所述陣列的列索引的存取。例如：

int val = a[2][3];

上面的語句將第4個元素的陣列的第三排。可以在上面雙字母組合驗證。

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

讓我們編譯和執行上面的程式，這將產生以下結果：

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

常見的陣列操作

陣列分片

我們經常用一個陣列的一部分，切片陣列往往是相當有用的。一個簡單的例子陣列切片如下所示。

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

讓我們編譯和執行上面的程式，這將產生以下結果：

[2, 3.4]

陣列複製

我們還使用複製陣列。一個簡單的例子，適用於陣列的複製如下所示。

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

讓我們編譯和執行上面的程式，這將產生以下結果：

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]

陣列設定

一個簡單的例子陣列中的設定值如下所示。

import std.stdio;

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

當上面的程式碼被編譯並執行，它會產生以下結果：

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

陣列連線

一個簡單的例子對兩個陣列的並置如下所示。

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

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