D 语言 - 数组
D 编程语言提供了一种名为数组的数据结构，它存储相同类型元素的固定大小的顺序集合。 数组用于存储数据的集合。 将数组视为相同类型变量的集合通常更有用。
不要声明单独的变量，例如 number0、number1、... 和 number99，您可以声明一个数组变量（例如数字），并使用数字[0]、数字[1] 和...、数字[99] 来表示各个变量。 数组中的特定元素通过索引访问。
所有数组都由连续的内存位置组成。 最低地址对应于第一个元素，最高地址对应于最后一个元素。
声明数组
要在 D 编程语言中声明数组，程序员指定数组所需的元素类型和元素数量，如下所示 −
type arrayName [ arraySize ];
这称为一维数组。 arraySize 必须是大于零的整数常量，type 可以是任何有效的 D 编程语言数据类型。 例如，要声明一个名为 balance 且类型为 double 的 10 元素数组，请使用以下语句 −
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() {
// n 是一个由 10 个整数组成的数组
int n[ 10 ];
// 将数组 n 的元素初始化为 0
for ( int i = 0; i < 10; i++ ) {
n[ i ] = i + 100; // set element at location i to i + 100
}
writeln("Element \t 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;
数组属性
这是数组的属性 −
| 序号 | 属性和描述 |
|---|---|
| 1 |
.init 静态数组返回一个数组文字，该文字的每个元素都是数组元素类型的 .init 属性。 |
| 2 |
.sizeof 静态数组返回数组长度乘以每个数组元素的字节数，而动态数组返回动态数组引用的大小，在 32 位版本中为 8，在 64 位版本中为 16。 |
| 3 |
.length 静态数组返回数组中元素的数量，而动态数组用于获取/设置数组中元素的数量。 长度的类型为 size_t。 |
| 4 |
.ptr 返回指向数组第一个元素的指针。 |
| 5 |
.dup 创建一个相同大小的动态数组并将数组内容复制到其中。 |
| 6 |
.idup 创建一个相同大小的动态数组并将数组内容复制到其中。 副本的类型是不可变的。 |
| 7 |
.reverse 原地反转数组中元素的顺序。 返回数组。 |
| 8 |
.sort 按数组中元素的顺序进行排序。 返回数组。 |
示例
下面的例子解释了数组的各种属性 −
import std.stdio;
void main() {
// n 是一个由 5 个整数组成的数组
int n[ 5 ];
// 将数组 n 的元素初始化为 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 . 10 . 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] , /* 索引为 0 的行的初始值设定项 */ [4, 5, 6, 7] , /* 索引为 1 的行的初始值设定项 */ [8, 9, 10, 11] /* 索引为 2 的行的初始值设定项 */ ];
表示预期行的嵌套大括号是可选的。 以下初始化相当于前面的示例 −
int a[3][4] = [0,1,2,3,4,5,6,7,8,9,10,11];
访问二维数组元素
二维数组中的元素是通过下标来访问的，下标表示数组的行索引和列索引。 例如
int val = a[2][3];
上面的语句从数组的第三行中取出第四个元素。 您可以通过上图进行验证。
import std.stdio;
void main () {
// 一个 5 行 2 列的数组。
int a[5][2] = [ [0,0], [1,2], [2,4], [3,6],[4,8]];
// 输出每个数组元素的值
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 () {
// 具有 5 个元素的数组。
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 () {
// 具有 5 个元素的数组。
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; // a[5] 的 5 个元素被复制到 b[5]
writeln("Array b:",b);
b[] = a[]; // a[3] 的 5 个元素被复制到 b[5]
writeln("Array b:",b);
b[1..2] = a[0..1]; // 等同于 b[1] = a[0]
writeln("Array b:",b);
b[0..2] = a[1..3]; // 等同于 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 () {
// 具有 5 个元素的数组。
double a[5];
a[] = 5;
writeln("Array a:",a);
}
当上面的代码被编译并执行时，会产生以下结果 −
Array a:[5, 5, 5, 5, 5]
数组串联
下面显示了连接两个数组的简单示例。
import std.stdio;
void main () {
// 具有 5 个元素的数组。
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]
