Khởi tạo và điền dữ liệu vào mảng
Việc mô tả một mảng bằng danh sách khởi tạo chỉ có thể thực hiện đối với các mảng có kích thước cố định. Các mảng động chỉ có thể được điền dữ liệu sau khi bộ nhớ đã được cấp phát cho chúng bằng hàm ArrayResize. Chúng được điền dữ liệu bằng cách sử dụng các hàm ArrayInitialize
hoặc ArrayFill
. Các hàm này cũng hữu ích trong chương trình khi bạn muốn thay thế hàng loạt giá trị trong các mảng cố định hoặc chuỗi thời gian.
Các ví dụ về cách sử dụng các hàm được đưa ra sau phần mô tả của chúng.
int ArrayInitialize(type &array[], type value)
Hàm này đặt tất cả các phần tử của mảng thành giá trị được chỉ định. Chỉ hỗ trợ các mảng của các kiểu số tích hợp sẵn (char, uchar, short, ushort, int, uint, long, ulong, bool, color, datetime, float, double
). Các mảng chuỗi, cấu trúc và con trỏ không thể được điền theo cách này: chúng sẽ cần triển khai các hàm khởi tạo riêng của mình. Mảng có thể là đa chiều.
Hàm trả về số lượng phần tử.
Nếu mảng động được cấp phát với một khoản dự trữ (tham số thứ ba của hàm ArrayResize
), thì khoản dự trữ này không được khởi tạo.
Nếu sau khi mảng được khởi tạo, kích thước của nó được tăng lên bằng ArrayResize
, các phần tử được thêm vào sẽ không tự động được đặt thành value
. Chúng có thể được điền bằng hàm ArrayFill
.
void ArrayFill(type &array[], int start, int count, type value)
Hàm này điền một mảng số hoặc một phần của nó với một giá trị được chỉ định. Phần của mảng được xác định bởi các tham số start
và count
, lần lượt biểu thị số thứ tự bắt đầu của phần tử và số lượng phần tử cần điền.
Hàm không quan tâm đến việc thứ tự đánh số của các phần tử mảng được đặt giống như trong chuỗi thời gian hay không: thuộc tính này bị bỏ qua. Nói cách khác, các phần tử của mảng luôn được đếm từ đầu đến cuối của nó.
Đối với mảng đa chiều, tham số start
có thể được tính bằng cách chuyển đổi tọa độ trong tất cả các chiều thành một chỉ số xuyên suốt cho một mảng một chiều tương đương. Vì vậy, đối với một mảng hai chiều, các phần tử có chỉ số 0 trong chiều đầu tiên được đặt trong bộ nhớ trước, sau đó là các phần tử có chỉ số 1 trong chiều đầu tiên, và cứ như vậy. Công thức để tính start
như sau:
start = D1 * N2 + D2
Trong đó D1
và D2
là các chỉ số cho chiều thứ nhất và thứ hai, tương ứng, N2
là số phần tử cho chiều thứ hai. D2
thay đổi từ 0 đến (N2-1), D1
thay đổi từ 0 đến (N1-1). Ví dụ, trong một mảng array[3][4]
, phần tử với chỉ số [1][3] là phần tử thứ bảy liên tiếp, và do đó lời gọi ArrayFill(array, 7, 2, ...)
sẽ điền hai phần tử: array[1][3]
và phần tử tiếp theo sau nó là array[2][0]
. Trên sơ đồ, điều này có thể được mô tả như sau (mỗi ô chứa chỉ số xuyên suốt của phần tử):
[][0] [][1] [][2] [][3]
[0][] 0 1 2 3
[1][] 4 5 6 7
[2][] 8 9 10 11
2
3
4
Tập lệnh ArrayFill.mq5
cung cấp các ví dụ về cách sử dụng các hàm đã đề cập ở trên.
void OnStart()
{
int dynamic[];
int fixed[][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}};
PRT(ArrayInitialize(fixed, -1));
ArrayPrint(fixed);
ArrayFill(fixed, 3, 4, +1);
ArrayPrint(fixed);
PRT(ArrayResize(dynamic, 10, 50));
PRT(ArrayInitialize(dynamic, 0));
ArrayPrint(dynamic);
PRT(ArrayResize(dynamic, 50));
ArrayPrint(dynamic);
ArrayFill(dynamic, 10, 40, 0);
ArrayPrint(dynamic);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Dưới đây là kết quả có thể trông như thế nào (dữ liệu ngẫu nhiên trong các phần tử chưa được khởi tạo của mảng động sẽ khác nhau):
ArrayInitialize(fixed,-1)=8
[,0][,1][,2][,3]
[0,] -1 -1 -1 -1
[1,] -1 -1 -1 -1
[,0][,1][,2][,3]
[0,] -1 -1 -1 1
[1,] 1 1 1 -1
ArrayResize(dynamic,10,50)=10
ArrayInitialize(dynamic,0)=10
0 0 0 0 0 0 0 0 0 0
ArrayResize(dynamic,50)=50
[ 0] 0 0 0 0 0
0 0 0 0 0
[10] -1402885947 -727144693 699739629 172950740 -1326090126
47384 0 0 4194184 0
[20] 2 0 2 0 0
0 0 1765933056 2084602885 -1956758056
[30] 73910037 -1937061701 56 0 56
0 1048601 1979187200 10851 0
[40] 0 0 0 -685178880 -1720475236
782716519 -1462194191 1434596297 415166825 -1944066819
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23