Lập trình D - Mảng

Ngôn ngữ lập trình D cung cấp một cấu trúc dữ liệu, có tên là arrays, nơi lưu trữ một tập hợp tuần tự có kích thước cố định của các phần tử cùng loại. Một mảng được sử dụng để lưu trữ một tập hợp dữ liệu. Thường sẽ hữu ích hơn nếu coi một mảng là một tập hợp các biến cùng kiểu.

Thay vì khai báo các biến riêng lẻ, chẳng hạn như number0, number1, ... và number99, bạn khai báo một biến mảng chẳng hạn như số và sử dụng số [0], số [1] và ..., số [99] để biểu diễn các biến riêng lẻ. Một phần tử cụ thể trong một mảng được truy cập bởi một chỉ mục.

Tất cả các mảng bao gồm các vị trí bộ nhớ liền kề. Địa chỉ thấp nhất tương ứng với phần tử đầu tiên và địa chỉ cao nhất cho phần tử cuối cùng.

Khai báo Mảng

Để khai báo một mảng trong ngôn ngữ lập trình D, người lập trình chỉ định kiểu của các phần tử và số phần tử theo yêu cầu của một mảng như sau:

type arrayName [ arraySize ];

Đây được gọi là mảng một chiều. Kích thước mảng phải là một hằng số nguyên lớn hơn 0 và kiểu có thể là bất kỳ kiểu dữ liệu ngôn ngữ lập trình D hợp lệ nào. Ví dụ, để khai báo một mảng 10 phần tử được gọi là số dư kiểu double, hãy sử dụng câu lệnh này:

double balance[10];

Khởi tạo Mảng

Bạn có thể khởi tạo từng phần tử của mảng ngôn ngữ lập trình D hoặc từng phần tử hoặc sử dụng một câu lệnh như sau

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

Số lượng giá trị giữa dấu ngoặc vuông [] ở phía bên phải không được lớn hơn số phần tử bạn khai báo cho mảng giữa dấu ngoặc vuông []. Ví dụ sau chỉ định một phần tử duy nhất của mảng:

Nếu bạn bỏ qua kích thước của mảng, một mảng vừa đủ lớn để chứa quá trình khởi tạo sẽ được tạo. Do đó, nếu bạn viết

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

thì bạn sẽ tạo chính xác mảng giống như bạn đã làm trong ví dụ trước.

balance[4] = 50.0;

Câu lệnh trên gán cho phần tử số thứ 5 trong mảng một giá trị là 50.0. Mảng có chỉ số thứ 4 sẽ là thứ 5, tức là phần tử cuối cùng vì tất cả các mảng đều có 0 là chỉ số của phần tử đầu tiên của chúng, còn được gọi là chỉ số cơ sở. Phần đại diện bằng hình ảnh sau đây cho thấy cùng một mảng mà chúng ta đã thảo luận ở trên -

Truy cập các phần tử mảng

Một phần tử được truy cập bằng cách lập chỉ mục tên mảng. Điều này được thực hiện bằng cách đặt chỉ mục của phần tử trong dấu ngoặc vuông sau tên của mảng. Ví dụ -

double salary = balance[9];

Câu lệnh trên nhận phần tử ^thứ 10 từ mảng và gán giá trị cho biến lương . Ví dụ sau thực hiện khai báo, gán và truy cập các mảng:

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

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

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

Mảng tĩnh so với Mảng động

Nếu độ dài của một mảng được chỉ định trong khi viết chương trình, thì mảng đó là một mảng tĩnh. Khi độ dài có thể thay đổi trong quá trình thực hiện chương trình thì mảng đó là mảng động.

Định nghĩa mảng động đơn giản hơn xác định mảng có độ dài cố định vì việc bỏ qua độ dài làm cho mảng động -

int[] dynamicArray;

Thuộc tính mảng

Đây là các thuộc tính của mảng -

Sr.No.	Kê khai tài sản
1	.init Mảng tĩnh trả về một ký tự mảng với mỗi phần tử của ký tự là thuộc tính .init của kiểu phần tử mảng.
2	.sizeof Mảng tĩnh trả về độ dài mảng nhân với số byte mỗi phần tử mảng trong khi mảng động trả về kích thước của tham chiếu mảng động, là 8 trong các bản dựng 32 bit và 16 trên các bản dựng 64 bit.
3	.length Mảng tĩnh trả về số phần tử trong mảng trong khi mảng động được sử dụng để lấy / đặt số phần tử trong mảng. Chiều dài thuộc loại size_t.
4	.ptr Trả về một con trỏ đến phần tử đầu tiên của mảng.
5	.dup Tạo một mảng động có cùng kích thước và sao chép nội dung của mảng vào đó.
6	.idup Tạo một mảng động có cùng kích thước và sao chép nội dung của mảng vào đó. Bản sao được đánh là bất biến.
7	.reverse Đảo ngược thứ tự của các phần tử trong mảng. Trả về mảng.
số 8	.sort Sắp xếp theo thứ tự của các phần tử trong mảng. Trả về mảng.

Thí dụ

Ví dụ sau giải thích các thuộc tính khác nhau của một mảng:

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

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

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]

Mảng đa chiều trong D

Lập trình D cho phép mảng nhiều chiều. Đây là dạng chung của khai báo mảng nhiều chiều:

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

Thí dụ

Khai báo sau đây tạo ra ba chiều 5. 10. 4 mảng số nguyên -

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

Mảng hai chiều trong D

Dạng đơn giản nhất của mảng nhiều chiều là mảng hai chiều. Về bản chất, mảng hai chiều là một danh sách các mảng một chiều. Để khai báo một mảng số nguyên hai chiều có kích thước [x, y], bạn sẽ viết cú pháp như sau:

type arrayName [ x ][ y ];

Ở đâu type có thể là bất kỳ kiểu dữ liệu lập trình D hợp lệ nào và arrayName sẽ là một mã định danh lập trình D hợp lệ.

Trong đó type có thể là bất kỳ kiểu dữ liệu lập trình D hợp lệ nào và arrayName là mã định danh lập trình D hợp lệ.

Một mảng hai chiều có thể được coi như một bảng, có x số hàng và y số cột. Một mảng hai chiềua chứa ba hàng và bốn cột có thể được hiển thị như sau:

Do đó, mọi phần tử trong mảng a được xác định bởi một phần tử là a[ i ][ j ], Ở đâu a là tên của mảng và i và j là các chỉ số con xác định duy nhất từng phần tử trong a.

Khởi tạo mảng hai chiều

Mảng nhiều thứ nguyên có thể được khởi tạo bằng cách chỉ định giá trị trong ngoặc cho mỗi hàng. Mảng sau có 3 hàng và mỗi hàng có 4 cột.

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

Các dấu ngoặc nhọn lồng nhau, biểu thị hàng dự định, là tùy chọn. Khởi tạo sau tương đương với ví dụ trước:

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

Truy cập các phần tử mảng hai chiều

Một phần tử trong mảng 2 chiều được truy cập bằng cách sử dụng các chỉ số con, nghĩa là chỉ số hàng và chỉ số cột của mảng. Ví dụ

int val = a[2][3];

Câu lệnh trên nhận phần tử thứ 4 từ hàng thứ 3 của mảng. Bạn có thể xác minh nó trong biểu đồ trên.

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

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

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

Các phép toán mảng phổ biến trong D

Dưới đây là các hoạt động khác nhau được thực hiện trên các mảng:

Mảng Slicing

Chúng ta thường sử dụng một phần của mảng và việc cắt mảng thường khá hữu ích. Dưới đây là một ví dụ đơn giản cho việc cắt mảng.

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

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

[2, 3.4]

Sao chép mảng

Chúng tôi cũng sử dụng mảng sao chép. Dưới đây là một ví dụ đơn giản cho việc sao chép mảng.

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

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

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]

Thiết lập mảng

Dưới đây là một ví dụ đơn giản để thiết lập giá trị trong một mảng.

import std.stdio;

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

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

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

Kết nối mảng

Dưới đây là một ví dụ đơn giản cho việc nối hai mảng.

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

Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:

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