ชนิดข้อมูลแบบอาเรย์
ที่มีปริมาณข้อมูลมาก ๆ ที่อาศัยการประมวลผลในรูปแบบเดียวกัน ดังนั้นการเขียนโปรแกรมเพื่อจัดการงาน
เหล่านี้จะต้องมีการเก็บข้อมูลเป็นจำนวนมากลงในตัวแปร ในกรณีนี้ หากเราประกาศตัวแปรหนึ่งตัวสำหรับ
ข้อมูลหนึ่งจำนวนโปรแกรมของเราจะประกอบด้วยตัวแปรเป็นจำนวนมาก นอกจากนั้นการเข้าถึงค่าภายใน
ตัวแปรจะต้องกระทำผ่านตัวแปรแต่ละตัวโดยตรงและไม่สามารถรวบรวมการประมวลผลในรูปแบบ
เดียวกันไว้ในโครงสร้างแบบวนซ้ำได้ ภาษาโปรแกรมส่วนใหญ่รวมทั้ง 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]);
|
การหาขนาดของอาร์เรย์
แล้วหากเราต้องการเพิ่มเติมความสามารถของโปรแกรมให้ประมวลผลข้อมูลมากขึ้น หรือด้วยสาเหตุอื่นใด
ก็ตาม หากเราลองพิจารณาโปรแกรมในใบงานที่ 6.1 จะเห็นว่าการดัดแปลงโปรแกรมให้ทำงานกับอาเรย์ที่มีขนาดต่างไปจากเดิมนั้น เราไม่สามารถทำเพียงแค่เปลี่ยนคำสั่งในการสร้างอาเรย์เท่านั้น เรายังต้องเปลี่ยนเงื่อนไขในโครงสร้าง for เพื่อให้การวนซ้ำมีจำนวนรอบที่สอดคล้องกับจำนวนข้อมูลในอาเรย์อีกด้วย แม้จะเป็นการง่ายที่จะดัดแปลงโปรแกรมในลักษณะดังกล่าว ความผิดพลาดสามารถเกิดขึ้นได้ง่ายในโปรแกรมที่ยาวและซับซ้อนมากยิ่งขึ้นโดยเฉพาะอย่างยิ่งโปรแกรมที่มีการใช้งานอาเรย์มากกว่าหนึ่ง และการใช้งานอาเรย์ร่วมกับเมท็อดที่เขียนขึ้นมาเพื่อประมวลผลอาเรย์ที่มีขนาดใดๆ ปัญหาเหล่านี้สามารถแก้ได้โดยใช้คำสั่งอ่านค่าคุณสมบัติ (property) ของอาเรย์ที่มีให้อยู่แล้วในภาษา C# โดยคุณสมบัติดังกล่าวมีชื่อว่า Length ซึ่งมีรูปแบบการใช้งานในรูปของนิพจน์ดังนี้
ArrayName.Length
|
ในที่นี้ ArrayName คืออาเรย์ที่ต้องการหาขนาด ส่วน Length เป็นชื่อคุณสมบัติที่ให้ขนาดของอาเรย์
การใช้งานข้างต้นจะอยู่ในรูปของนิพจน์แบบจำนวนเต็ม ซึ่งมีค่าเท่ากับขนาดของอาเรย์ ArrayName
ตัวอย่างที่ 6.5 โปรแกรมด้านล่างคำนวณน้ำหนักเฉลี่ยของประชากรตัวอย่างจำนวน 5 คน โดยค่าน้ำหนักถูกเก็บไว้ในอาเรย์weights
using System;
class AverageWeight {
static void Main() {
double[] weights = {65.5, 44.8, 70.0, 54.2, 77.6};
double sum = 0.0;
for (int i = 0; i < weights.Length; i++)
sum += weights[i];
Console.WriteLine("Average weight is {0:f2}",
sum/weights.Length);
}
}
|
ไม่มีความคิดเห็น:
แสดงความคิดเห็น