Thực đơn
trang chủHướng dẫn

Cách tạo mảng một chiều c. Lập trình trong C: Sử dụng mảng dữ liệu trong C. Biển chỉ dẫn

Khi giải bài toán với lượng lớn dữ liệu cùng loại, việc sử dụng các biến có tên khác nhau không được sắp xếp theo địa chỉ bộ nhớ khiến việc lập trình trở nên khó khăn. Trong những trường hợp như vậy, ngôn ngữ C sử dụng các đối tượng được gọi là mảng.

là một phần bộ nhớ liền kề chứa một chuỗi các đối tượng cùng loại, được biểu thị bằng một tên.

Mảng được đặc trưng bởi các khái niệm cơ bản sau:

Phần tử mảng (giá trị phần tử mảng)– một giá trị được lưu trữ trong một ô nhớ cụ thể nằm trong mảng, cũng như địa chỉ của ô nhớ này.
Mỗi phần tử mảng được đặc trưng bởi ba giá trị:

  • địa chỉ phần tử - địa chỉ của ô nhớ khởi đầu chứa phần tử này;
  • chỉ số phần tử (số thứ tự của phần tử trong mảng);
  • giá trị phần tử.

Địa chỉ mảng – địa chỉ của phần tử bắt đầu của mảng.

Tên mảng là một mã định danh dùng để chỉ các phần tử mảng.

Kích thước mảng – số phần tử mảng

Kích thước phần tử là số byte được chiếm bởi một phần tử mảng.

Về mặt đồ họa, vị trí của mảng trong bộ nhớ máy tính có thể được biểu diễn dưới dạng một dải địa chỉ liên tục.

Mảng hiển thị trong hình chứa q phần tử có chỉ số từ 0 đến q-1. Mỗi phần tử chiếm k byte trong bộ nhớ máy tính và việc sắp xếp các phần tử trong bộ nhớ là tuần tự.

Địa chỉ của phần tử thứ i của mảng là

Địa chỉ mảng là địa chỉ của phần tử bắt đầu (không) của mảng. Để truy cập các phần tử mảng, số sê-ri (chỉ mục) của phần tử được sử dụng, giá trị ban đầu là 0. Vì vậy, nếu một mảng chứa q phần tử thì chỉ số của các phần tử mảng thay đổi từ 0 đến q-1.

Độ dài mảng là số byte được phân bổ trong bộ nhớ để lưu trữ tất cả các phần tử của mảng.

Độ dài mảng = Kích thước phần tử * Số phần tử

Hàm có thể được sử dụng để xác định kích thước của một phần tử mảng

int sizeof(loại);

Ví dụ,

sizeof(char) = 1;
sizeof(int) = 4;
sizeof(float) = 4;
sizeof(double) = 8;

Khai báo và khởi tạo mảng

Để khai báo một mảng trong C, cú pháp sau được sử dụng:

gõ tên[chiều]=(init);

Khởi tạo là tập hợp các giá trị ban đầu của các phần tử mảng, được chỉ định trong dấu ngoặc nhọn, phân tách bằng dấu phẩy.

int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // mảng a gồm 10 số nguyên

Nếu số lượng giá trị khởi tạo được chỉ định trong dấu ngoặc nhọn nhỏ hơn số phần tử mảng được chỉ định trong dấu ngoặc vuông, thì tất cả các phần tử còn lại trong mảng (không có đủ giá trị khởi tạo) sẽ bằng 0. Thuộc tính này thuận tiện để sử dụng để đặt tất cả các phần tử của một mảng về giá trị 0.

int b = (0); // mảng b gồm 10 phần tử, khởi tạo là 0


Nếu mảng được khởi tạo khi khai báo thì các giá trị ban đầu không đổi của các phần tử trong mảng được biểu thị cách nhau bằng dấu phẩy trong dấu ngoặc nhọn. Trong trường hợp này, số phần tử trong ngoặc vuông có thể được bỏ qua.

int a = (1, 2, 3, 4, 5, 6, 7, 8, 9);

Khi truy cập các phần tử mảng, chỉ mục của phần tử bắt buộc được biểu thị trong dấu ngoặc vuông.

Ví dụ trong C

1
2
3
4
5
6
7
8

#bao gồm
int chính()
{
int a = ( 5, 4, 3, 2, 1 ); // mảng a chứa 5 phần tử
printf("%d %d %d %d %d\n" , a, a, a, a, a);
getchar();
trả về 0;
}

Kết quả thực hiện chương trình:

Tuy nhiên, thường cần thiết lập giá trị của các phần tử mảng trong quá trình thực hiện chương trình. Điều này sử dụng khai báo mảng mà không cần khởi tạo. Trong trường hợp này, việc chỉ ra số phần tử trong ngoặc vuông là bắt buộc.

int một;

Để đặt giá trị ban đầu của các phần tử mảng, vòng lặp tham số thường được sử dụng:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18


#bao gồm
int chính()
{
int một;
int tôi;
// Nhập các phần tử mảng
với (i = 0; tôi<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
// Xuất ra các phần tử mảng
với (i = 0; tôi<5; i++)
printf("%d " , a[i]); // cần có khoảng trống ở định dạng in
getchar(); getchar();
trả về 0;
}

Kết quả thực hiện chương trình

Mảng đa chiều

Mảng đa chiều cũng có thể được khai báo trong C. Sự khác biệt giữa mảng nhiều chiều và mảng một chiều là trong mảng một chiều, vị trí của một phần tử được xác định bởi một chỉ mục và trong mảng nhiều chiều - bởi một số chỉ mục. Một ví dụ về mảng nhiều chiều là ma trận.

Dạng tổng quát khai báo mảng nhiều chiều

tên loại [thứ nguyên1] [thứ nguyên2]...[thứ nguyênm];

Các phần tử của mảng đa chiều được đặt trong các ô RAM kế tiếp nhau theo thứ tự địa chỉ tăng dần. Trong bộ nhớ máy tính, các phần tử của mảng nhiều chiều được sắp xếp thành một hàng, ví dụ mảng có 2 hàng và 3 cột,

int một;


sẽ được đặt trong bộ nhớ như sau

Tổng số phần tử trong mảng hai chiều đã cho được xác định như sau:

Số hàng * Số cột = 2 * 3 = 6.

Số byte bộ nhớ cần thiết để chứa mảng được cho bởi

Số lượng mục * Kích thước mục = 6 * 4 = 24 byte.

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

Giá trị của các phần tử của mảng nhiều chiều, như trong trường hợp một chiều, có thể được xác định bằng các giá trị không đổi khi được khai báo, đặt trong dấu ngoặc nhọn (). Tuy nhiên, trong trường hợp này, số phần tử trong hàng và cột phải được ghi trong dấu ngoặc vuông.

Ví dụ trong C

1
2
3
4
5
6
7
8
9

#bao gồm
int chính()
{
int a = ( 1, 2, 3, 4, 5, 6 );
printf("%d %d %d\n" , a, a, a);
getchar();
trả về 0;
}



Tuy nhiên, thường xuyên hơn bạn cần nhập giá trị của các phần tử của mảng nhiều chiều trong quá trình thực hiện chương trình. Với mục đích này, sẽ thuận tiện hơn khi sử dụng vòng lặp tham số lồng nhau.

Ví dụ trong C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#define _CRT_SECURE_NO_WARNINGS
#bao gồm
int chính()
{
int một; // mảng 2 hàng và 3 cột
int tôi, j;
// Nhập các phần tử mảng
với (i = 0; tôi<2; i++) // lặp qua các dòng
{
với (j = 0; j<3; j++) // lặp qua các cột
{
printf("a[%d][%d] = " , i, j);
scanf("%d" , &a[i][j]);
}
}
// Xuất ra các phần tử mảng
với (i = 0; tôi<2; i++) // lặp qua các dòng
{
với (j = 0; j<3; j++) // lặp qua các cột
{
printf("%d " , a[i][j]);
}
printf("\n" ); // dòng mới
}
getchar(); getchar();
trả về 0;
}



Truyền một mảng cho hàm

Việc xử lý mảng có thể được tổ chức thuận tiện bằng cách sử dụng các chức năng đặc biệt. Để xử lý một mảng, bạn phải truyền đối số cho hàm

  • địa chỉ mảng,
  • kích thước mảng.

Ngoại lệ là các hàm xử lý chuỗi, trong đó chỉ cần truyền địa chỉ là đủ.

Khi truyền biến làm đối số cho hàm, dữ liệu sẽ được truyền dưới dạng bản sao. Điều này có nghĩa là nếu một giá trị tham số thay đổi bên trong hàm thì điều này sẽ không ảnh hưởng đến giá trị của nó bên trong hàm gọi.

Nếu một địa chỉ biến (hoặc địa chỉ mảng) được truyền cho một hàm thì tất cả các thao tác được thực hiện trong hàm trên dữ liệu trong phạm vi địa chỉ đã chỉ định sẽ được thực hiện trên dữ liệu gốc, do đó mảng (hoặc giá trị biến) ban đầu có thể được thay đổi bởi hàm được gọi.

Ví dụ về mảng C Dan gồm 10 phần tử. Hoán đổi phần tử lớn nhất và phần tử bắt đầu của mảng. Để có các hoạt động tìm kiếm và trao đổi phần tử tối đa, hãy sử dụng hàm.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#define _CRT_SECURE_NO_WARNINGS
#bao gồm
// Hàm trao đổi
thay đổi void(int *x, int n)
{
// x - con trỏ tới mảng (địa chỉ mảng)
// n - kích thước mảng
int tôi;
int max, chỉ số;
tối đa = x;
chỉ số = 0;
// Tìm phần tử lớn nhất
với (i = 1; tôi {
nếu (x[i]>tối đa)
{
tối đa = x[i];
chỉ số = tôi;
}
}
// Trao đổi
x = x;
x = tối đa;
}
// Chức năng chính
int chính()
{
int một;
int tôi;
với (i = 0; tôi<10; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
thay đổi(a, 10); // gọi hàm trao đổi
// Xuất ra các phần tử mảng
với (i = 0; tôi<10; i++)
printf("%d " , a[i]);
getchar();
getchar();
trở lại
p = p * x[i];
}
trả lại p;
}
// Chức năng chính
int chính()
{
int một; // khai báo mảng a gồm 5 phần tử
int tôi;
int pr;
// Nhập các phần tử mảng
với (i = 0; tôi<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]); // &a[i] - địa chỉ của phần tử thứ i của mảng
}
pr = func(a, 5); // tính tích sản phẩm
printf("\npr = %d" ,pr); // xuất ra tích các phần tử chẵn
getchar(); getchar();
trả về 0;
}



Mảng là một cấu trúc dữ liệu được biểu diễn dưới dạng một nhóm các ô cùng loại, được hợp nhất dưới một tên duy nhất. Mảng được sử dụng để xử lý một lượng lớn dữ liệu cùng loại. Tên của mảng chính là con trỏ, lát nữa tôi sẽ kể cho bạn nghe. Một ô dữ liệu riêng lẻ của một mảng được gọi là phần tử mảng. Các phần tử của mảng có thể là dữ liệu thuộc bất kỳ loại nào. Mảng có thể có một hoặc nhiều chiều. Tùy thuộc vào số chiều, mảng được chia thành mảng một chiều, mảng hai chiều, mảng ba chiều, v.v. cho đến mảng n chiều. Mảng một chiều và hai chiều thường được sử dụng nhiều nhất trong lập trình nên chúng ta sẽ chỉ xem xét các mảng này.

Mảng một chiều trong C++

Mảng một chiều là mảng có một tham số mô tả số phần tử của mảng một chiều. Trong thực tế, mảng một chiều là mảng chỉ có thể có một hàng và n cột. Các cột trong mảng một chiều là các phần tử của mảng. Hình 1 thể hiện cấu trúc của mảng một chiều số nguyên Một. Kích thước của mảng này là 16 ô.

Hình 1 - Mảng trong C++

Lưu ý rằng chỉ số tối đa của mảng một chiều Một là 15, nhưng kích thước của mảng là 16 ô, vì việc đánh số các ô của mảng luôn bắt đầu từ 0. Chỉ mục ô là một số nguyên không âm mà nhờ đó bạn có thể truy cập từng ô của mảng và thực hiện bất kỳ hành động nào trên đó ( tế bào).

//cú pháp khai báo mảng một chiều trong C++: /*kiểu dữ liệu*/ /*tên mảng một chiều*/; //ví dụ khai báo mảng một chiều như trong Hình 1: int a;

trong đó int là số nguyên;

A là tên mảng một chiều;
16 là kích thước của mảng một chiều, 16 ô.

Luôn ngay sau tên của mảng có dấu ngoặc vuông trong đó kích thước của mảng một chiều được chỉ định; đây là điểm phân biệt mảng với tất cả các biến khác.

//một cách khác để khai báo mảng một chiều int mas, a;

Hai mảng một chiều mas và a được khai báo với kích thước lần lượt là 10 và 16. Hơn nữa, trong phương thức khai báo này, tất cả các mảng sẽ có cùng kiểu dữ liệu, trong trường hợp của chúng ta là int.

// mảng có thể được khởi tạo khi khai báo: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); //khởi tạo mảng một chiều

Việc khởi tạo mảng một chiều được thực hiện trong dấu ngoặc nhọn sau dấu bằng, mỗi phần tử của mảng được phân tách với phần tử trước đó bằng dấu phẩy.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // khởi tạo mảng mà không xác định kích thước của nó.

Trong trường hợp này, chính trình biên dịch sẽ xác định kích thước của mảng một chiều. Kích thước của mảng chỉ được bỏ qua khi khởi tạo mảng; khi khai báo mảng thông thường thì phải xác định kích thước của mảng. Hãy phát triển một chương trình đơn giản để xử lý mảng một chiều.

// array.cpp: Xác định điểm vào cho ứng dụng console. #include "stdafx.h" #include << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// mã Code::Khối

// Mã Dev-C++

// array.cpp: Xác định điểm vào cho ứng dụng console. #bao gồm sử dụng không gian tên std; int main(int argc, char* argv) ( cout<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

TRONG dòng 10 - 11 Một mảng số nguyên một chiều có tên array1 đã được khai báo và khởi tạo, kích thước của mảng là 16 ô, tức là mảng đó có thể lưu trữ được 16 số. Bất kỳ quá trình xử lý mảng nào cũng chỉ có thể thực hiện được khi kết hợp với các vòng lặp. Lựa chọn vòng lặp nào để xử lý mảng là tùy bạn quyết định. Nhưng nó phù hợp nhất cho nhiệm vụ này. Chúng ta sẽ sử dụng biến đếm counter để truy cập các phần tử của mảng một chiều1. Điều kiện tiếp tục của vòng lặp for chứa dấu bất đẳng thức nghiêm ngặt, vì không có chỉ số thứ mười sáu trong mảng một chiều array1. Và vì việc đánh số ô bắt đầu từ 0 nên có 16 phần tử trong mảng. Trong phần thân của vòng lặp for, toán tử cout in ra các phần tử của mảng một chiều (xem Hình 2).

Obrabotka massiva lập chỉ mục phần tử massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 39 array1 -15 Để tiếp tục, nhấn phím bất kỳ. . .

Hình 2 - Mảng trong C++

Hãy phát triển một chương trình khác để xử lý mảng một chiều trong C++. Chương trình phải đọc tuần tự 10 số đã nhập từ bàn phím. Tất cả các số đã nhập sẽ được tổng hợp và kết quả được hiển thị trên màn hình.

// array_sum.cpp: Xác định điểm vào cho ứng dụng console. #include "stdafx.h" #include << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// mã Code::Khối

// Mã Dev-C++

// array_sum.cpp: Xác định điểm vào cho ứng dụng console. #bao gồm sử dụng không gian tên std; int main(int argc, char* argv) ( int array1; // khai báo một mảng số nguyên cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> mảng1; // đọc số nhập từ bàn phím cout<< "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

Trước khi xử lý một mảng, nó phải được khai báo và kích thước của mảng một chiều là 10, vì điều này được quy định bởi điều kiện của tác vụ. Trong biến sum chúng ta sẽ tích lũy tổng các phần tử của mảng một chiều. Vòng lặp for đầu tiên điền vào mảng một chiều được khai báo bằng các số được nhập từ bàn phím, dòng 12 - 13. Biến đếm được sử dụng để truy cập tuần tự các phần tử của mảng một chiều array1 , bắt đầu từ chỉ số 0 cho đến chỉ số thứ 9. Vòng lặp for thứ hai hiển thị các phần tử của mảng, dòng 15 - 16. Vòng lặp for thứ ba đọc tuần tự các phần tử của mảng một chiều và tính tổng chúng, tổng được tích lũy trong biến tổng. dòng 17 - 18. Kết quả của chương trình được thể hiện trong Hình 3.

Nhập phần tử khối lượng: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 Để tiếp tục, nhấn phím bất kỳ. . .

Hình 3 - Mảng trong C++

Đầu tiên, tất cả 10 số được nhập tuần tự, sau đó mảng một chiều được hiển thị và tổng các số trong mảng được in ra.

Mảng hai chiều trong C++

Cho đến thời điểm này, chúng ta đã xem xét mảng một chiều, không phải lúc nào cũng có thể bị giới hạn. Giả sử bạn cần xử lý một số dữ liệu từ một bảng. Một bảng có hai đặc điểm: số hàng và số cột. Ngoài ra, trong mảng hai chiều, ngoài số lượng phần tử mảng còn có các đặc điểm như số hàng, số cột của mảng hai chiều. Nghĩa là, về mặt trực quan, mảng hai chiều là một bảng thông thường, có các hàng và cột. Trong thực tế, mảng hai chiều là mảng một chiều của mảng một chiều. Cấu trúc của một mảng hai chiều, được đặt tên là a, có kích thước m x ​​n được hiển thị bên dưới (xem Hình 4).

Hình 4 - Mảng trong C++

trong đó, m là số hàng của mảng hai chiều;
n là số cột của mảng hai chiều;
m * n - số phần tử mảng.

// cú pháp khai báo mảng hai chiều /*data type*/ /*array name*/;

Khi khai báo mảng hai chiều cũng như khi khai báo mảng một chiều, trước hết bạn cần xác định rõ:

  • loại dữ liệu;
  • tên mảng.

Sau đó, dấu ngoặc vuông đầu tiên cho biết số hàng của mảng hai chiều và dấu ngoặc vuông thứ hai cho biết số cột của mảng hai chiều. Mảng hai chiều được phân biệt trực quan với mảng một chiều bằng cặp dấu ngoặc vuông thứ hai. Hãy xem một ví dụ về khai báo mảng hai chiều. Giả sử chúng ta cần khai báo một mảng hai chiều có số phần tử bằng 15. Trong trường hợp này, mảng hai chiều có thể có ba hàng và năm cột hoặc năm hàng và ba cột.

// ví dụ khai báo mảng hai chiều: int a;

  • a là tên mảng số nguyên
  • số trong ngoặc vuông đầu tiên biểu thị số hàng của mảng hai chiều, trong trường hợp này là 5;
  • số trong ngoặc vuông thứ hai cho biết số cột của mảng hai chiều, trong trường hợp này là 3.

// khởi tạo mảng hai chiều: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

Mảng này có 5 hàng, 3 cột. Sau dấu gán, các dấu ngoặc nhọn chung được đặt, bên trong đó đặt càng nhiều cặp dấu ngoặc nhọn thì càng có các dòng trong mảng hai chiều và các dấu ngoặc này được phân tách bằng dấu phẩy. Trong mỗi cặp dấu ngoặc nhọn, hãy viết các phần tử của mảng hai chiều cách nhau bằng dấu phẩy. Trong tất cả các dấu ngoặc nhọn, số phần tử phải giống nhau. Vì có năm dòng trong mảng nên cũng có năm cặp dấu ngoặc bên trong. Ba phần tử được viết trong dấu ngoặc đơn vì số cột là ba. Về mặt đồ họa, mảng của chúng ta sẽ trông giống như một bảng hai chiều (xem Hình 5).

Hình 5 - Mảng trong C++

Trong mỗi ô của mảng hai chiều Một giá trị được hiển thị, địa chỉ của ô này được hiển thị ở góc dưới bên phải. Địa chỉ ô của mảng hai chiều là tên mảng, số hàng và số cột.

Hãy phát triển một chương trình đơn giản để xử lý mảng hai chiều, được gọi là “Mê cung”. Mê cung phải được xây dựng trên cơ sở mảng hai chiều. Chúng tôi sẽ chọn kích thước của mê cung theo ý của chúng tôi.

// array2.cpp: Xác định điểm vào cho ứng dụng console. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) khác cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// mã Code::Khối

// Mã Dev-C++

// array2.cpp: Xác định điểm vào cho ứng dụng console. #bao gồm sử dụng không gian tên std; int main(int argc, char* argv) ( // 1-có điều kiện “bức tường của mê cung” // 2-“đường dẫn đúng, thoát khỏi mê cung” // 0-“đường dẫn sai” int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // khởi tạo mảng hai chiều ( 1,2,1,0 ,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1,1 ,0,1,0, 1,2,1,2,2,2,2,1,0,1,1,0,1,), (1,2,2,2,2,2,2, 1,2,1,1 ,1,1,2,1,0,0,1,0,1,), (1,1,1,1,1,1,2,1,2,1,0 ,0,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0,0,2, 0,0,0,1 ,0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1 ,0,1,), (1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,), (1,1,1, 1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,), (1,1,0, 0,0,1,0 ,0,1,1,2,1,1,1,1,0,0,0,0,1,), (1,0,0,1,0,0,0 ,0,0,1, 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1,1,1,1,1, 1,1,1,2 ,1,0,0,0,0,1,), (1,2,2,2,2,2,2,2,2,2,2,2,2,2 ,1,0,1, 1,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0, 0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,) , (1,2,1 ,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,), (1,2,1 ,2,2,2, 1,2,1,2,2,2,1,1,1,1,1,1,1,1,), (1,2,1,2,1,2, 1,2,1,0 ,1,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1,2,1,2,1,0 ,1,1,1, 1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0,0,0,0, 0,0,0,0 ,0,2,1,), (1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0 ,1,2,1, ), (1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1, ), (1,2, 1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,), (1,2, 1,1,2,1 ,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1,1,2,1 ,0,0,1, 1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2,1,1,0,1, 2,2,2,2 ,2,2,2,2,2,2,1,), (1,2,1,1,2,1,0,0,1,2,1,1,1 ,1,1,1, 1,1,1,1,), (1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1, 1,1,2,2 ,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1 ,), (1,2 ,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,), (1,2 ,1,1,2, 1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,), (1,2,2,2,2, 1,0,1,1 ,2,2,2,2,0,0,1,0,0,0,1,), (1,1,1,1,1,1,1,1,1 ,1,1,1, 1,1,1,1,1,1,1,1,) ); // hai vòng lặp - bên trong và bên ngoài, truy cập từng phần tử của mảng for (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) khác cout<< " "; // вывести два пробела cout << endl; } return 0; }

Đường dẫn đúng và sai có thể được biểu thị bằng cùng một số, ví dụ: 0, nhưng để rõ ràng, đường dẫn đúng được biểu thị bằng số 2. Mảng được khởi tạo theo cách thủ công, chỉ để đơn giản hóa chương trình. Vì chương trình xử lý mảng hai chiều nên cần có hai vòng lặp để chuyển đổi giữa các phần tử của mảng hai chiều. Vòng lặp for đầu tiên chuyển đổi giữa các hàng của mảng hai chiều. Vì có 33 hàng trong mảng hai chiều nên biến đếm i được tăng từ 0 lên 33, dòng 46. Bên trong vòng lặp đầu tiên là vòng lặp for duyệt qua các phần tử hàng của mảng hai chiều. Trong phần thân của vòng lặp for thứ hai, một thao tác chuyển đổi kiểu dữ liệu đơn nhất được thực hiện bên trong - static_cast<>() , in ra ký tự số 176. Thao tác chuyển đổi kiểu dữ liệu được nhân đôi để tăng chiều rộng của mê cung. Kết quả của chương trình (xem Hình 6).

Hình 6 - Mảng trong C++

Mảng

Mảng là tập hợp các biến cùng loại có tên chung để chỉ chúng. Trong C#, mảng có thể là một chiều hoặc nhiều chiều. Mảng phục vụ nhiều mục đích khác nhau vì chúng cung cấp một phương tiện thuận tiện để nhóm các biến có liên quan lại với nhau.

Bạn có thể sử dụng mảng trong C# theo cách tương tự như trong các ngôn ngữ lập trình khác. Tuy nhiên, chúng có một điểm đặc biệt: chúng được triển khai dưới dạng đối tượng.

Việc sử dụng mảng trong chương trình yêu cầu quy trình gồm hai bước vì C# triển khai mảng dưới dạng đối tượng. Đầu tiên các bạn cần khai báo một biến có thể truy cập vào mảng. Và thứ hai, bạn cần tạo một thể hiện của mảng bằng toán tử mới.

Sử dụng hệ thống; sử dụng System.Collections.Generic; sử dụng System.Linq; sử dụng System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( // Khai báo mảng int myArr = new int; // Khởi tạo từng phần tử của mảng theo cách thủ công myArr = 100; myArr = 23; myArr = 25; myArr = 31; myArr = 1 ; foreach (int i trong myArr) Console.WriteLine(i);

Hãy nhớ rằng nếu một mảng chỉ được khai báo nhưng không được khởi tạo rõ ràng thì mỗi phần tử sẽ được đặt thành giá trị mặc định cho kiểu dữ liệu tương ứng (ví dụ: các phần tử của một mảng kiểu bool sẽ được đặt thành false và các phần tử của một mảng kiểu bool sẽ được đặt thành false và các phần tử của một mảng kiểu bool sẽ được đặt thành false). mảng kiểu int sẽ được đặt thành 0).

Khởi tạo một mảng

Ngoài việc điền từng phần tử mảng (như trong ví dụ trước), bạn cũng có thể điền nó bằng cú pháp khởi tạo mảng đặc biệt. Để làm điều này, bạn cần liệt kê các phần tử có trong mảng trong dấu ngoặc nhọn ( ). Cú pháp này hữu ích khi tạo một mảng có kích thước đã biết và cần thiết lập nhanh các giá trị ban đầu của nó:

// Cú pháp khởi tạo một mảng sử dụng // từ khóa new int myArr = new int (10,20,30,40,50); // Cú pháp khởi tạo một mảng không sử dụng // từ khóa new string info = ( "Họ", "Tên", "Người bảo trợ" ); // Sử dụng từ khóa new và ký hiệu char có kích thước mong muốn = new char ( "X","Y","Z","M" );

Lưu ý rằng khi sử dụng cú pháp dấu ngoặc nhọn, bạn không cần chỉ định kích thước của mảng (như đã thấy khi tạo biến myArr) vì kích thước được tính toán tự động dựa trên số phần tử bên trong dấu ngoặc nhọn. Ngoài ra, hãy sử dụng từ khóa mới tùy chọn (như khi tạo một mảng thông tin).

Từ khóa var cho phép bạn xác định một biến để trình biên dịch suy ra kiểu cơ bản của nó. Bạn cũng có thể định nghĩa các mảng cục bộ được gõ ngầm theo cách tương tự. Sử dụng phương pháp này, bạn có thể xác định một biến mảng mới mà không cần chỉ định loại phần tử có trong mảng. Hãy xem một ví dụ:

Sử dụng hệ thống; sử dụng System.Collections.Generic; sử dụng System.Linq; sử dụng System.Text; không gian tên ConsoleApplication1 ( class Program ( static void Main(string args) ( var arr1 = new ( 1, 2, 3 ); Console.WriteLine("Loại mảng arr1 là (0)",arr1.GetType()); var arr2 = new( "Một", "Hai", "Ba" ); Console.WriteLine("Loại mảng arr2 - (0)",arr2.GetType());

Tất nhiên, giống như khi tạo một mảng bằng cú pháp C# rõ ràng, các phần tử được chỉ định trong danh sách khởi tạo mảng phải có cùng kiểu cơ bản (nghĩa là tất cả chúng phải là int, string hoặc MyCar).

Xác định một mảng đối tượng

Trong hầu hết các trường hợp, khi xác định một mảng, loại phần tử có trong mảng được chỉ định rõ ràng. Mặc dù thoạt nhìn điều này có vẻ khá đơn giản nhưng có một tính năng quan trọng. Trọng tâm của mọi kiểu trong hệ thống kiểu .NET (bao gồm các kiểu dữ liệu cơ bản) cuối cùng là một lớp cơ sở, System.Object. Kết quả là nếu bạn định nghĩa một mảng các đối tượng, các phần tử bên trong nó có thể là bất cứ thứ gì:

Sử dụng hệ thống; sử dụng System.Collections.Generic; sử dụng System.Linq; sử dụng System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( // Khai báo và khởi tạo một mảng đối tượng object arrByObject = ( true, 10, "Hello", 13.7m ); // In kiểu của từng thành viên mảng ra console foreach (đối tượng tôi trong arrByObject) Console.WriteLine("Type (0) - (1)",me,me.GetType());

Mảng trong C là gì?

Cách khai báo mảng trong C?

Làm cách nào để khởi tạo mảng trong C?

Mảng trong C dành cho người giả.

Mảng trong C

Mảng trong C là tập hợp các phần tử cùng loại có thể được truy cập bằng chỉ mục. Các phần tử của mảng trong C lần lượt được đặt trong bộ nhớ của máy tính.

Một ví dụ đơn giản về tạo và điền một mảng trong C:

// @author Subbotin B.P..h> void main(void) ( int nArr; nArr = 1; nArr = 2; nArr = 3; printf("\n\tArray\n\n"); printf("nArr\t =\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); return 0 ; )

Chúng tôi nhận được:

Trong ví dụ này, chúng ta khai báo một mảng chứa các phần tử kiểu int:

ở đây tên mảng là nArr, số phần tử mảng là 3, kiểu phần tử mảng là int.

Mảng là một tập hợp các phần tử. Mỗi phần tử của mảng có thể được gọi bằng số của nó. Con số này thường được gọi là chỉ mục. Các phần tử mảng được đánh số bắt đầu từ số 0. Hãy gán một giá trị cho phần tử đầu tiên của mảng và phần tử đầu tiên có chỉ số bằng 0:

Hãy gán một giá trị cho phần tử thứ hai của mảng và phần tử thứ hai có chỉ mục một:

Hãy gán một giá trị cho phần tử thứ ba của mảng và phần tử thứ ba có chỉ số hai:

Khi hiển thị các phần tử mảng trên màn hình, chúng ta sẽ nhận được giá trị của chúng. Như thế này:

printf("nArr\t=\t%d\n", nArr);

Để lấy một phần tử của mảng, bạn cần chỉ định tên mảng và chỉ mục của phần tử:

Đây là phần tử đầu tiên của mảng vì phần tử đầu tiên có chỉ số bằng 0.

Hãy gán giá trị của phần tử thứ ba của mảng cho biến int a:

chỉ số của phần tử thứ ba của mảng là hai, vì các chỉ số được tính từ 0.

Bây giờ quy tắc chung để khai báo mảng trong C: khi khai báo một mảng, bạn cần cho biết tên mảng, loại phần tử và số lượng phần tử. Số phần tử là số tự nhiên, tức là toàn bộ là tích cực. Số 0 không thể là số phần tử. Bạn không thể chỉ định số lượng phần tử mảng thay đổi. Dưới đây là ví dụ về khai báo mảng trong C:

int nArr; // Một mảng đã được khai báo để chứa một trăm số nguyên;
phao fArr; // Một mảng được thiết kế để lưu trữ 5 số float đã được khai báo;
char cArr; // Một mảng đã được khai báo để lưu trữ hai ký tự;

Sẽ là một sai lầm khi khai báo một mảng có số phần tử thay đổi:

Int varElem;
int nArr; // Lỗi! Số lượng phần tử không thể được đặt thành một biến;

Nhưng bạn có thể đặt số phần tử có giá trị không đổi: số nguyên dương trực tiếp 1, 2, 3... hoặc hằng số:

Const int arrayLength = 3;
int nArr;

Khi khai báo một mảng trong C, bạn có thể khởi tạo ngay:

int nMassiv = (1, 2, 3);

Bạn có thể bỏ qua số phần tử mảng trong ngoặc vuông nếu tất cả các phần tử mảng được khởi tạo:

int nMassiv = (1, 2, 3);

số phần tử sẽ được xác định tự động trong trường hợp này.

Bạn chỉ có thể định nghĩa một phần các phần tử của mảng khi khai báo nó:

int nMassiv = (1, 2);

trong ví dụ này, hai phần tử đầu tiên của mảng được khởi tạo, nhưng phần tử thứ ba không được xác định.

Ví dụ về mảng ký tự:

char cArr = ("S", "B", "P");

Khi khai báo một mảng, bạn không thể chỉ định số phần tử của một biến. Nhưng bạn có thể sử dụng các biến khi truy cập các phần tử mảng:

Int ind = 0;
char cr = cArr;

Điều này được sử dụng khi làm việc với các vòng lặp. Ví dụ:

// @author Subbotin B.P..h> void main(void) ( const int arrayLength = 3; int nArr; for(int inn = 0; inn< 3; inn++) { nArr = inn + 1; } printf("\n\tArray\n\n"); for(int inn = 0; inn < 3; inn++) { printf("nArr[%d]\t=\t%d\n", inn, nArr); } return 0; }

Trong ví dụ, trong vòng lặp đầu tiên, chúng ta điền vào mảng các phần tử kiểu int và trong vòng lặp thứ hai, chúng ta hiển thị các phần tử này trên màn hình.

Một loại mảng C# khác là mảng mảng, còn được gọi là mảng lởm chởm. Một mảng các mảng như vậy có thể được coi là một mảng một chiều có các phần tử là mảng, các phần tử của nó lần lượt có thể là mảng, v.v. ở một mức độ lồng nhau nào đó.

Trong những tình huống nào thì nhu cầu về cấu trúc dữ liệu như vậy có thể phát sinh? Các mảng này có thể được sử dụng để biểu diễn các cây trong đó các nút có thể có số lượng nút con tùy ý. Ví dụ, đây có thể là một cây gia phả. Đỉnh của cấp độ đầu tiên - Người cha, đại diện cho người cha có thể được cho bởi mảng một chiều, do đó Người cha[ Tôi] - Cái này Tôi bố. Các đỉnh của cấp độ thứ hai được biểu diễn bằng một mảng các mảng - Những đứa trẻ, Vì thế Những đứa trẻ[ Tôi] - đây là một mảng trẻ em Tôi-người cha, và Những đứa trẻ[ Tôi][ j] - đây là đứa con thứ j Tôi bố. Để đại diện cho cháu bạn sẽ cần có cấp độ thứ ba, vì vậy Cháu[ Tôi][ j][ k] sẽ đại diện ĐẾN cháu trai jđứa trẻ Tôi bố.

Có một số đặc thù trong việc khai báo và khởi tạo các mảng như vậy. Nếu khi khai báo loại mảng nhiều chiều, dấu phẩy được sử dụng để biểu thị thứ nguyên, thì đối với mảng lởm chởm, một ký hiệu rõ ràng hơn được sử dụng - một tập hợp các cặp dấu ngoặc vuông; Ví dụ, int[ ] chỉ định một mảng có các phần tử là mảng một chiều gồm các phần tử kiểu int.

Việc tự tạo các mảng và khởi tạo chúng sẽ khó khăn hơn. Bạn không thể gọi hàm tạo ở đây mớiint, vì nó không chỉ định một mảng lởm chởm. Trên thực tế, bạn cần gọi hàm tạo cho từng mảng ở mức thấp nhất. Đây chính là khó khăn khi khai báo các mảng như vậy. Hãy bắt đầu với một ví dụ chính thức:

// mảng mảng - ví dụ hình thức
// khai báo và khởi tạo
int[ ] lời nói tục tĩu= mớiint[ ] {
int mới [] {5, 7, 9, 11},
int mới [] {2, 8},
int mới [] {6, 12, 4}
};

Mảng lời nói tục tĩu chỉ có hai cấp độ. Chúng ta có thể coi nó có ba phần tử, mỗi phần tử là một mảng. Với mỗi mảng như vậy, bạn cần gọi hàm tạo mới, để tạo một mảng nội bộ. Trong ví dụ này, các phần tử của mảng bên trong nhận giá trị của chúng bằng cách được khởi tạo rõ ràng dưới dạng mảng không đổi. Tất nhiên, tuyên bố sau đây cũng được chấp nhận:

int[ ] lời nói tục tĩu1 = mớiint[ ] {
mớiint,
mớiint,
mớiint
};

Trong trường hợp này, các phần tử mảng sẽ nhận giá trị 0 trong quá trình khởi tạo. Việc khởi tạo thực tế sẽ cần phải được thực hiện theo chương trình. Điều đáng chú ý là trong hàm tạo cấp cao nhất, hằng số 3 bạn có thể bỏ qua nó và chỉ cần viết mớiint[ ] . Lệnh gọi tới hàm tạo này có thể được bỏ qua hoàn toàn - nó sẽ được ngụ ý:

int[ ] lời nói tục tĩu2 = {
int mới,
int mới,
int mới
};

Nhưng các nhà xây dựng cấp thấp hơn là cần thiết. Một lưu ý quan trọng khác - mảng động cũng có thể được sử dụng ở đây. Nói chung, ranh giới ở bất kỳ cấp độ nào cũng có thể là những biểu thức phụ thuộc vào các biến. Hơn nữa, các mảng ở cấp độ thấp hơn được phép có nhiều chiều.