แนวคิดของอาร์เรย์ลองจินตนาการว่ามีปัญหาอยู่ปัญหาหนึ่ง คือ ต้องการตัวแปรแบบจำนวนเต็ม 20 ตัว และให้รับค่าตัวแปรทั้ง 20 ตัว และแสดงค่าตัวแปรทั้ง 20 ตัวนั้นด้วย ฉะนั้นวิธีการแก้ปัญหา คือ จะต้องประกาศตัวแปร 20 ตัว ดังแสดงในรูป 8-1
รูปที่ 8-1 ตัวแปรทั้ง 20 ตัว
ปัญหาต่อมา คือ ผู้ใช้จะต้องเขียนโปรแกรมยาวขนาดไหน ในการรับค่ามาใส่ตัวแปรทั้ง 20 ตัว และแสดงค่าของตัวแปรทั้ง 20 ตัว ในรูปที่ 8-2 แสดงผังงานการทำงานของการรับข้อมูลและการแสดงข้อมูล
ซึ่งถ้ามีตัวแปรเพียงแค่ 20 ตัวก็คงไม่สร้างปัญหาให้มากนัก แต่ถ้าปัญหานั้นต้องการใช้ตัวแปรมากกว่านั้น เป็น 200 หรือ 2000 หรือ 20000 ตัวจะทำให้โปรแกรมยาวขนาดไหนและผู้ใช้จะต้องจำชื่อตัวแปรเหล่านั้นทั้งหมด จึงเป็นสาเหตุที่ทำให้เกิดตัวแปรแบบอาร์เรย์ หรือ Array ขึ้นมา
อาร์เรย์ คือ ชุดของตัวแปรชนิดเดียวกัน ซึ่งสมาชิกของอาร์เรย์จะเป็นตัวแปรพื้นฐาน จำนวนสมาชิกในอาร์เรย์มีขนาดแน่นอน และสมาชิกของอาร์เรย์แต่ละตัว (ในที่นี้จะขอเรียกว่า Element) จะมีลำดับ (Index) ประจำตัว ลักษณะอาร์เรย์ทางความคิดแสดงในรูปที่ 8-3
รูปที่ 8-2 ผังการทำงานการรับค่าและแสดงผลของตัวแปรทั้ง 20 ตัว
รูปที่ 8-3 แสดงลักษณะของอาร์เรย์ตามแนวความคิด
ถ้าต้องการเข้าถึงอาร์เรย์แต่ละ Element ก็สามารถทำได้โดยการอ้างชื่อแล้วตามด้วยลำดับของ Element ที่ต้องการ เช่น ถ้าต้องการเข้าอาร์เรย์ที่ชื่อ number ใน Element ที่ 0 ก็ สามารถทำได้ดังนี้
number[0]
กลับไปที่ปัญหาเดิมในตอนต้น วิธีการรับเข้าและแสดงข้อมูลก็จะทำได้ง่ายขึ้นโดยอาศัยลูปเข้ามาช่วย ไม่ว่าจะมี 2, 20, 200 หรือ 20,000 ก็จะเปลี่ยนลำดับของ Element จากตัวเลขเป็นตัวแปร ตัวอย่างเช่น i ซึ่งในรูปที่ 8-4 แสดงการใช้ลูปเข้ามาช่วยในการใช้อาร์เรย์
number[i]
การใช้อาร์เรย์ในภาษา C
ในหัวข้อนี้จะกล่าวถึงการประกาศและการกำหนดลักษณะของอาร์เรย์ รวมไปถึงการกำหนดค่าให้กับอาร์เรย์ การเข้าและเปลี่ยนแปลงค่าภายในแต่ละ Element ของอาร์เรย์ ซึ่งในรูปที่ 8-5 แสดงอาร์เรย์ชื่อ scores และค่าของมัน
การประกาศและการกำหนดลักษณะของอาร์เรย์
ทั้ง 2 อย่างนี้จะต้องทำก่อนการใช้อาร์เรย์เสมอ การประกาศและการกำหนดลักษณะของอาร์เรย์จะเป็นการบอกให้ตัวคอมไพเลอร์ทราบว่า อาร์เรย์นี้ชื่อว่าอะไร มีชนิดข้อมูลเป็นแบบไหน และมีจำนวนกี่ Element ซึ่งในรูปที่ 8-6 แสดงอาร์เรย์ 3 อาร์เรย์ที่มีชนิดข้อมูลที่แตกต่างกัน
การเข้าถึงแต่ละ Element ของอาร์เรย์
ภาษา C นั้นจะใช้ลำดับในการเข้าถึงแต่ละ Element ของอาร์เรย์ ซึ่งลำดับแรกจะเป็น 0 เสมอ ลำดับของ Element ของอาร์เรย์โดยส่วนมากจะเป็นค่าตัวเลขจำนวนเต็ม ตัวอย่างเช่น ใช้อาร์เรย์ scores ในรูปที่ 8-5 เราจะเข้าถึง Element แรกได้ดังนี้
scores[0]
และถ้าต้องการจะประมวลผล Element ทั้งหมด ก็สามารถใช้ลูปเข้ามาช่วยได้ดังตัวอย่างด้านล่างนี้
for (i=0;<9;i++)
scores[i]…;
การกระทำกับอาร์เรย์
การประกาศและกำหนดลักษณะอาร์เรย์นั้น อาร์เรย์ที่ได้จะเป็นค่าว่าง หรือ Null อยู่ถ้าต้องการจะบรรลุค่าลงในอาร์เรย์ จะต้องใช้วิธีการกำหนดค่าให้แต่ละ Element
การกำหนดค่าเริ่มต้น (Initialization)
การกำหนดค่าเริ่มต้นให้กับอาร์เรย์สามารถทำได้ 4 แบบ ดังนี้
1. Basic Initialization เป็นการประกาศและกำหนดลักษณะ พร้อมทั้งกำหนดค่าเริ่มต้นให้กับอาร์เรย์เลย จะกำหนดว่ามีจำนวน Element กี่ Element พร้อมกำหนดค่าให้แต่ละ Element เลย ดังแสดงในรูปที่ 8-7 ก
2. Initialization Without Size เป็นการประกาศและกำหนดลักษณะ พร้อมทั้งกำหนดค่าเริ่มต้นให้กับอาร์เรย์ แต่ไม่กำหนดว่าจำนวน Element ใดเท่าไร แต่จะกำหนดค่าให้ไปเลยแล้วตัวคอมไพเลอร์จะกำหนดจำนวนของ Element ตามจำนวนค่าที่กำหนดไว้ ดังแสดงในรูปที่ 8-7 ข
3. Partia Initialization เป็นการประกาศและกำหนดลักษณะ พร้อมทั้งกำหนดค่าเริ่มต้นให้กับอาร์เรย์ โดยกำหนดเลยว่ามีจำนวน Element แต่จะกำหนดค่าให้ไม่ครบตามจำนวนของ Element ฉะนั้น Element ที่เหลือจะมีค่าเป็น 0 ดังแสดงในรูปที่ 8-7 ค
4. Initialization to All Zero เป็นการประกาศและกำหนดลักษณะ พร้อมทั้งกำหนดค่าเริ่มต้นให้กับอาร์เรย์ โดยกำหนดเลยว่ามีจำนวน Element กี่ Element แต่ค่าที่กำหนดให้ มีเลข 0 เพียงตัวเดียว ตัวคอมไพเลอร์จะกำหนดให้ Element ทุกตัวมีค่าเป็น 0 ทั้งหมด ดังแสดงในรูปที่ 8-7 ง
การรับค่า เป็นการใช้ฟังก์ชัน scanf มารับค่าใส่ลงในแต่ละ Element ของอาร์เรย์ โดยการใช้ลูปเข้ามาช่วยในการรับค่า โดยส่วนใหญ่จะใช้ลูป for เพราะว่ารู้จำนวนของ Element อยู่แล้ว
for (i=0;i<9;i++)
scanf(“%d”,&scores[i]);
การกำหนดค่า เป็นการกำหนดค่าให้กับเฉพาะ Element โดยการใช้เครื่องหมาย กำหนดค่า หรือ = นั้นเอง ตัวอย่างเช่น
score[4] = 23;
และยังสามารถคัดเลือกค่าจากอาร์เรย์หนึ่งไปใส่ในอีกอาร์เรย์หนึ่งได้ ดังตัวอย่าง
for (i=0;i<25;i++)
second[i] = first[i];
การสลับค่า
ในการสลับค่าระหว่าง 2 Element ในอาร์เรย์ ตัวอย่างเช่น ต้องการสลับค่าระหว่าง number[3] และ number[1] ในรูปที่ 8-7 ถ้าผู้ใช้ไม่เข้าใจอาจจะเขียนดังตัวอย่างด้านล่างนี้
number[3] = number[1];
number[1] = number[3];
ซึ่งตัวอย่างด้านบนนั้นเป็นการเขียนโปรแกรมที่ผิด ผิดอย่างไรให้ดูที่รูปที่ 8-8
ในรูปที่ 8-8 จะพบว่าค่าจริง ๆ ใน number[3] นั้นหายไปหลังจากที่ทำการสลับ วิธีการแก้ก็สามารถทำได้โดยการหาตัวแปรขยะตัวหนึ่งมาเก็บค่าของ number[3] ก่อนจะย้ายค่าจาก number[1] มาใส่
temp = number[3]
number[3] = number[1];
number[1] = temp;
ซึ่งการทำงานสามารถแสดงในรูปที่ 8-9
การแสดงค่า
เป็นการนำค่าในแต่ละ Element ออกมาแสดง โดยใช้ลูป for เข้ามาช่วย ดังแสดงในตัวอย่างด้านล่าง
for (i=0;i<9;i++)
printf(“%d”,second[i]);
prinf(“\n”);
ตัวอย่างข้างต้นนี้ เมื่อจบลูป for แล้ว จะเห็นได้ว่าข้อมูลจะพิมพ์ออกในบรรทัดเดียวกันทั้งหมด ถ้ามีข้อมูล 100 ตัว ก็จะทำให้ผลลัพธ์ที่แสดงออกมานั้นดูไม่สวย ฉะนั้นควรจะจัดให้แสดง 10 ตัวต่อบรรทัด ดังแสดงชุดคำสั่งในโปรแกรมที่ 8-1
โปรแกรมที่ 8-1 แสดงการพิมพ์ 10 ตัวต่อบรรทัด
โปรแกรมที่ 8-2 โปรแกรมแสดงลำดับ และค่าของ Element ในลำดับนั้น
ผลลัพธ์ที่ได้
Element Square
= = = = = = = = = = = = = = = = =
1. 0
2. 1
3. 4
4. 9
5. 12
โปรแกรมที่ 8-3 เป็นโปรแกรมที่จะรับค่าตัวเลขตามจำนวนที่ได้กำหนดไว้ในตอนแรกแล้วจะพิมพ์ตัวเลขเหล่านั้นย้อนหลังจากตัวที่รับสุดท้ายมาแสดงเป็นตัวแรก
โปรแกรมที่ 8-3 โปรแกรมแสดงการรับตัวเลขและแสดงตัวย้อนหลัง
ผลลัพธ์ที่ได้
You may enter up to 50 integers:
How many would you like to enter ? 12
Enter your numbers:
1 2 3 4 5 6 7 8 9 10 11 12
Your numbers reversed are:
12 11 10 9 8 7 6 5 4 3 2 1
อาร์เรย์กับฟังก์ชัน
ในการประมวลอาร์เรย์ในโปรแกรมใหญ่นั้น ผู้ใช้ต้องการใช้การส่งค่าอาร์เรย์ไปให้กับฟังก์ชัน ซึ่งสามารถทำได้ 2 แบบ คือ
1. การส่งค่าแบบ Element เดียว (Passing Individual Elements) ผู้ใช้สามารถจะส่งค่าของ Element เดียว ไปให้กับฟังก์ชันอื่นได้ ตัวอย่าง สมมุติว่ามีฟังก์ชัน print_square ซึ่งต้องการพารามิเตอร์ที่มีชนิดข้อมูลเป็น int และจะพิมพ์ค่านั้นออกทางหน้าจอ และใช้อาร์เรย์ชื่อ base ผู้ใช้สามารถใช้ลูปเพื่อส่งค่าแต่ละ Element ไปให้กับฟังก์ชัน print_square
2. การส่งค่าแบบทั้งอาร์เรย์ (Passing The Whole Array) เมื่อผู้ใช้ต้องการส่งค่าอาร์เรย์ให้กับฟังก์ชันอื่น จะใช้ชื่อของอาร์เรย์เป็นพารามิเตอร์ที่ส่งไปให้ ซึ่งพารามิเตอร์ของฟังก์ชันที่ถูกเรียกมีการประกาศ ดังนี้
int x[]
การเรียกการส่งค่าจะมีข้อกำหนด ดังนี้
เวลาจะส่งค่าไปให้กับฟังก์ชันที่ถูกเรียก ก็เพียงใช้ชื่อของอาร์เรย์เท่านั้น
ส่วนพารามิเตอร์ที่อยู่ในฟังก์ชันที่ถูกเรียก จะต้องกำหนดให้มีชนิดข้อมูลเดียวกัน แต่จะไม่ต้องกำหนดขนาดของอาร์เรย์
จากรูปที่ 8-11 จะพบว่า พารามิเตอร์ x นั้นจะชี้ไปยังอาร์เรย์ base ซึ่งการเรียกใช้ค่าในแต่ละ Element ของอาร์เรย์ base ได้เลยทุกตัว โดยการเรียกผ่านพารามิเตอร์ x และผู้ใช้สามารถเปลี่ยนแปลงค่าในอาร์เรย์ที่ส่งค่าแบบนี้มา ตัวอย่างในรูปที่ 8-12 จะทำการคูณค่าในแต่ละ Elementในอาร์เรย์ base ด้วย 2
อาร์เรย์ 2 มิติ
ในตอนต้นที่กล่าวมาทั้งหมดนั้นจะเป็นอาร์เรย์เพียง 1 มิติเท่านั้น แต่ในงานบางอย่างต้องการข้อมูลที่อยู่ในลักษณ์ที่มากกว่า 1 มิติ อาร์เรย์ 2 มิตินั้นก็เปรียบเสมือนตารางนั้นที่ประกอบไปด้วยแถวและคอลัมน์ ในรูปที่ 8-13 แสดงตารางซึ่งสามารถเรียกได้เป็น อาร์เรย์ 2 มิติ
ถึงแม้ว่าอาร์เรย์ 2 มิติที่แท้จริงนั้นแสดงในรูปที่ 8-13 แต่ในภาษา C จะมองเป็นในอาร์เรย์ 1 มิติอยู่ แต่จะใช้เลขลำดับของ Element เป็น 2 ตัว ตัวแรกเป็นแถวตัวที่ 2 เป็นคอลัมน์ ซึ่งลักษณะทางแนวความคิดของภาษา C ดังแสดงในรูปที่ 8-14
การประกาศและการกำหนดลักษณะของอาร์เรย์ 2 มิติ
อาร์เรย์ 2 มิติ จะเหมือนกับอาร์เรย์ 1 มิติ ในการประกาศและกำหนดลักษณะก่อนการใช้ จะเป็นตัวบอกให้คอมไพเลอร์รู้ว่า อาร์เรย์ที่สร้างมีชื่ออะไร มีชนิดข้อมูลของแต่ละ Element เป็นชนิดอะไร และมีขนาดของแต่ละมิติเป็นเท่าไร ดังตัวอย่างที่แสดงในรูปที่ 8-14 สามารถทำการประกาศและกำหนดลักษณะได้ดังนี้
int talbe [5] [4];
โดยตัวเลขตัวแรกจะบอกจำนวนของแถว และตัวเลขตัวที่ 2 จะบอกจำนวนของคอลัมน์ในแต่ละแถว
การกำหนดค่าเริ่มต้น หลังจากที่ได้ทำการประกาศและกำหนดลักษณะของอาร์เรย์แล้วในแต่ละ Element ของอาร์เรย์จะยังไม่มีค่าบรรจุอยู่ ในการกำหนดค่าเริ่มต้นของ Element แต่ละตัวสามารถทำได้หลังจากการประกาศ ตัวอย่างสมมุติว่าต้องการใช้ 20 ค่า การกำหนดค่าเริ่มต้นแบบทางเดียวจะเป็นดังนี้
int table [5] [4]; =
{ 0, 1, 2, 3, 10, 11, 12, 13, 20, 21, 22, 23, 30, 31, 32, 33, 40, 41, 42, 43 };
หรือการกำหนดค่าเริ่มต้นให้กับอาร์เรย์ วิธีที่ดีที่สุดจะเป็นดังนี้
int table [5] [4];
{
{ 0, 1, 2, 3 },
{10, 11, 12, 13 },
{20, 21, 22, 23 },
{30, 31, 32, 33 },
{40, 41, 42, 43 }
}; /* table */
แต่เมื่อใดที่ผู้ใช้ไม่ต้องการจะกำหนดขนาดของมิติใดมิติหนึ่ง ผู้ใช้ก็สามารถทำการกำหนดค่าเริ่มต้นได้ดังนี้
int table [] [4] =
{
{ 0, 1, 2, 3 },
{10, 11, 12, 13 },
{20, 21, 22, 23 },
{30, 31, 32, 33 },
{40, 41, 42, 43 }
}; /* table */
และถ้าต้องการกำหนดค่าเริ่มต้นทั้งอาร์เรยให้เป็น 0 ทั้งหมด ผู้ใช้สามารถทำได้ดังนี้
int table [5] [4] = {0};
การรับค่า เป็นการใช้ฟังก์ชัน scanf มารับค่าใส่ลงในแต่ละ Element ของอาร์เรย์ 2 มิตินั้น จะต้องใช้ลูป 2 ลูปซ้อนกัน สมมุติว่าอาร์เรย์มีขนาด n m ลูปแรกจะเป็นของแถวโดยจะทำตั้งแต่ 0 ถึง n – 1ส่วนลูปที่ 2 จะเป็นของคอลัมน์จะทำตั้งแต่ 0 ถึง m – 1 ถ้าต้องการรับค่าเข้าในอาร์เรย์ในรูปที่ 8-14 สามารถทำได้ดังนี้
for (row = 0; row < 5; row++)
for (column = 0; column < 4; column++)
scanf (“%d”,&table[row][column]);
การแสดงค่า เป็นการนำค่าในแต่ละ Element ออกมาแสดง โดยใช้ลูป for ซ้อนกัน 2 ลูปเข้ามาช่วย โดยลูปแรกจะเป็นตัวควบคุมการพิมพ์ของแถว และลูปที่ 2 จะเป็นตัวควบคุมการพิมพ์ของคอลัมน์ เมื่อจะพิมพ์อาร์เรย์ table ออกมาเป็นรูปแบบตาราง จะต้องทำการขึ้นบรรทัดใหม่ทุกครั้ง เมื่อพิมพ์แต่ละแถวจบ ซึ่งแสดงดังตัวอย่างด้านล่าง
for (row = 0; row < 5; row++)
{
for (coluun =0; column < 4; column++)
printf(“%8d”, tale[row][column]);
printf(“\n”);
}
การกำหนดค่า เป็นการกำหนดค่าให้กับเฉพาะ Element โดยการใช้เครื่องกำหนดค่าหรือ = นั่นเอง ตัวอย่างเช่น
table[2][0] = 23;
table[0][1] = table[3][2] + 15;
การส่งค่าของอาร์เรย์ 2 มิติไปให้กับฟังก์ชัน
การส่งค่าของอาร์เรย์ 2 มิติไปให้กับฟังก์ชันนั้น สามารถทำได้ 3 แบบ ดังนี้
1. การส่งค่าแบบ Element เดียว (Passing Individual Elements) ซึ่งมีการกระทำเหมือนกับอาร์เรย์ 1 มิติ คือ ให้ลูปวนส่งค่าไปทีละ Element
2. การส่งค่าที่แถว (Passing a Row) เป็นการส่งค่าทั้งแถว โดยการใช้ลำดับของแถวเป็นตัวส่งไป ซึ่งแสดงในรูปที่ 8-15 ซึ่งพารามิเตอร์ที่รับจะเป็นอาร์เรย์ 1 มิติ ในฟังก์ชันที่ถูกเรียงก็จะใช้ลูป for เพียง 1ลูปในการทำงานเหมือนกับการส่งอาร์เรย์ 1 มิติมาให้
3. การส่งค่าแบบทั้งอาร์เรย์ (Passing The Whole Array) เมื่อผู้ใช้ต้องการส่งค่าอาร์เรย์ 2 มิติไปให้กับฟังก์ชันอื่น จะใช้ชื่อของอาร์เรย์เป็นพารามิเตอร์ที่เป็นอาร์เรย์ 2 มิติ โดยมีตัวอย่างการประกาศฟังก์ชันดังนี้
Double average (int table[] [MAX_COLS]);
ซึ่งจะสังเกตได้ว่าการประกาศพารามิเตอร์ที่เป็นอาร์เรย์ 2 มิติ ที่กำหนดแต่ขนาดของคอลัมน์ไว้เพียงเท่านั้น ซึ่งจะมีข้อกำหนดในการส่งค่าดังนี้
1. เวลาจะส่งค่าไปให้กับฟังก์ชันที่ถูกเรียก ก็เพียงใช้ชื่อของอาร์เรย์เท่านั้น
2. ส่วนพารามิเตอร์ในฟังก์ชันที่ถูกเรียก จะต้องกำหนดให้มีชนิดข้อมูลเดียวกัน และเป็นอาร์เรย์ 2 มิติ โดยกำหนดแต่ขนาดของคอลัมน์เท่านั้น
ในโปรแกรมที่ 8-4 แสดงการกำหนดค่าในแต่ละ Element ของอาร์เรย์ให้มีลักษณะเป็น Matrix ดังรูปที่ 8-17
โปรแกรมที่ 8-4 กำหนดค่าลงในอาร์เรย์ตามแบบรูปที่ 8-17
อาร์เรย์หลายมิติ
อาร์เรย์หลายมิติสามารถมีได้ตั้งแต่ 3 มิติ 4 มิติ หรือหลายมิติ ซึ่งในรูปทื่ 8-18 แสดงอาร์เรย์ที่มีมิติ 3 มิติ
ถึงแม้ว่าอาร์เรย์ 3 มิติ ที่แท้จริงจะเป็นดังในรูปที่ 8-18 แต่ในภาษา Cจะมองเป็นแบบอื่น คือ การสร้างอาร์เรย์ 3 มิติ จะสร้างจากอาร์เรย์ 2 มิติหลายอัน และอาร์เรย์ 2 มิติ ก็จะสร้างมาจากอาร์เรย์ 1 มิติ ฉะนั้นจะเรียกอาร์เรย์ 3 มิติ ว่าเป็นอาร์เรย์ของอาร์เรย์นั้นเอง ลักษณะที่ภาษา C มองกับอาร์เรย์ 3 มิติ
การประกาศและการกำหนดลักษณะของอาร์เรย์ 3 มิติ
อาร์เรย์หลายมิติจะเหมือนกับอาร์เรย์ 1 มิติ ในการประกาศและกำหนดลักษณะก่อนการใช้ ซึ่งการประกาศและกำหนดลักษณะนั้นจะเป็นตัวบอกให้คอมไพเลอร์รู้ว่า อาร์เรย์ที่สร้างมีชื่ออะไร มีชนิดข้อมูลของแต่ละ Element เป็นอะไร และมีขนาดของแต่ละมิติเป็นเท่าไร ซึ่งตัวอย่างที่แสดงในรูปที่ 8-19 สามารถทำการประกาศและกำหนดลักษณะได้ดังนี้
int table [3] [5][4];
การกำหนดค่าเริ่มต้น หลังจากที่ได้ทำการประกาศและกำหนดลักษณะของอาร์เรย์แล้วในแต่ละ Element ของอาร์เรย์จะยังไม่มีค่าบรรจุอยู่ ในการกำหนดค่าเริ่มต้นของ Element แต่ละตัวสามารถทำได้หลังจากที่การประกาศอาร์เรย์ โดยการกำหนดค่าเริ่มต้นสามารถทำได้ดังนี้
int table [3][5][4];
{
{ /* แผ่น 0 */
{ 0, 1, 2, 3}, /* แถว 0 */
{10, 11, 12 13}, /* แถว 1 */
{20, 21, 22, 23}, /* แถว 2 */
{30, 31, 32, 33}, /* แถว 3 */
{40, 41, 42, 43} /* แถว 4 */
},
{ /* แผ่น 0 */
{100, 101, 102, 103}, /* แถว 0 */
{110, 111, 112, 113}, /* แถว 1 */
{120, 121, 122, 123}, /* แถว 2 */
{130, 131, 132, 133}, /* แถว 3 */
{140, 141, 142, 143} /* แถว 4 */
},
{ /* แผ่น 0 */
{200, 201, 202, 203}, /* แถว 0 */
{210, 211, 212, 213}, /* แถว 1 */
{220, 221, 222, 223}, /* แถว 2 */
{230, 231, 232, 233}, /* แถว 3 */
{240, 241, 242, 243} /* แถว 4 */
}
};/* table */
และถ้าต้องการกำหนดค่าเริ่มต้นทั้งอาร์เรย์ให้เป็น 0 ทั้งหมด ผู้ใช้สามารถทำได้ดังนี้
int table [3][5][4] = {0};
Design by Pratya |
การสร้างบทเรียนออนไลน์ด้วย Wordpress วิชาการเขียนโปรแกรมภาษาซี 