D 编程 - 数组

---

---

D 编程语言提供了一种名为数组的数据结构，它存储大小固定的相同类型元素的顺序集合。数组用于存储数据集合。通常，将数组视为相同类型变量的集合更有用。

与其声明单个变量，例如 number0、number1……和 number99，不如声明一个数组变量，例如 numbers，并使用 numbers[0]、numbers[1]……和 numbers[99] 来表示单个变量。数组中的特定元素通过索引访问。

所有数组都由连续的内存位置组成。最低地址对应于第一个元素，最高地址对应于最后一个元素。

声明数组

要在 D 编程语言中声明数组，程序员需要指定元素的类型和数组所需的元素数量，如下所示：

type arrayName [ arraySize ];

这被称为一维数组。arraySize 必须是一个大于零的整数常量，而 type 可以是任何有效的 D 编程语言数据类型。例如，要声明一个名为 balance 的包含 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; 

上述语句将数组中第 5 个元素的值赋值为 50.0。具有索引 4 的数组将是第 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 \t Value");
   
   // output each array element's value 
   for ( int j = 0; j < 10; j++ ) { 
      writeln(j," \t ",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("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); 
}

编译并执行上述代码后，将产生以下结果：

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]

D 中的多维数组

D 编程允许使用多维数组。以下是多维数组声明的一般形式：

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

示例

以下声明创建了一个三维 5 x 10 x 4 整数数组：

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

D 中的二维数组

多维数组最简单的形式是二维数组。二维数组本质上是一维数组的列表。要声明一个大小为 [x, y] 的二维整数数组，可以使用以下语法：

type arrayName [ x ][ y ];

其中 type 可以是任何有效的 D 编程数据类型，而 arrayName 将是有效的 D 编程标识符。

其中 type 可以是任何有效的 D 编程数据类型，而 arrayName 是有效的 D 编程标识符。

二维数组可以被认为是一个表，它有 x 行和 y 列。包含三行四列的二维数组 a 可以显示如下：

因此，数组 a 中的每个元素都由元素 a[i][j] 标识，其中 a 是数组的名称，i 和 j 是唯一标识 a 中每个元素的下标。

二维数组初始化

可以通过为每一行指定带括号的值来初始化多维数组。以下数组有 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];

访问二维数组元素

使用下标（即数组的行索引和列索引）访问二维数组中的元素。例如

int val = a[2][3];

上述语句从数组的第 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

D 中常见的数组操作

以下是对数组执行的各种操作：

数组切片

我们经常使用数组的一部分，数组切片通常非常有用。数组切片的一个简单示例如下所示。

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]