ใบความรู้ 11 การเขียนโปรแกรมด้วยภาษา C#

อาร์เรย์สองมิติ

           การใช้งานอาเรย์ที่ผ่านมานั้นจำกัดอยู่เพียงโครงสร้างแบบมิติเดียวเท่านั้นซึ่งอาเรย์ในรูปแบบนี้จะมีการเก็บข้อมูลแบบแถวเรียงหนึ่งและมีการเข้าถึงข้อมูลผ่านดัชนีซึ่งประกอบด้วยตัวเลขเพียงตัวเดียว อาเรย์ แบบนี้ใช้งานได้ดีอยู่แล้วในสถานการณ์ทั่ว ๆ ไป แต่ก็ยังมีงานอีกหลายประเภทที่ต้องการการจัดการข้อมูลที่ซับซ้อนมากกว่านั้นซึ่งต้องอาศัยโครงสร้างข้อมูลที่ซับซ้อนมากยิ่งขึ้นไปด้วย เพื่อการนี้ภาษา C# จึงอนุญาตให้เราสร้างและใช้งานอาเรย์ที่มีโครงสร้างแบบหลายมิติ (multi-dimensional array) ได้โดยจำนวนมิติมีได้ตั้งแต่สองมิติ สามมิติ หรือมากกว่า อย่างไรก็ตามอาเรย์แบบสองมิตินั้นจัดว่าเพียงพอแล้วสำหรับงานส่วนใหญ่ ในกรณีนี้ อาเรย์จะถูกมองอยู่ในรูปของตารางที่แต่ละช่องสามารถเก็บข้อมูลโดด ๆ ได้แทนที่จะอยู่ในรูปแถวเรียงหนึ่งเหมือนที่ผ่านมาลองเปรียบเทียบอาเรย์สองชนิดดังแสดงในภาพ

           รูปทางซ้ายมือเป็นตัวอย่างของอาเรย์หนึ่งมิติดังนั้นข้อมูลภายในอาเรย์จึงถูกอ้างอิงโดยใช้ดัชนีที่
ประกอบด้วยตัวเลขเพียงตัวเดียวเพื่อบ่งบอกตำแหน่งของข้อมูล ตัวอย่างเช่นช่องข้อมูลที่มีดัชนีเท่ากับ 2 มี การเก็บค่า 57 เอาไว้ ส่วนรูปทางขวามือแสดงตัวอย่างของอาเรย์แบบสองมิติซึ่งต้องใช้จำนวนเต็มสองค่าในการระบุดัชนี เช่นช่องเก็บข้อมูลที่ตำแหน่ง (1,3) มีการเก็บค่า 10 ส่วนช่องข้อมูลที่ดัชนี (2,4) มีการเก็บค่า 21

1. การประกาศและสร้างอาเรย์สองมิติ

ตัวแปรแบบอาเรย์สองมิติมีการประกาศตามรูปแบบด้านล่าง

DataType [,] ArrayName;

โดยที่ ArrayName คือชื่อของตัวแปรแบบอาเรย์ และ DataType คือชนิดข้อมูลในแต่ละช่องของ
อาเรย์

         เช่นเดียวกับการใช้งานอาเรย์แบบหนึ่งมิติ ตัวแปรแบบอาเรย์สองมิตินั้นยังไม่พร้อมที่จะถูกใช้งาน
จนกว่าจะมีการสร้างอาเรย์จริง ๆ ขึ้นมาให้ตัวแปรนั้นอ้างอิงถึง การสร้างอาเรย์ทำได้โดยการใช้ตัว
ดำเนินการ new ดังนี้

new DataType[nrows,ncols]

          การใช้งานตัวดำเนินการ new ข้างต้นจะสร้างอาเรย์สองมิติสำหรับข้อมูลชนิด DataType ที่มี
จำนวน nrows แถวและ ncols คอลัมน์ เนื่องจากการใช้ตัวดำเนินการ new ในรูปแบบข้างต้นนั้นจะอยู่
ในรูปของนิพจน์ ส่วนใหญ่จึงต้องมีการนำตัวแปรแบบอาเรย์ที่ประกาศไว้ก่อนแล้วมารับค่าเพื่อใช้อ้างอิงค่า
ในอาเรย์ต่อไปภายหลัง ดังแสดงในตัวอย่างต่อไปนี้

ตัวอย่างที่ 7.1 ประกาศตัวแปรแบบอาเรย์ชื่อ students เพื่อใช้อ้างอิงถึงอาเรย์สองมิติที่เก็บรายชื่อของ
นักเรียนตามที่นั่ง (แถว,คอลัมน์) ภายในชั้นเรียน โดยให้อาเรย์มีขนาด 5 แถวและ 3 คอลัมน์

string[,] students; students = new string[5,3];

หรือ

string[,] students = new string[5,3];

2. การสร้างอาเรย์สองมิติโดยกำหนดค่าเริ่มต้น

            เราสามารถกำหนดค่าเริ่มต้นให้กับข้อมูลแต่ละช่องพร้อมกับการสร้างอาเรย์ได้ทันทีโดยระบุค่าไว้
ภายในเครื่องหมายปีกกาเช่นเดียวกับอาเรย์หนึ่งมิติ อย่างไรก็ตาม เนื่องจากมิติที่เพิ่มขึ้น การกำหนดค่า
เริ่มต้นจึงมีโครงสร้างที่ซับซ้อนขึ้นโดยประกอบด้วยเครื่องหมายปีกกาหลายชั้นดังแสดง

ArrayName = new DataType[nrows,ncols] {   { value(0,0), value(0,1), ..., value(0,ncols-1) },   { value(1,0), value(1,1), ..., value(1,ncols-1) },         :           :                :   { value(nrows-1,0), value(nrows-1,1), ..., value(nrows-1,ncols-1) } };

           เนื่องจากขนาดของอาเรย์สามารถละได้หากมีการกำหนดค่าเริ่มต้น ดังนั้นรูปแบบด้านล่างจึงให้ผล
ลัพธ์เช่นเดียวกัน

ArrayName = new DataType[,] {   { value(0,0), value(0,1), ..., value(0,ncols-1) },   { value(1,0), value(1,1), ..., value(1,ncols-1) },         :           :                :   { value(nrows-1,0), value(nrows-1,1), ..., value(nrows-1,ncols-1) } };

          และเช่นเดียวกับอาเรย์หนึ่งมิติ ตัวดำเนินการ new สามารถละได้โดยมีข้อจำกัดว่าเราต้องสร้าง
อาเรย์และประกาศตัวแปรแบบอาเรย์ภายในคำสั่งเดียวกัน

DataType[,] ArrayName = {   { value(0,0), value (0,1), ..., value(0,ncols-1) },   { value(1,0), value (1,1), ..., value(1,ncols-1) },         :           :                 :   { value(nrows-1,0), value(nrows-1,1), ..., value(nrows-1,ncols-1) } };

ตัวอย่างที่ 7.2 สร้างอาเรย์สองมิติและอ้างอิงผ่านตัวแปรชื่อ A เพื่อเก็บค่าของแมตริกซ์ขนาด 4×3 ที่มีสมาชิกดังนี้

int[,] A = {   { 5, 3, 8},   { 2, 6, 10},   { 1, 8, 25},   {12, 3, 30} }

3. การอ้างถึงข้อมูลในอาเรย์

          เนื่องจากอาเรย์มีโครงสร้างแบบสองมิติ การอ้างถึงข้อมูลในอาเรย์ต้องมีการระบุทั้งดัชนีของแถวและดัชนีของคอลัมน์เพื่อบ่งบอกตำแหน่งที่แน่นอนของช่องเก็บข้อมูลภายในอาเรย์ เช่นเดียวกับอาเรย์มิติเดียวดัชนีของแถวและคอลัมน์นี้จะเริ่มต้นที่ค่า 0 และสิ้นสุดที่จำนวนแถวลบหนึ่งและจำนวนคอลัมน์ลบหนึ่งตามลำดับ เช่นการอ้างถึงข้อมูลที่มีดัชนีแถวเป็น ri และดัชนีคอลัมน์เป็น ci ในอาเรย์ชื่อ ArrayName

จะเป็นดังนี้

ArrayName[ri,ci]

และอีกเช่นเคย การอ้างอิงถึงข้อมูลภายในอาเรย์ในรูปแบบนี้จะมีการใช้งานเสมือนเป็นตัวแปรโดดตัวหนึ่ง

ตัวอย่างที่ 7.3 พิจารณาแมตริกซ์ A จากตัวอย่างที่ 7.2

   •  แสดงค่าสมาชิกของแมตริกซ์ A[3,2] (หรือ a3,2 นั่นเอง)

Console.WriteLine(A[2,1]);

Console.WriteLine(A[2,1]);

หมายเหตุ: สังเกตว่าในโปรแกรมมีการเรียกใช้ A[2,1] แทนที่จะเป็น A[3,2] เนื่องจากว่าการ

ระบุตำแหน่งในอาเรย์สำหรับภาษา C# นั้นเริ่มต้นที่ดัชนี 0 ในขณะที่การระบุตำแหน่งในแมตริกซ์

ทางคณิตศาสตร์เริ่มต้นที่ 1

   •  กำหนดค่า 33 ให้กับสมาชิก a4,3

A[3,2] = 33;

การหาขนาดของอาเรย์

            เราได้เรียนรู้จากปฏิบัติการครั้งก่อนไปแล้วว่าเราสามารถหาขนาดของอาเรย์หนึ่งมิติใด ๆ ได้โดยใช้คุณสมบัติ Length ซึ่งเป็นคุณสมบัติที่นำมาใช้ได้กับอาเรย์หลายมิติได้เช่นกัน อย่างไรก็ตาม การเขียน
โปรแกรมสำหรับงานบางอย่างจำเป็นต้องการทราบสัดส่วนของอาเรย์ในแต่ละมิติ (ดังเช่นการประมวลผลแมตริกซ์) ดังนั้นภาษา C# จึงเตรียมเมท็อดชื่อ GetLength เพื่อตรวจสอบขนาดอาเรย์ที่มิติต่าง ๆ ซึ่งมีการใช้งานในรูปของนิพจน์แบบจำนวนเต็มดังนี้

ArrayName.GetLength(dim_idx)

โดยที่ dim_idx แสดงหมายเลขมิติที่เราต้องการทราบขนาด สำหรับอาเรย์แบบสองมิตินั้นมิติหมายเลข 0

หมายถึงแถว และมิติหมายเลข 1 หมายถึงคอลัมน์ ดังนั้นนิพจน์สำหรับตรวจสอบจำนวนแถวของอาเรย์สอง มิติจึงเขียนได้เป็น

ArrayName.GetLength(0)

และนิพจน์สำหรับตรวจสอบจำนวนคอลัมน์ของอาเรย์จึงเป็น

ArrayName.GetLength(1)

ตัวอย่างที่ 7.4 พิจารณาแมตริกซ์ A จากตัวอย่างที่ 7.2

    •  ทำให้ทุกค่าในคอลัมน์แรกของแมตริกซ์ A มีค่าเท่ากับ 1

for (int i = 0; i < A.GetLength(0); i++)       A[i,0] = 1;

    •  ทำให้ทุกค่าในแถวที่สองของแมตริกซ์ A มีค่าเท่ากับ 5

for (int i = 0; i < A.GetLength(1); i++)       A[1,i] = 5;

    •  ทำให้แมตริกซ์ A กลายเป็นแมตริกซ์ศูนย์

for (int i = 0; i < A.GetLength(0); i++)    for (int j = 0; i < A.GetLength(1); j++)       A[i,j] = 0;

แบบฝึกหัดเพิ่มเติมเรื่องอาเรย์สองมิติ

1. เขียนโปรแกรมบวกแมตริกซ์ 2 แมตริกซ์ ดังนี้

ต้องการผลลัพธ์ ดังนี้

6     8     7 6     9     9 7     5     4

2. เขียนโปรแกรมโดยใช้อาเรย์สองมิติเก็บข้อมูล เพื่อแสดงภาพดังนี้

3. เขียนโปรแกรมโดยใช้ข้อมูลจากตัวแปรอาเรย์ในข้อ 1 และให้แสดงภาพดังนี้

ใบความรู้ 10 การเขียนโปรแกรมด้วยภาษา C#

คำสั่ง foreach

         ภาษา C# ได้เตรียมโครงสร้าง foreach สำหรับการเขียนโปรแกรมแบบวนซ้ำเพื่อความสะดวก
ในการเข้าถึงข้อมูลในอาเรย์ การใช้งานมีรูปแบบดังนี้

foreach (DataType var in ArrayName) statement;

โดย DataType คือชนิดข้อมูลภายในอาเรย์ var คือชื่อตัวแปรสำหรับเก็บค่าทีละค่าจากอาเรย์ในการวนซ้ำแต่ละรอบ และ ArrayName คืออาเรย์ที่จะนำค่าภายในมาใช้งาน ดังนั้นคำสั่ง statement จึงถูกกระทำ
เป็นจำนวนครั้งเท่ากับจำนวนข้อมูลในอาเรย์

          เช่นเดียวกับโครงสร้างอื่นๆ ที่ได้ศึกษาไปก่อนหน้านี้แล้ว คำสั่งที่ถูกวนซ้ำจะมีได้เพียงคำสั่งเดียว
การใช้งานมากกว่าหนึ่งคำสั่งต้องรวมคำสั่งทั้งหมดไว้ภายในวงเล็บปีกกา

foreach (DataType var in ArrayName) {    statement1;    statement2;    :    statementN; }

ตัวอย่างที่ 6.6 โปรแกรมด้านล่างถูกดัดแปลงจากโปรแกรมในตัวอย่างที่ 6.5 โดยมีการใช้งานโครงสร้าง
foreach แทนที่จะเป็นโครงสร้าง for ตามปกติ ให้สังเกตความแตกต่างที่บรรทัดที่ 6 และ 7

1: using System; 2: class AverageWeight { 3:  static void Main() { 4:    double[] weights = {65.5, 44.8, 70.0, 54.2, 77.6}; 5:    double sum = 0.0; 6:    foreach (double x in weights) 7:      sum += x; 8:    Console.WriteLine("Average weight is {0:f2}", 9:      sum/weights.Length); 10:  } 11: }

การส่งอาเรย์ไปยังเมท็อด

          เราได้ทราบจากกิจกรรมที่ผ่านมาแล้วว่าเมท็อดสามารถรับค่าจากผู้เรียกผ่านทางพารามิเตอร์ของ
เมท็อดนั้น ๆ นอกจากการส่งค่าในรูปข้อมูลพื้นฐาน (เช่น int, double, string) แล้ว ภาษา C#
อนุญาตให้เมท็อดรับพารามิเตอร์ในรูปของอาเรย์ได้อีกด้วย ซึ่งทำได้ง่ายๆ เพียงแค่ระบุให้พารามิเตอร์ที่
รับเข้ามามีชนิดข้อมูลเป็นแบบอาเรย์เท่านั้นลองพิจารณาตัวอย่าง

ตัวอย่างที่ 6.7 โปรแกรมด้านล่างประกาศเมท็อดชื่อ ArraySum ซึ่งรับพารามิเตอร์หนึ่งตัวเป็นอาเรย์ของ
double จากนั้นจึงคำนวณผลรวมของค่าทั้งหมดในอาเรย์และส่งค่าผลรวมกลับไปยังผู้เรียก สังเกตการ
ระบุชนิดของพารามิเตอร์เป็น double[] ในบรรทัดที่ 3 และการใช้งานโครงสร้าง foreach ซึ่งทำให้
เมท็อดนี้ประมวลผลอาเรย์ได้ทุกขนาด

1: using System; 2: class ArrayTest { 3: static double ArraySum(double[] data) { 4: double sum = 0.0; 5: foreach (double x in data) 6: sum += x; 7: return sum; 8: } 9: 10: static void Main() { 11: double[] myData = {1.0, 2.4, 3.6, 4.8}; 12: Console.WriteLine("Sum = {0}", ArraySum(myData)); 13: } 14: }

การการอ้างถึงสตริงในรูปแบบอาเรย์

           ภาษา C# อนุญาตให้เราประมวลผลข้อมูลชนิดข้อความหรือสตริง (string) เสมือนว่าข้อมูลนั้นเป็น
อาเรย์ของอักขระโดยใช้ตัวดำเนินการต่างๆ ที่ใช้กับอาเรย์ได้ทันที เช่นตัวดำเนินการ [] โครงสร้าง
foreach และคุณสมบัติ Length โดยมีข้อจำกัดตรงที่เราทำได้เพียงอ่านค่าอักขระ ณ ตำแหน่งต่างๆ
ของข้อความได้เท่านั้น แต่ไม่สามารถเปลี่ยนแปลงส่วนหนึ่งส่วนใดของข้อความนั้นๆ ได้

ตัวอย่างที่ 6.8 ตัวอย่างต่อไปนี้รับข้อความจากผู้ใช้และรายงานจำนวนตัวอักขระ 'E' ภายในข้อความนั้นๆ

using System; class CountE {    static void Main() {       Console.Write("Enter a string: ");       string s = Console.ReadLine();       int count = 0;       for (int i = 0; i < s.Length; i++) {          if (s[i] == 'E') count++;       }       Console.WriteLine("There are {0} E's in the string", count);    } }

ตัวอย่างผลการทำงาน

Enter a string: HELLO EVERYONE There are 4 E's in the string

ตัวอย่างที่ 6.9 โปรแกรมต่อไปนี้ให้ผลการทำงานเหมือนโปรแกรมในตัวอย่างที่แล้วทุกประการ แต่มีการใช้

งานโครงสร้าง foreach แทนการใช้โครงสร้าง for

using System; class CountE {    static void Main() {       Console.Write("Enter a string: ");       string s = Console.ReadLine();       int count = 0;       foreach (char c in s) {          if (c == 'E') count++;       }        Console.WriteLine("There are {0} E's in the string", count);    } }

ใบความรู้ 9 การเขียนโปรแกรมด้วยภาษา C#

ชนิดข้อมูลแบบอาเรย์

           คอมพิวเตอร์เป็นอุปกรณ์ที่เพิ่มความรวดเร็วในการประมวลผลข้อมูลโดยเฉพาะอย่างยิ่งสำหรับงาน
ที่มีปริมาณข้อมูลมาก ๆ ที่อาศัยการประมวลผลในรูปแบบเดียวกัน ดังนั้นการเขียนโปรแกรมเพื่อจัดการงาน
เหล่านี้จะต้องมีการเก็บข้อมูลเป็นจำนวนมากลงในตัวแปร ในกรณีนี้ หากเราประกาศตัวแปรหนึ่งตัวสำหรับ
ข้อมูลหนึ่งจำนวนโปรแกรมของเราจะประกอบด้วยตัวแปรเป็นจำนวนมาก นอกจากนั้นการเข้าถึงค่าภายใน
ตัวแปรจะต้องกระทำผ่านตัวแปรแต่ละตัวโดยตรงและไม่สามารถรวบรวมการประมวลผลในรูปแบบ
เดียวกันไว้ในโครงสร้างแบบวนซ้ำได้ ภาษาโปรแกรมส่วนใหญ่รวมทั้ง 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);   } }