ใบความรู้ที่ 6.1
ชนิดข้อมูลแบบอาเรย์
ที่มีปริมาณข้อมูลมาก ๆ ที่อาศัยการประมวลผลในรูปแบบเดียวกัน ดังนั้นการเขียนโปรแกรมเพื่อจัดการงาน
เหล่านี้จะต้องมีการเก็บข้อมูลเป็นจำนวนมากลงในตัวแปร ในกรณีนี้ หากเราประกาศตัวแปรหนึ่งตัวสำหรับ
ข้อมูลหนึ่งจำนวนโปรแกรมของเราจะประกอบด้วยตัวแปรเป็นจำนวนมาก นอกจากนั้นการเข้าถึงค่าภายใน
ตัวแปรจะต้องกระทำผ่านตัวแปรแต่ละตัวโดยตรงและไม่สามารถรวบรวมการประมวลผลในรูปแบบ
เดียวกันไว้ในโครงสร้างแบบวนซ้ำได้ ภาษาโปรแกรมส่วนใหญ่รวมทั้ง C# จึงรองรับการใช้งานโครงสร้าง
การเก็บข้อมูลชนิดพิเศษที่อนุญาตให้เราจัดการกับข้อมูลชนิดเดียวกันหลาย ๆ จำนวนผ่านตัวแปรเพียงตัว
เดียว โครงสร้างการเก็บข้อมูลดังกล่าวมีชื่อเรียกว่า อาเรย์ (array) และตัวแปรที่ประกาศขึ้นมาเพื่อใช้อ้างถึง อาเรย์จะถูกเรียกว่า ตัวแปรแบบอาเรย์
1. การประกาศตัวแปรแบบอาเรย์
ดังเช่นตัวแปรทั่ว ๆ ไป ตัวแปรแบบอาเรย์จะต้องมีการประกาศล่วงหน้าก่อนการใช้งาน โดยมี
รูปแบบดังต่อไปนี้
|
DataType[]
ArrayName;
|
ในที่นี้ ArrayName คือชื่อตัวแปรแบบอาเรย์ และ DataType คือชนิดข้อมูลแต่ละจำนวนที่ตัวแปรนี้
เก็บค่าได้ สังเกตว่าการประกาศตัวแปรแบบอาเรย์มีความคล้ายคลึงกับการประกาศตัวแปรแบบปกติแต่
ต่างกันเพียงเครื่องหมาย [] ที่ต้องใส่เพิ่มเข้าไปเท่านั้น นอกจากนั้นหากเรามองการประกาศตัวแปรใน
ลักษณะนี้เทียบกับการประกาศตัวแปรปกติที่เราคุ้นเคยจะเห็นว่าการประกาศดังกล่าวจะเทียบเท่ากับการ
ประกาศตัวแปรชื่อ ArrayName ที่มีชนิดของการเก็บข้อมูลเป็น DataType[] ซึ่งหมายถึงอาเรย์
ของข้อมูลประเภท DataType นั่นเอง
ตัวอย่างที่ 6.1 ส่วนของโปรแกรมต่อไปนี้เป็นการประกาศตัวแปรแบบอาเรย์สามตัวคือ score, grade
และ Name เพื่อเก็บข้อมูลประเภทจำนวนเต็ม อักขระ และสตริง ตามลำดับ ให้พิจารณาการประกาศตัวแปร
แบบอาเรย์เหล่านี้เทียบกับการประกาศตัวแปรตามปกติในตอนท้ายโดยดูความหมายจากคอมเมนต์ที่ท้ายแต่ละบรรทัด
|
int[] score; //
score refers to an array of integers
char[] grade; //
grade refers to an array of characters
string[]
name; // Name refers to an array of strings
|
|
int s; // s
refers to an integer
char c; // c
refers to a character
string
n; // n refers to a string
|
2. การสร้างอาเรย์
ตัวแปรแบบอาเรย์ที่ถูกประกาศขึ้นมาตามรูปแบบข้างต้นนั้นสามารถนำไปใช้เพียงแค่อ้างถึงอาเรย์
ชนิดนั้นๆเท่านั้น อย่างไรก็ตาม ณ ขณะนี้เรายังไม่มีอาเรย์ที่แท้จริงที่จะอ้างถึง ดังนั้นขั้นตอนต่อไปจะเป็น
การสั่งให้คอมพิวเตอร์สร้างอาเรย์ขึ้นมาไว้ในหน่วยความจำของเครื่อง โดยคำสั่งที่เราจะใช้ในกระบวนการ
นี้คือคำสั่ง new ซึ่งมีรูปแบบการใช้งานดังนี้
|
new DataType[num_elements]
|
ในที่นี้ DataType คือชนิดข้อมูล และ num_elements คือนิพจน์แบบจำนวนเต็มแสดงขนาดของ
อาเรย์ที่เราต้องการสร้าง การใช้งานคำสั่ง new ในรูปแบบข้างต้นนั้นอยู่ในรูปของนิพจน์ที่ให้ค่าอ้างอิงไปยังอาเรย์ที่เพิ่งถูกสร้างขึ้นมา ดังนั้นโดยส่วนใหญ่แล้วเราจะนิยมนำค่าอ้างอิงนี้ไปให้กับตัวแปรแบบอาเรย์ที่เราได้ประกาศไว้ล่วงหน้าแล้ว เพื่อความสะดวกในการอ้างอิงถึงอาเรย์ตัวนี้ในภายหลัง ดังนั้นคำสั่ง new จึงมักพบในรูป
|
ArrayName
=
new DataType[num_elements];
|
โดยในที่นี้ ArrayName คือชื่อตัวแปรแบบอาเรย์ที่เราได้ประกาศเอาไว้ก่อนหน้านี้ และเช่นเดียวกับการ
ประกาศและการให้ค่าเริ่มต้นกับตัวแปร เราสามารถรวมเอาการประกาศและการสร้างอาเรย์เข้าไว้ในคำสั่ง
เดียวกันได้เลย ดังเช่นตัวอย่างด้านล่าง
ตัวอย่างที่ 6.2 การประกาศตัวแปรแบบอาเรย์และการสร้างอาเรย์
• สร้างอาเรย์สำหรับเก็บจำนวนเต็ม 5 ตัว โดยอ้างอิงผ่านตัวแปรแบบอาเรย์ชื่อ scores
|
int[] scores;
scores
= new int[5];
|
ตามที่ได้กล่าวไว้แล้วข้างต้น เราสามารถรวมเอาการประกาศตัวแปรแบบอาเรย์และการสร้างอาเรย์
ไว้ในคำสั่งเดียวกันดังนี้
|
int[] scores = new
int[5];
|
• สร้างอาเรย์สำหรับเก็บชื่อนักเรียน 10 คน อ้างอิงผ่านตัวแปรแบบอาเรย์ชื่อ names
|
string[] names;
names
= new string[10];
|
หรือ
|
string[] names = new
string[10];
|
นอกจากนี้อาเรย์ที่สร้างขึ้นมาใหม่ยังสามารถกำหนดค่าเริ่มต้นให้กับข้อมูลในอาเรย์ได้อีกด้วยโดย
อาศัยคำสั่งในรูปแบบต่อไปนี้
|
ArrayName = new
DataType[num_elements] {
value0,
value1,..., valueN-1};
|
สิ่งที่เพิ่มขึ้นมาคือวงเล็บปีกกาหลังจากคำสั่ง new ที่ภายในมีค่าต่างๆ จำนวน num_elements
ค่า โดยค่า value0 จะถูกกำหนดเป็นค่าเริ่มต้นให้กับข้อมูลแรกสุดในอาเรย์ แล้วตามด้วย value1
สำหรับข้อมูลช่องถัดมาและไล่ต่อไปเรื่อยๆ จนถึงข้อมูลสุดท้าย
หากมีการกำหนดค่าเริ่มต้นให้กับข้อมูลในอาเรย์แล้ว ภาษา C# ยอมให้เราละการระบุขนาดของ
อาเรย์ที่เราสร้างขึ้นมาได้ เนื่องจากขนาดของอาเรย์ถูกกำหนดไว้โดยจำนวนค่าเริ่มต้นที่ใส่ไว้ภายในวงเล็บปีกกาอยู่แล้ว ดังนั้นเราจึงสามารถใช้รูปแบบคำสั่งดังนี้ได้
|
ArrayName
= new DataType[] {value0, value1, ..., valueN-1};
|
สังเกตว่าเราได้ละส่วนที่เป็น num_elements ไว้ ยิ่งไปกว่านั้นคำสั่งข้างต้นยังสามารถเขียนให้สั้นลงได้
อีกโดยละคำสั่ง new ไว้ จึงเหลือแค่เพียง
|
DataType[]
ArrayName = {value0, value1, ..., valueN-1};
|
อย่างไรก็ตามการสร้างอาเรย์ในรูปแบบสุดท้ายนี้มีข้อจำกัดว่าจะต้องรวมอยู่ภายในคำสั่งเดียวกันกับการ
ประกาศตัวแปรแบบอาเรย์
ตัวอย่างที่ 6.3 สร้างอาเรย์ชื่อ scores เพื่อเก็บจำนวนเต็ม 5 จำนวนโดยมีค่าเริ่มต้นเท่ากับ 10, 50, 10, 55
และ 60 ตามลำดับ
|
int[] scores = new int[5] {10, 50, 10,
55, 60};
|
หรือ
|
int[] scores = new int[] {10, 50, 10,
55, 60};
|
หรือ
|
int[] scores = {10, 50, 10,
55, 60};
|
3. การอ้างถึงข้อมูลในอาร์เรย์
เราสามารถเข้าถึงข้อมูลแต่ละจำนวนภายในอาเรย์ผ่านทางดัชนี (index) ที่สอดคล้องกับตำแหน่ง
ของข้อมูลนั้น ๆ โดยค่าดัชนีสำหรับข้อมูลตัวแรกสุดในอาเรย์ถูกำหนดให้เป็นดัชนีหมายเลข 0 ถัดมาเป็น
หมายเลข 1 เรื่อยไป ดังนั้นสำหรับอาเรย์ที่มีความยาว N แล้ว ค่าของดัชนีที่ใช้งานได้จึงเริ่มตั้งแต่ 0 ถึง N-1 ในภาษา C# ข้อมูล ณ ตำแหน่ง idx ภายในอาเรย์ชื่อ ArrayName จะถูกอ้างถึงในรูปแบบ
|
ArrayName[idx]
|
การอ้างอิงถึงข้อมูลภายในอาเรย์ในรูปแบบนี้จะมีการใช้งานเสมือนเป็นตัวแปรโดดตัวหนึ่ง นั่นคือหากเราใช้การอ้างอิงนี้เป็นส่วนหนึ่งของนิพจน์ใดๆ ค่าภายในอาเรย์จะถูกดึงออกมาใช้เพื่อประเมินค่าของนิพจน์นั้นๆในทางตรงกันข้าม หากเราวางการอ้างอิงนี้ไว้ทางด้านซ้ายของเครื่องหมาย = ในคำสั่งให้ค่ากับตัวแปร ค่าของอาเรย์ตำแหน่งนี้ก็จะถูกเปลี่ยนค่าไปตามนั้น
ตัวอย่างที่ 6.4 พิจารณาอาเรย์ scores ซึ่งประกอบด้วยจำนวนเต็ม 5 จำนวน
• กำหนดค่า 52 ให้กับข้อมูลตัวแรกของอาเรย์
|
scores[0]
= 52;
|
• นำข้อมูลในตำแหน่งท้ายสุดของอาเรย์มาแสดงผลบนหน้าจอ
|
Console.WriteLine(scores[4]);
|
• กำหนดให้ค่าทุกค่าในอาเรย์มีค่าเท่ากับ 3
|
for (int i = 0; i < 5;
i++)
scores[i]
= 3;
|
• คำนวณผลรวมของค่าทั้งหมดภายในอาเรย์
|
int sum = 0;
for (int i =
0; i < 5; i++)
sum
= sum + scores[i];
|
• นำค่าทั้งหมดในอาเรย์มาแสดงผลบนหน้าจอ
|
for (int i = 0; i < 5;
i++)
Console.WriteLine("Student
{0}: {1}", i+1, scores[i]);
|
ไม่มีความคิดเห็น:
แสดงความคิดเห็น