Mảng trong C: Tổng quan, Cách khai báo và Khởi tạo chúng – khai báo một mảng trong c

Tìm hiểu tất cả về mảng trong C bằng cách hiểu các thuộc tính, ưu điểm của nó và cũng biết cách khai báo, khởi tạo và truy cập các phần tử của mảng.

Bạn đang xem : khai báo một mảng trong c

Mảng trong C có thể được định nghĩa là một phương pháp gộp nhiều thực thể cùng loại vào một nhóm lớn hơn. Các thực thể hoặc phần tử này có thể thuộc kiểu dữ liệu int, float, char hoặc double hoặc có thể thuộc kiểu dữ liệu do người dùng định nghĩa giống như cấu trúc. Tuy nhiên, để được lưu trữ cùng nhau trong một mảng, tất cả các phần tử phải có cùng kiểu dữ liệu . Các phần tử được lưu trữ từ trái sang phải với chỉ mục ngoài cùng bên trái là chỉ mục thứ 0 và chỉ mục ngoài cùng bên phải là chỉ mục (n-1).

Chương trình Sau Đại học: Phát triển Web Full Stack

trong Hợp tác với Caltech CTME

Đăng ký ngay  Chương trình Sau Đại học: Phát triển Web Full Stack

Mảng trong C có hai loại; Mảng một chiều và Mảng nhiều chiều.

  • Mảng đơn chiều: Mảng một chiều hoặc mảng 1-D là dạng mảng đơn giản nhất có thể tìm thấy trong C. Loại mảng này bao gồm các phần tử có cùng kiểu và các phần tử này có thể được truy cập thông qua các chỉ số của chúng.

array_in_C_1

  • Mảng đa chiều: Loại mảng đa chiều phổ biến nhất được sử dụng trong Ngôn ngữ C là ngôn ngữ 2 -D mảng. Tuy nhiên, số thứ nguyên có thể nhiều hơn 2 tùy thuộc vào trình biên dịch trong hệ thống của người dùng. Các mảng này bao gồm các phần tử chính là mảng.

array_in_C_2

Tại sao Chúng ta Cần Mảng?

Nếu chúng ta có một số lượng nhỏ các phần tử, giả sử chúng ta muốn có 3 biến, sau đó chúng ta có thể khai báo chúng một cách riêng biệt như var1, var2 và var3. Nhưng nếu chúng ta có một số lượng lớn các biến thì chúng ta có thể sử dụng mảng để lưu trữ chúng.

Hãy để chúng tôi lấy một ví dụ thực tế. Giả sử bạn muốn tạo một chương trình in từ 1-100 chữ số. Bây giờ trong ngôn ngữ C, bạn có thể đạt được điều này bằng 2 phương pháp. Cách đầu tiên là tạo 100 biến và lưu trữ các số từ 1-100 trong các biến đó riêng biệt và sau đó in ra từng chữ số. Phương pháp thứ hai là tạo một mảng có kích thước 100 và lưu trữ các số trong mảng đó bằng cách sử dụng một vòng lặp. Những chữ số này có thể được in bằng cách sử dụng một vòng lặp duy nhất với độ phức tạp tuyến tính. Rõ ràng là phương pháp thứ hai được tối ưu hóa và mong muốn hơn phương pháp đầu tiên vì nó thuận tiện hơn để lưu trữ các giá trị này trong một mảng duy nhất thay vì tạo 100 biến.

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

Có nhiều cách khác nhau trong đó một mảng có thể được khai báo và khởi tạo theo nhiều cách khác nhau. Bạn có thể khai báo một mảng thuộc bất kỳ kiểu dữ liệu nào (tức là int, float, double, char) trong C. Các cách sau có thể được sử dụng để khai báo và khởi tạo một mảng trong C.

  • Khai báo mảng bằng cách chỉ định kích thước

Mảng có thể được khai báo bằng cách chỉ định kích thước hoặc số lượng phần tử của mảng. Kích thước của mảng xác định số phần tử tối đa mà mảng có thể chứa. Trong phiên bản C mới nhất, bạn có thể khai báo một mảng bằng cách chỉ định kích thước tại thời điểm khai báo hoặc bạn có thể cung cấp kích thước do người dùng chỉ định. Cú pháp sau có thể được sử dụng để khai báo một mảng đơn giản bằng cách chỉ định kích thước của nó.

// khai báo một mảng bằng cách chỉ định kích thước trong [].

int my_array1 [20];

char my_array2 [5];

// khai báo một mảng bằng cách chỉ định kích thước do người dùng xác định.

int size = 20;

int my_array3 [size];

Khi một mảng được khai báo mà không phân bổ bất kỳ giá trị nào, thì nó sẽ lưu trữ một giá trị rác. Nếu bạn truy cập bất kỳ giá trị mảng chưa được khởi tạo nào, thì cũng giống như bất kỳ biến chưa được khởi tạo nào, nó sẽ cung cấp cho bạn một giá trị rác.

  • Khai báo mảng bằng phần tử khởi tạo

Một mảng có thể được khởi tạo tại thời điểm khai báo của nó. Trong phương pháp khai báo mảng này, trình biên dịch sẽ cấp phát một mảng có kích thước bằng số phần tử của mảng. Cú pháp sau có thể được sử dụng để khai báo và khởi tạo một mảng cùng một lúc.

// khởi tạo mảng tại thời điểm khai báo.

int my_array [] = {100, 200, 300, 400, 500}

Trong cú pháp trên, một mảng gồm 5 phần tử được tạo và mặc dù kích thước mảng chưa được chỉ định ở đây, trình biên dịch sẽ phân bổ kích thước của 5 phần tử nguyên.

  • Khai báo mảng bằng cách chỉ định kích thước và phần tử khởi tạo

Một mảng cũng có thể được tạo bằng cách chỉ định kích thước và gán các phần tử của mảng tại thời điểm khai báo. Phương pháp tạo mảng này khác với phương pháp trước. Ở đây, nếu số phần tử được khởi tạo nhỏ hơn kích thước của mảng được chỉ định, thì phần còn lại của phần tử sẽ tự động được khởi tạo bằng 0 bởi trình biên dịch. Hãy xem cú pháp sau để hiểu điều này.

// khai báo một mảng bằng cách chỉ định kích thước và

// khởi tạo tại thời điểm khai báo

int my_array1 [5] = {100, 200, 300, 400, 500}; // my_array1 = {100, 200, 300, 400, 500}

//

int my_array2 [5] = {100, 200, 300}; // my_array2 = {100, 200, 300, 0, 0}

Trong cú pháp mảng ở trên, my_array1 là một mảng có kích thước 5 với tất cả năm phần tử được khởi tạo. Trong khi, my_array2 là một mảng có kích thước 5 với chỉ ba phần tử của nó được khởi tạo. Hai phần tử còn lại của mảng thứ hai sẽ được trình biên dịch khởi tạo thành 0.

Khóa học mới: Phát triển toàn bộ ngăn xếp cho người mới bắt đầu

Học lệnh Git, Angular, NodeJS, Maven & amp; Thêm

Đăng ký ngay Khóa học mới: Phát triển ngăn xếp đầy đủ cho người mới bắt đầu

  • Khởi tạo mảng bằng vòng lặp

Một mảng cũng có thể được khởi tạo bằng vòng lặp. Vòng lặp lặp từ 0 đến (size – 1) để truy cập tất cả các chỉ số của mảng bắt đầu từ 0. Cú pháp sau sử dụng “vòng lặp for” để khởi tạo các phần tử của mảng. Đây là cách phổ biến nhất để khởi tạo một mảng trong C.

// khai báo một mảng.

int my_array [5];

// khởi tạo mảng bằng vòng lặp “for”.

int i;

cho (i = 0; i & lt; 5; i ++)

{

my_array [i] = 2 * i;

}

// my_array = {0, 2, 4, 6, 8}

Trong cú pháp trên, một mảng có kích thước 5 được khai báo đầu tiên. Sau đó, mảng được khởi tạo bằng vòng lặp for lặp lại trên mảng bắt đầu từ chỉ mục 0 đến (size – 1).

Phần tử mảng Truy cập

Vì một mảng được lưu trữ liên tục trong bộ nhớ, nó có các chỉ mục bắt đầu từ “0” đến “array_size – 1”, còn được gọi là lập chỉ mục dựa trên 0. Việc lập chỉ mục này thể hiện vị trí trong mảng.

Các chỉ số mảng được sử dụng để truy cập bất kỳ phần tử nào của mảng theo cách sau:

array_name [index]

Chỉ mục của phần tử được truy cập được chỉ định trong dấu ngoặc vuông “[]”. Phạm vi của chỉ mục là số nguyên trong phạm vi [0, size).

Ví dụ:

int my_array [6];

// truy cập phần tử đầu tiên

my_array [0] = 100;

// truy cập phần tử thứ 4

my_array [2] = 300;

// truy cập phần tử cuối cùng

my_array [5] = 600;

Phần tử mảng đầu vào và đầu ra

Các giá trị của mảng có thể được lưu trữ bằng cách lấy đầu vào từ người dùng và lưu trữ chúng trong mảng. Ví dụ sau minh họa điều này:

// nhập một phần tử số nguyên và lưu trữ nó

// ở vị trí đầu tiên của mảng

scanf (“% d”, & amp; my_array [0]);

// nhập một phần tử float và lưu trữ nó

// ở vị trí thứ i của mảng

scanf (“% f”, & amp; my_array [i-1]);

Tương tự, các phần tử mảng cũng có thể được hiển thị trong đầu ra bằng phương thức printf (). Chỉ mục được chỉ định cho biết vị trí của phần tử sẽ được in. Ví dụ sau minh họa điều này:

// in phần tử được lưu trữ ở vị trí đầu tiên hoặc chỉ mục thứ 0

printf (“% d”, my_array [0]);

// in phần tử được lưu trữ ở vị trí thứ i hoặc chỉ mục thứ (i – 1)

printf (“% d”, my_array [i-1]);

Ưu điểm của Mảng trong C

Mảng có một ý nghĩa lớn trong ngôn ngữ C. Chúng cung cấp một số lợi thế cho các lập trình viên trong khi lập trình . Một số trong số đó là:

  • Mảng giúp mã được tối ưu hóa và rõ ràng hơn vì chúng tôi có thể lưu trữ nhiều phần tử trong một mảng cùng một lúc, vì vậy chúng tôi không phải viết hoặc khởi tạo chúng nhiều lần.
  • Mọi phần tử có thể được duyệt qua trong một mảng bằng một vòng lặp duy nhất.
  • Mảng giúp việc sắp xếp dễ dàng hơn nhiều. Các phần tử có thể được sắp xếp bằng cách viết một vài dòng mã.
  • Có thể truy cập bất kỳ phần tử mảng nào theo bất kỳ thứ tự nào từ phía trước hoặc phía sau trong thời gian O (1).
  • Việc chèn hoặc xóa các phần tử có thể được thực hiện với độ phức tạp tuyến tính trong một mảng.

Khóa học dành cho nhà phát triển web Full Stack

Để trở thành chuyên gia trong MEAN Stack

Xem khóa học Khóa học dành cho nhà phát triển web Full Stack

Nhược điểm của Mảng trong C

Mọi điều thuận lợi cũng đi kèm với một số nhược điểm. Điều này cũng đúng cho các mảng. Dưới đây là một số nhược điểm của mảng trong C:

  • Truy cập một mảng ngoài giới hạn: Nhược điểm đầu tiên của mảng là chúng được cấp phát tĩnh. Điều này có nghĩa là khi kích thước của chúng được khởi tạo, nó không thể tăng hoặc giảm. Để hiểu điểm này, hãy xem xét ví dụ dưới đây:

#include & lt; stdio.h & gt;

int main ()

{

// khai báo mảng có kích thước 20

int my_array [20];

// khởi tạo các phần tử mảng

cho (int i = 0; i & lt; 20; i ++)

{

// tôi sẽ là giá trị của e

// phần tử thứ i của mảng

my_array [i] = i;

}

// In giá trị ở chỉ mục 5 của mảng

printf (“Phần tử ở chỉ mục 5”

“là% d \ n”,

my_array [5]);

// In giá trị ở chỉ mục 13 của mảng

printf (“Phần tử ở chỉ mục 13”

“là% d \ n”,

my_array [13]);

// In giá trị ở chỉ mục 21 của mảng

printf (“Phần tử ở chỉ mục 21”

“là% d”,

my_array [21]);

trả về 0;

}

array_in_C_3.

Trong ví dụ trên, giá trị ban đầu của mảng arr là 20, vì vậy bằng cách in giá trị của các phần tử lên đến chỉ số 20, chúng ta sẽ nhận được đầu ra mong muốn. Nhưng khi chúng tôi cố gắng in phần tử ở chỉ mục thứ 21, nó đang đưa ra một giá trị rác. Điều này là do mảng được truy cập từ chỉ mục liên kết.

Sự cố này có thể được giải quyết bằng cách sử dụng các hàm malloc () và calloc (). Các hàm này cấp phát bộ nhớ động. Chúng tôi có một hàm free () cho phép chúng tôi giải phóng bộ nhớ không mong muốn theo ý muốn của chúng tôi. Ví dụ dưới đây minh họa tương tự:

#include & lt; stdio.h & gt;

#include & lt; stdlib.h & gt;

int main ()

{

// * ptr sẽ lưu trữ cơ sở

// địa chỉ của các phần tử mảng

int * ptr;

kích thước int, i;

// kích thước của mảng sẽ là 5

kích thước = 5;

printf (“Kích thước của mảng là:% d \ n”, size);

// cấp phát bộ nhớ mảng

// động bằng cách sử dụng malloc ()

ptr = (int *) malloc (size * sizeof (int));

// Kiểm tra xem bộ nhớ có

// đã được phân bổ thành công bởi malloc

if (ptr == NULL)

{

printf (“Bộ nhớ chưa được cấp phát \ n”);

thoát (0);

}

khác

{

// Bộ nhớ đã được cấp phát thành công

printf (“Bộ nhớ đã được cấp phát thành công \ n”);

// khởi tạo các phần tử của mảng

cho (i = 0; i & lt; size; ++ i)

{

ptr [i] = i + 1;

}

// In các phần tử của mảng

printf (“Các phần tử của mảng là:”);

cho (i = 0; i & lt; size; ++ i)

{

printf (“% d”, ptr [i]);

}

}

trả về 0;

}

array_in_C_4.

Đào tạo chứng chỉ Java MIỄN PHÍ

Học từ A-Z về Java chưa từng có

Đăng ký ngay < img alt = "Đào tạo chứng chỉ Java MIỄN PHÍ" class = "lazy" height = "9" src = "https://www.simplilearn.com/ice9/assets/form_opacity.png" width = "16" />

  • Tính đồng nhất: Chúng ta chỉ có thể lưu trữ một loại phần tử duy nhất trong mảng, tức là các mảng là đồng nhất. Chúng tôi không thể sử dụng nó như một mẫu. Ví dụ, nếu kiểu dữ liệu mảng là char, thì chỉ các ký tự có thể được lưu trữ trong mảng. Nếu bạn cố gắng lưu trữ số nguyên hoặc bất kỳ phần tử nào thuộc kiểu dữ liệu khác, nó sẽ gây ra lỗi. Để hiểu điểm này, hãy xem xét ví dụ dưới đây:

#include & lt; stdio.h & gt;

int main ()

{

// khai báo như vậy sẽ ném ra

// Lỗi biên dịch

int my_array [6] = {1, 2, “xoài”, 4, 5, 6.2};

int i;

printf (“Các phần tử của mảng là:”);

cho (i = 0; i & lt; 6; i ++)

{

printf (“% d”, my_array [i]);

}

trả về 0;

}

array_in_C_5.

Trong ví dụ trên, kiểu dữ liệu của mảng là int. Nhưng khi chúng ta cố gắng khai báo các giá trị chuỗi và giá trị float cho mảng, nó sẽ tạo ra một lỗi biên dịch.

Vấn đề này có thể được giải quyết bằng cách tạo một cấu trúc để lưu trữ các giá trị không đồng nhất (không đồng nhất). Hãy xem xét ví dụ dưới đây để hiểu khái niệm này:

#include & lt; stdio.h & gt;

// tạo một cấu trúc

ví dụ về cấu trúc

{

int fruit_quant;

float fruit_rate;

char fruit_name [30];

};

int main ()

{

// s1 – đối tượng của cấu trúc

struct example s1 = {10, 90.45, “Mango”};

// truy cập các thành viên cấu trúc

// sử dụng đối tượng cấu trúc

printf (“% d \ n”, s1.fruit_quant);

printf (“% f \ n”, s1.fruit_rate);

int i;

for (i = 0; s1.fruit_name [i]! = ‘\ 0’; i ++)

{

printf (“% c”, s1.fruit_name [i]);

}

trả về 0;

}

array_in_C_6.

Ví dụ về Mảng 1-D trong C

Các chương trình sau đây minh họa các hoạt động khai báo, khởi tạo, nhập / xuất và các hoạt động cơ bản như chèn, xóa, sắp xếp và tìm kiếm trong mảng 1-D trong C.

Ví dụ 1: Khai báo mảng, đầu vào và đầu ra

#include & lt; stdio.h & gt;

int main ()

{

// khai báo một mảng.

int my_array [6];

printf (“Nhập các phần tử của mảng: \ n”);

// đầu vào các phần tử của mảng.

int i;

cho (i = 0; i & lt; 6; i ++)

{

scanf (“% d”, & amp; my_array [i]);

}

printf (“\ n Các phần tử của dải là: \ n”);

// in các phần tử của mảng.

cho (i = 0; i & lt; = 5; i ++)

{

printf (“% d”, my_array [i]);

}

trả về 0;

}

array_in_C_7.

Trong ví dụ trên, một mảng số nguyên có kích thước 6 được khai báo. Mảng này có thể chứa nhiều nhất 6 phần tử nguyên. “Vòng lặp for” được sử dụng để nhập các phần tử mảng từ người dùng. Tương tự, một “vòng lặp for” được sử dụng để in các phần tử này trong đầu ra. Cả hai lần vòng lặp đều chạy từ 0 đến 5, để lặp lại trên tất cả các phần tử của mảng.

Khóa học dành cho nhà phát triển Java Full Stack

Hợp tác với HIRIST và HackerEarth

KHÁM PHÁ KHÓA HỌC < img alt = "Khóa học dành cho nhà phát triển Java Full Stack" class = "lazy" height = "9" src = "https://www.simplilearn.com/ice9/assets/form_opacity.png" width = "16" />

Ví dụ 2: Chèn và xóa trong một mảng.

#include & lt; stdio.h & gt;

int main ()

{

int i;

// khởi tạo một mảng.

int my_array [10] = {11, 6, 10, 50, 32, 56, 15, 98, 43, 22};

// chỉ mục đầu vào nơi phần tử sẽ được chèn.

int pos;

printf (“Nhập vị trí:”);

scanf (“% d”, & amp; pos);

// nhập phần tử cần chèn.

phần tử int;

printf (“Nhập phần tử:”);

scanf (“% d”, & amp; phần tử);

if (pos & gt; 10)

{

printf (“Dữ liệu nhập không hợp lệ!”);

}

khác

{

// dịch chuyển sang phải các phần tử của mảng.

cho (i = 9; i & gt; = pos – 1; i–)

my_array [i + 1] = my_array [i];

// chèn phần tử tại “pos”.

my_array [pos – 1] = element;

printf (“Mảng sau khi chèn là: \ n”);

// in các phần tử của mảng.

cho (i = 0; i & lt; = 10; i ++)

printf (“% d”, my_array [i]);

}

trả về 0;

}

array_in_C_8

Trong ví dụ trên, một phần tử cần được chèn được lấy làm đầu vào. Vị trí nơi phần tử này sẽ được lưu trữ cũng được lấy làm đầu vào. Các phần tử mảng được chuyển sang bên phải để tạo khoảng trống cho phần tử mới. Sau khi chèn, kích thước của mảng sẽ tăng lên.

Ví dụ 3: Tìm kiếm một phần tử trong mảng.

#include & lt; stdio.h & gt;

int main ()

{

int i, phần tử;

// khởi tạo một mảng.

int my_array [10] = {11, 6, 10, 50, 32, 56, 15, 98, 43, 22};

printf (“Nhập phần tử cần tìm: \ n”);

// phần tử đầu vào cần tìm kiếm.

scanf (“% d”, & amp; phần tử);

// xem qua mảng để tìm kiếm phần tử.

cho (i = 0; i & lt; = 9; i ++)

{

if (my_array [i] == phần tử)

{

// in chỉ mục tại đó

// phần tử được tìm thấy.

printf (“Phần tử được tìm thấy ở chỉ mục% d”, i);

nghỉ ngơi;

}

}

// nếu phần tử không được tìm thấy.

if (i == 10)

{

printf (“\ nKhông tìm thấy phụ kiện!”);

}

trả về 0;

}

array_in_C_9

Trong ví dụ trên, một phần tử được lấy làm đầu vào từ người dùng. Mảng được duyệt để tìm kiếm phần tử này một cách tuyến tính bằng cách so sánh tất cả các phần tử của mảng với phần tử cần tìm. Nếu phần tử tồn tại, thì chỉ mục của nó được in và “vòng lặp for” được thoát. Nếu phần tử không tồn tại, thì “vòng lặp for” được lặp lại ngắt quãng từ 0 đến 9 và “i” sẽ bằng 10.

Ví dụ 4: Sắp xếp các phần tử của một mảng

#include & lt; stdio.h & gt;

int main ()

{

int i, j, temp;

// khởi tạo một mảng.

int my_array [10] = {11, 6, 10, 50, 32, 56, 15, 98, 43, 22};

// in mảng không được sắp xếp.

printf (“Mảng ban đầu là: \ n”);

cho (i = 0; i & lt; 10; i ++)

{

printf (“% d”, my_array [i]);

}

// sắp xếp các phần tử của mảng theo thứ tự giảm dần.

cho (i = 0; i & lt; 10; i ++)

{

cho (j = i + 1; j & lt; 10; j ++)

{

if (my_array [j] & gt; my_array [i])

{

temp = my_array [i];

my_array [i] = my_array [j];

my_array [j] = temp;

}

}

}

// in các phần tử đã sắp xếp.

printf (“\ n \ n Mảng được sắp xếp theo thứ tự giảm dần là: \ n”);

cho (i = 0; i & lt; 10; i ++)

{

printf (“% d”, my_array [i]);

}

trả về 0;

}

array_in_C_10.

Trong ví dụ trên, một mảng có kích thước 10 được khởi tạo. Các phần tử mảng được sắp xếp theo thứ tự giảm dần bằng cách sử dụng Thuật toán sắp xếp bong bóng.

Ví dụ 5: Tìm phần tử lớn nhất và nhỏ nhất trong mảng 1-D trong C

# bao gồm & lt; stdio.h & gt;

int main ()

{

// khai báo mảng

int my_array [10] = {11, 6, 10, 50, 32, 56, 15, 98, 43, 22};

int i, nhỏ nhất, lớn nhất;

// gán giá trị của phần tử mảng đầu tiên

// đến nhỏ nhất và lớn nhất.

nhỏ nhất = lớn nhất = my_array [0];

// xem qua mảng.

cho (i = 0; i & lt; 10; i ++)

{

// nếu phần tử hiện tại lớn hơn phần tử lớn nhất,

// sau đó cập nhật giá trị lớn nhất.

if (my_array [i] & gt; lớn nhất)

{

lớn nhất = my_array [i];

}

// nếu phần tử hiện tại nhỏ hơn nhỏ nhất,

// sau đó cập nhật giá trị nhỏ nhất.

if (my_array [i] & lt; nhỏ nhất)

{

small = my_array [i];

}

}

// in phần tử nhỏ nhất và phần tử lớn nhất.

printf (“Phần tử nhỏ nhất trong mảng là:% d”, nhỏ nhất);

printf (“\ nPhần tử lớn nhất trong mảng là:% d”, lớn nhất);

printf (“\ n \ n”);

trả về 0;

}

array_in_C_11

Trong chương trình trên, phần tử lớn nhất và nhỏ nhất trong một mảng chưa được sắp xếp được in. Hai biến lớn nhất và nhỏ nhất được tạo ra để lưu trữ kết quả. Các biến này được khởi tạo cho các phần tử mảng đầu tiên. Mảng được duyệt theo tuyến tính và mỗi phần tử được so sánh với phần tử lớn nhất và nhỏ nhất hiện tại, đồng thời giá trị của chúng được cập nhật nếu tìm thấy phần tử lớn nhất hoặc nhỏ nhất mới.

Thêm Ngôi sao khác vào Đánh giá Hiệu suất của bạn

Học hỏi MIỄN PHÍ từ các chuyên gia trong ngành

Bắt đầu học tập  Thêm một ngôi sao khác vào đánh giá hiệu suất của bạn

2 Mảng thứ nguyên trong C

array_in_C_12

Mảng 2 chiều hoặc mảng 2-D là dạng mảng đa chiều đơn giản nhất trong C. Mỗi phần tử trong mảng 2-D có thể được biểu diễn dưới dạng một mảng 1-D riêng biệt. Mảng 2-D chứa một số hàng và cột nhất định và tổng số phần tử của mảng có thể được tìm thấy bằng cách nhân số hàng và cột. Ví dụ: nếu mảng là my_array [2] [3], thì tổng số phần tử trong mảng là 6.

Ma trận được cho là ma trận vuông khi số hàng bằng số cột. Khi số hàng khác với số cột, ma trận được cho là ma trận hình chữ nhật. Xử lý mảng 2-D yêu cầu một vòng lặp lồng nhau. Vòng lặp bên ngoài biểu thị số lượng hàng và vòng lặp bên trong biểu thị cột các phần tử của mỗi hàng. Tuy nhiên, tầm quan trọng của vòng ngoài và vòng trong có thể thay đổi cho nhau tùy thuộc vào việc người dùng muốn sử dụng ma trận thứ tự hàng hay ma trận thứ tự cột.

Khai báo mảng 2-D trong C

Cú pháp khai báo mảng 2 chiều trong C:

// khai báo mảng 2-d

dataType arrayName [no_of_rows] [no_of_columns];

Mô tả cú pháp:

  • dataType: Đây là kiểu dữ liệu chỉ định kiểu phần tử sẽ được lưu trữ trong mảng. Nó có thể là int, float, double, char.
  • arrayName: Đây là tên của mảng. Để chỉ định tên của một mảng, bạn phải tuân theo các quy tắc tương tự có thể áp dụng khi khai báo một biến thông thường trong C.
  • no_of_rows: Đây là thứ nguyên đầu tiên của mảng. Nó là một số nguyên xác định số hàng được giữ bởi mảng.
  • no_of_columns: Đây là thứ nguyên thứ hai của mảng. Đó là một giá trị số nguyên đại diện cho số cột của mảng.

Ví dụ

// Ma trận 5 x 10.

int my_array1 [5] [10];

// Ma trận vuông 3 x 3.

float my_array2 [3] [3];

// Ma trận 2 x 1.

char my_array3 [2] [1];

Lưu ý: Tổng số phần tử mà mảng có thể chứa là (no_of_rows * no_of_columns). Ví dụ: một mảng arr [2] [4] có thể có nhiều nhất 8 phần tử.

Khởi tạo Mảng 2-D trong C

Trong mảng 1-D, khi một mảng được khởi tạo tại thời điểm khai báo, bạn có thể bỏ qua việc chỉ định kích thước của nó. Tuy nhiên, kịch bản này khác với mảng 2-D. Chỉ có thể bỏ qua thứ nguyên đầu tiên và thứ nguyên thứ hai là bắt buộc tại thời điểm khởi tạo.

Các cách sau có thể được sử dụng để khởi tạo mảng 2-D trong C:

  • Cách thông thường: Đây là cách phổ biến nhất để khởi tạo một mảng trong C. Mảng 1-D bằng số chiều đầu tiên (hoặc các hàng) được tạo có các phần tử bằng số chiều thứ hai (hoặc cột).

Ví dụ

int my_array [3] [2] = {

{11, 12},

{21, 22},

{31, 32}

};

Trong ví dụ trên, 3 mảng 1-D (3 = số hàng) có 2 phần tử mỗi mảng (2 = số cột).

  • Cách rút gọn: Trong phương pháp này, tất cả các phần tử của mảng được viết trên cùng một dòng cách nhau bằng dấu phẩy. Nó trông giống như một khởi tạo mảng 1-D. Cách này không được khuyến khích vì mảng đã khởi tạo có ít khả năng đọc hơn.

Ví dụ

int my_array [3] [2] = {11, 12, 21, 22, 31, 32};

Trong ví dụ trên, tất cả các phần tử mảng được viết bên trong một cặp dấu ngoặc nhọn “{}”. Kiểu khởi tạo này khó đọc hơn.

  • Sử dụng vòng lặp: Giống như mảng 1-D, mảng 2-D cũng có thể được khởi tạo bằng vòng lặp. Vòng lặp được sử dụng phổ biến nhất là “vòng lặp for”. Cần có hai vòng lặp lồng nhau để khởi tạo mảng.

Ví dụ

int my_array [2] [3];

int i, j;

// Vòng lặp đầu tiên chạy đến hết số hàng.

cho (i = 0; i & lt; 2; i ++)

{

// vòng lặp thứ hai chạy cho đến số cột.

cho (j = 0; j & lt; 3; j ++)

{

my_array [i] [j] = i + j;

}

}

/ * my_array = {

{0, 1, 2},

{1, 2, 3}

} * /

Trong ví dụ trên, hai “vòng lặp for” được sử dụng để khởi tạo mảng 2-D. Vòng lặp đầu tiên chạy từ 0 đến số hàng. Và vòng lặp thứ hai chạy từ 0 đến số cột.

Những điểm cần nhớ khi khởi tạo mảng 2-D

Kích thước thứ hai là bắt buộc khi khai báo mảng 2-D, trong khi thứ nguyên đầu tiên có thể là tùy chọn. Các ví dụ sau minh họa những sai lầm có thể mắc phải khi khởi tạo mảng 2-D trong C:

// hợp lệ

int my_array [3] [3] = {10, 20, 30, 40, 50, 60, 70, 70, 80, 90}

// hợp lệ

int my_array [] [3] = {10, 20, 30, 40, 50, 60, 70, 70, 80, 90}

// không hợp lệ: thứ nguyên thứ hai phải được chỉ định.

int my_array [] [] = {10, 20, 30, 40, 50, 60, 70, 70, 80, 90}

// không hợp lệ: thứ nguyên thứ hai phải được chỉ định.

int my_array [3] [] = {10, 20, 30, 40, 50, 60, 70, 70, 80, 90}

Ví dụ về Mảng 2-D trong C

Các ví dụ sau minh họa cách triển khai cơ bản của mảng 2-D bao gồm các phép toán đầu vào và đầu ra trong ma trận 2-D và tìm chuyển vị của ma trận.

Ví dụ 1: Khai báo mảng 2-D, đầu vào và đầu ra.

#include & lt; stdio.h & gt;

int main ()

{

// khai báo và khởi tạo mảng 2-D.

// Mảng 2-D có 5 hàng và 2 cột.

int x [5] [2] = {{0, 1}, {2, 3}, {4, 5}, {6, 7}, {8, 9}};

int i, j;

// in ra giá trị của từng phần tử mảng.

// vòng lặp bên ngoài- cho các hàng.

cho (i = 0; i & lt; 5; i ++)

{

// vòng lặp bên trong- cho các cột.

cho (j = 0; j & lt; 2; j ++)

{

printf (“Phần tử tại x [% d”, i);

printf (“] [% d”, j);

printf (“]:”);

printf (“% d”, x [i] [j]);

printf (“\ n”);

}

}

trả về 0;

}

array_in_C_13.

Trong ví dụ sau, một mảng 2-D gồm 5 hàng và 2 cột đã được khai báo và khởi tạo. Để in, chúng tôi đang sử dụng hai “vòng lặp for”. “Vòng lặp for” bên ngoài in các hàng trong khi “vòng lặp for” bên trong in các cột cho mọi hàng.

Ví dụ 2: Tìm Tổng và Tích của hai 2 ma trận

#include & lt; stdio.h & gt;

int main ()

{

// khai báo arr1 và arr2.

int arr1 [2] [2], arr2 [2] [2];

int sum [2] [2], product [2] [2];

// đọc đầu vào cho arr1 từ người dùng.

printf (“Nhập các phần tử của arr1: \ n”);

cho (int i = 0; i & lt; 2; i ++)

{

cho (int j = 0; j & lt; 2; j ++)

{

printf (“arr1 [% d] [% d]:”, i, j);

scanf (“% d”, & amp; arr1 [i] [j]);

}

printf (“\ n”);

}

// đọc đầu vào cho arr2 từ người dùng.

printf (“Nhập các phần tử của arr2: \ n”);

cho (int i = 0; i & lt; 2; i ++)

{

cho (int j = 0; j & lt; 2; j ++)

{

printf (“arr2 [% d] [% d]:”, i, j);

scanf (“% d”, & amp; arr2 [i] [j]);

}

printf (“\ n”);

}

// thêm các phần tử mảng tương ứng.

printf (“Mảng tổng là: \ n”);

cho (int i = 0; i & lt; 2; i ++)

{

cho (int j = 0; j & lt; 2; j ++)

{

sum [i] [j] = arr1 [i] [j] + arr2 [i] [j];

// in mảng tổng

printf (“% d \ t”, sum [i] [j]);

}

printf (“\ n”);

}

// nhân các phần tử mảng tương ứng.

printf (“Mảng sản phẩm là: \ n”);

cho (int i = 0; i & lt; 2; i ++)

{

cho (int j = 0; j & lt; 2; j ++)

{

product [i] [j] = arr1 [i] [j] * arr2 [i] [j];

// in mảng sản phẩm.

printf (“% d \ t”, product [i] [j]);

}

printf (“\ n”);

}

trả về 0;

}

array_in_C_14

Để tìm phép cộng hai ma trận, số hàng và số cột phải giống nhau trong cả hai ma trận. Và để tìm tích của hai ma trận, số cột trong ma trận đầu tiên phải bằng số hàng trong ma trận thứ hai.

Để nhận tổng của hai ma trận, một ma trận kết quả có cùng thứ tự được khai báo. Để có được tích của hai ma trận, một ma trận kết quả có các hàng bằng ma trận thứ nhất và các cột bằng ma trận thứ hai được khai báo.

Ví dụ 3: Chuyển vị của ma trận

Ma trận vuông

#include & lt; stdio.h & gt;

int main ()

{

// khai báo các ma trận.

int arr [10] [10], chuyển vị [10] [10];

// đọc thông tin đầu vào từ người dùng.

printf (“Nhập các phần tử của arr \ n”);

cho (int i = 0; i & lt; 2; i ++)

cho (int j = 0; j & lt; 2; j ++)

scanf (“% d”, & amp; arr [i] [j]);

// sao chép phần tử mảng vào một phần tử khác.

cho (int i = 0; i & lt; 2; i ++)

cho (int j = 0; j & lt; 2; j ++)

chuyển đoạn [j] [i] = arr [i] [j];

printf (“Chuyển vị của arr: \ n”);

// in phần chuyển vị của arr

cho (int i = 0; i & lt; 2; i ++)

{

cho (int j = 0; j & lt; 2; j ++)

printf (“% d \ t”, transpose [i] [j]);

printf (“\ n”);

}

trả về 0;

}

array_in_C_15

Trong ví dụ trên, phép chuyển vị của một ma trận vuông được in. Để in chuyển vị của ma trận, trước tiên, các phần tử của ma trận được sao chép trong một ma trận khác và sau đó các hàng và cột của ma trận đã sao chép được đảo ngược.

Ma trận hình chữ nhật

#include & lt; stdio.h & gt;

int main ()

{

// khai báo các ma trận.

int arr [10] [10], chuyển vị [10] [10];

// đọc thông tin đầu vào từ người dùng.

printf (“Nhập các phần tử của arr \ n”);

cho (int i = 0; i & lt; 2; i ++)

{

cho (int j = 0; j & lt; 3; j ++)

scanf (“% d”, & amp; arr [i] [j]);

}

// sao chép phần tử mảng vào một phần tử khác.

cho (int i = 0; i & lt; 2; i ++)

{

cho (int j = 0; j & lt; 3; j ++)

chuyển đoạn [j] [i] = arr [i] [j];

}

printf (“Chuyển vị của arr: \ n”);

// in chuyển vị của mảng.

cho (int i = 0; i & lt; 3; i ++)

{

cho (int j = 0; j & lt; 2; j ++)

printf (“% d \ t”, transpose [i] [j]);

printf (“\ n”);

}

trả về 0;

}

array_in_C_16.

Trong ví dụ trên, ma trận là ma trận hình chữ nhật có nghĩa là số hàng không bằng số cột. Logic tương tự như trong ví dụ trước.

Ví dụ 4: Kiểm tra xem Ma trận đã cho có thưa hay không

#include & lt; stdio.h & gt;

#include & lt; stdlib.h & gt;

int main ()

{

int row, col, a [10] [10], count = 0;

// đọc số hàng và số cột từ người dùng.

printf (“Nhập số hàng: \ n”);

scanf (“% d”, & amp; row);

printf (“Nhập số cột: \ n”);

scanf (“% d”, & amp; col);

// đọc các phần tử của ma trận từ người dùng.

printf (“Nhập các phần tử ma trận: \ n”);

cho (int i = 0; i & lt; row; i ++)

{

cho (int j = 0; j & lt; col; j ++)

{

scanf (“% d”, & amp; a [i] [j]);

}

}

// in ma trận.

printf (“Ma trận là: \ n”);

cho (int i = 0; i & lt; row; i ++)

{

cho (int j = 0; j & lt; col; j ++)

{

printf (“% d \ t”, a [i] [j]);

}

printf (“\ n”);

}

// kiểm tra xem ma trận có thưa thớt hay không.

cho (int i = 0; i & lt; row; i ++)

{

cho (int j = 0; j & lt; col; j ++)

{

if (a [i] [j] == 0)

số lượng ++;

}

}

if (count & gt; ((row * col) / 2))

printf (“Ma trận là ma trận thưa thớt \ n”);

khác

printf (“Ma trận không phải là ma trận thưa thớt \ n”);

}

array_in_C_17

Trong ví dụ trên, nó được kiểm tra xem ma trận có thưa thớt hay không. Ma trận thưa thớt là ma trận trong đó số phần tử 0 lớn hơn các phần tử khác 0. Một bộ đếm được duy trì để đếm số lượng 0. Cuối cùng, số lượng 0 được so sánh với một nửa tổng số phần tử của ma trận.

Mảng so với Con trỏ

Mảng có thể hoạt động giống như con trỏ trong nhiều trường hợp chẳng hạn như khi một mảng được truyền cho hàm, nó được coi như một con trỏ. Ngoài ra, số học con trỏ có thể áp dụng cho mảng. Tuy nhiên, hai điều này khác nhau ở nhiều điểm. Biểu đồ so sánh sau đây tóm tắt những điểm khác biệt chính giữa con trỏ và mảng trong C.

CƠ SỞ SO SÁNH

ĐẾN

POINTER

ĐỊNH NGHĨA

Một mảng lưu trữ một hoặc nhiều giá trị cùng loại.

Một con trỏ lưu trữ địa chỉ hoặc vị trí bộ nhớ của một biến.

TỔNG HỢP

nhập tên_mảng [kích thước];

Nhập * ptr_name;

PHÂN PHỐI BỘ NHỚ

Bộ nhớ liền kề hoặc tuần tự được cấp phát cho các phần tử của mảng.

Một con trỏ có thể được cấp phát cho bất kỳ bộ nhớ có sẵn ngẫu nhiên nào.

KHÔNG GIAN NHỚ

Mảng là tĩnh nên không thể thay đổi kích thước của chúng.

Con trỏ là động, do đó, kích thước bộ nhớ có thể được thay đổi hoặc thậm chí được giải phóng.

KHÔNG. CÁC GIÁ TRỊ ĐƯỢC LƯU TRỮ

Một mảng duy nhất có thể lưu trữ một số lượng lớn các phần tử.

Một con trỏ chỉ có thể trỏ đến địa chỉ của một biến.

LOẠI

Kiểu dữ liệu của mảng được xác định bởi loại phần tử được lưu trữ trong đó.

Kiểu dữ liệu của một con trỏ được xác định bởi kiểu của biến có vị trí bộ nhớ mà nó trỏ tới.

Toán tử Sizeof ()

Khi một mảng được chuyển đến toán tử sizeof (), kích thước tổng hợp của tất cả các phần tử được lưu trữ sẽ được trả về.

Khi một con trỏ được chuyển đến toán tử sizeof (), kích thước của con trỏ sẽ được in (thường là 8). Kích thước này giống nhau đối với bất kỳ loại con trỏ nào.

COMPILE-TIME / RUN-TIME

Bộ nhớ được cấp cho một mảng trong quá trình biên dịch.

Bộ nhớ được cấp cho một con trỏ trong thời gian chạy chương trình.

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

Khi một mảng trong C được chuyển cho một hàm, chỉ địa chỉ của phần tử đầu tiên của mảng được chuyển cho hàm. Và có bản chất liền kề, toàn bộ mảng có thể được truy cập bởi hàm bằng cách sử dụng địa chỉ của phần tử đầu tiên.

Truyền một phần tử mảng cho một hàm

Chúng ta có thể chuyển một phần tử mảng duy nhất cho một hàm làm đối số của nó. Các ví dụ sau minh họa cách chúng ta có thể truyền một phần tử mảng cho một hàm. Ở đây, chúng tôi đã tạo một hàm chỉ đơn giản là in phần tử được chuyển đến nó.

# bao gồm & lt; stdio.h & gt;

// hàm có tham số kiểu int

void func (int a)

{

printf (“Phần tử mảng được truyền vào hàm là:% d”, a);

}

int main ()

{

// mảng 1-D được khởi tạo

int arr [] = {1, 2, 3, 4, 5};

// lệnh gọi hàm

func (arr [2]); // chuyển arr [2] tức là 3 vào func.

trả về 0;

}

array_in_C_18

Truyền Mảng 1-D cho một hàm

Trong phần trên, chúng ta đã thấy việc truyền một phần tử mảng cho một hàm. Trong phần này, chúng ta sẽ xem xét cách một mảng 1-D có thể được truyền cho một hàm thông qua một ví dụ đơn giản dưới đây. Ở đây, một hàm đã được thực hiện mà chúng ta đang truyền một mảng và kích thước của nó và hàm đang trả về phần tử lớn nhất của mảng đó.

# bao gồm & lt; stdio.h & gt;

// hàm tìm phần tử mảng lớn nhất

int tối đa (int arr [], int size)

{

int i;

int large = arr [0];

cho (i = 0; i & lt; size; i ++)

{

if (arr [i] & gt; large)

{

large = arr [i];

}

}

trả về lớn;

}

int main ()

{

int kết quả;

// Khởi tạo mảng 1-D

int arr [] = {100, 2, 1, 120, 55, 41};

int size = sizeof (arr) / sizeof (int);

// lệnh gọi hàm

result = Maximum (arr, size); // Mảng 1-D được truyền cho hàm.

printf (“Phần tử lớn nhất của mảng là:% d”, result);

trả về 0;

}

array_in_C_19.

Truyền một mảng đa chiều cho một hàm

Chúng ta cũng có thể chuyển một ma trận hoặc một mảng 2-D sang một ma trận. Ví dụ dưới đây minh họa tương tự khi một ma trận được truyền cho một hàm và hàm đang in ma trận đó.

# bao gồm & lt; stdio.h & gt;

// hàm in các phần tử ma trận

void printMatrix (int arr [3] [3])

{

int i, j;

printf (“Ma trận được hình thành là: \ n”);

cho (i = 0; i & lt; 3; ++ i)

{

// thay đổi dòng

printf (“\ n”);

cho (j = 0; j & lt; 3; ++ j)

{

printf (“% d \ t”, arr [i] [j]);

}

}

}

int main ()

{

int arr [3] [3], i, j;

// đọc đầu vào từ người dùng

printf (“Nhập các phần tử: \ n”);

cho (i = 0; i & lt; 3; ++ i)

{

cho (j = 0; j & lt; 3; ++ j)

{

scanf (“% d”, & amp; arr [i] [j]);

}

}

// truyền mảng 2-D hoặc một

// Ma trận làm đối số

printMatrix (arr);

trả về 0;

}

array_in_C_20

Con trỏ tới Mảng

Như chúng ta đã thảo luận ở phần trước về mối quan hệ và sự khác biệt giữa mảng và pointers in C. Trong này , chúng ta sẽ thảo luận về cách một con trỏ có thể được khai báo để lưu trữ địa chỉ của một mảng.

Có được những lợi ích sau bằng cách khai báo một con trỏ tới một mảng:

  • Các phần tử của mảng hiện có thể được truy cập theo nhiều cách.
  • Thời gian và không gian phức tạp của chương trình có thể được giảm bớt.
  • Mảng có thể được sử dụng hiệu quả hơn.

# bao gồm & lt; stdio.h & gt;

int main ()

{

int i;

int my_array [8] = {10, 20, 30, 40, 50, 60, 70, 80};

// khai báo một con trỏ trỏ đến mảng trên.

int * my_ptr = my_array;

my_ptr = my_array;

// truy cập một phần tử mảng bằng con trỏ.

* (my_ptr + 1) = 100;

// in các phần tử của mảng bằng con trỏ.

printf (“Các phần tử của mảng là: \ n”);

cho (i = 0; i & lt; 8; i ++) {

printf (“* (my_ptr +% d) =% d \ n”, i, * (my_ptr + i));

}

trả về 0;

}

array_in_C_21

Trong chương trình trên, một con trỏ * my_ptr đang trỏ đến mảng my_array. Điều này đơn giản có nghĩa là địa chỉ của phần tử đầu tiên của mảng (tức là my_array [0]) được lưu trữ trong con trỏ. Con trỏ hiện có quyền truy cập vào tất cả các phần tử của mảng.

Đó là tất cả về Array trong C

Đẩy nhanh sự nghiệp của bạn với tư cách là một Nhà phát triển ngăn xếp MEAN có tay nghề cao bằng cách đăng ký tham gia một Nhà phát triển Web Full Stack – MEAN Chương trình Thạc sĩ về Stack. Nhận được kiến ​​thức phát triển và kiểm tra đầy đủ về các công nghệ mới nhất bằng cách chọn tham gia Khóa học dành cho nhà phát triển Stack MEAN. Liên hệ với chúng tôi NGAY HÔM NAY!

Lời kết!

Tóm lại, trong bài viết này, bạn đã học khái niệm mảng trong C. Bạn bắt đầu với phần giới thiệu ngắn gọn về cấu trúc dữ liệu mảng và dần dần tiến tới thảo luận về nhu cầu, ưu điểm và nhược điểm của mảng. Tiếp theo, bạn đã thấy các cách khác nhau để khai báo và khởi tạo mảng trong C.

Tiếp theo, bạn đã học cách truy cập các phần tử của mảng và các phần tử đầu vào hoặc đầu ra đến / từ một mảng. Tiếp tục, bạn đã thấy một số ví dụ về mảng 1D và 2D. Cuối cùng, bạn đã học cách truyền một mảng cho một hàm, một khái niệm được gọi là con trỏ đến một mảng và sự khác biệt giữa một mảng và con trỏ .

Tại sao dừng lại ở đây? Nếu bạn muốn tìm hiểu về phát triển web đầy đủ, bạn chắc chắn nên xem khóa đào tạo chứng chỉ 9 tháng do giảng viên hướng dẫn của Simplilearn về Full Stack Phát triển Web . Điều này sẽ giúp bạn bắt đầu phát triển web chuyên nghiệp và bạn sẽ có thể học các khái niệm nâng cao như Agile methodologies , DevOps , Java và các khuôn khổ của nó như Spring , Hibernate, v.v., JS, CSS , HTML, , v.v. Nếu bạn có sở trường học các khóa học mới, bạn chắc chắn nên xem danh sách đầy đủ của Simplilearn về các khóa học miễn phí < / span>.

Nếu bạn có bất kỳ thắc mắc nào trong bài viết “Mảng trong C” này hoặc đề xuất cho chúng tôi, vui lòng nêu chúng trong hộp nhận xét và các chuyên gia của chúng tôi sẽ trả lời chúng cho bạn sớm nhất có thể.

Chúc bạn học vui vẻ!


Xem thêm những thông tin liên quan đến chủ đề khai báo một mảng trong c

Bài 2.1: Khai báo biến trong C++

alt

  • Tác giả: Tran Huong CNTT
  • Ngày đăng: 2022-04-02
  • Đánh giá: 4 ⭐ ( 5668 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: tranhuong tranhuongcntt LTCB NgonnguC Lập_trình_C++ C++
    Lập_trình_cơ_bản_với_C++
    CẢM ƠN TẤT CẢ QUÝ VỊ
    “ĐĂNG KÝ” ỦNG HỘ KÊNH PHÁT TRIỂN
    “LIKE” NẾU CẢM THẤY VIDEO HỮU ÍCH.

Mảng (Array) trong C/C++

  • Tác giả: quantrimang.com
  • Đánh giá: 3 ⭐ ( 5335 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Ngôn ngữ lập trình C/C++ cung cấp cấu trúc dữ liệu gọi là mảng, được lưu trữ trong một tập hợp các dữ liệu cùng kiểu với độ dài cố định. Một mảng được sử dụng để lưu trữ tập hợp dữ liệu, nhưng nó rất hữu dụng nếu bạn nghĩ về một mảng các biến với cùng một kiểu.

Học lập trình C cơ bản

  • Tác giả: vncoder.vn
  • Đánh giá: 5 ⭐ ( 7446 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Mảng (array) trong C là một tập hoặc một nhóm các phần tử (dữ liệu) có kiểu dữ liệu đồng nhất(tương tự). Các phần tử của mảng được lưu trong các vùng nhớ liên tiếp.

Mảng (array) trong C#, cách khởi tạo và khai báo

  • Tác giả: thuthuat.taimienphi.vn
  • Đánh giá: 3 ⭐ ( 8364 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: mang array trong c#, Mảng (array) trong C#, cách khởi tạo và khai báo

Mảng (array) trong C

  • Tác giả: viettuts.vn
  • Đánh giá: 5 ⭐ ( 7082 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Mảng (array) trong C là một tập hoặc một nhóm các phần tử (dữ liệu) có kiểu dữ liệu đồng nhất(tương tự). Các phần tử của mảng được lưu trong các vùng nhớ

Mảng 1 chiều trong C/C++ | Cách khai báo mảng trong C/C++

  • Tác giả: cdspvinhlong.edu.vn
  • Đánh giá: 4 ⭐ ( 1584 lượt đánh giá )
  • Khớp với kết quả tìm kiếm:

Mảng trong Ngôn ngữ C

  • Tác giả: vietjack.com
  • Đánh giá: 4 ⭐ ( 2355 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Mảng trong C – Học C cơ bản và nâng cao theo các bước đơn giản và ví dụ dễ hiểu bắt đầu từ cơ bản về C, Toán tử, kiểu dữ liệu, hàm, vòng lặp, mảng, con trỏ, cấu trúc, chuỗi, lệnh, input và output, quản lý bộ nhớ, bộ tiền xử lý, điều khiển luồng etc.

Xem thêm các bài viết khác thuộc chuyên mục: Kiến thức lập trình

Xem Thêm  Hướng dẫn ASP - hướng dẫn lõi asp net w3schools