บทความมนี้กล่าวถึงพื้นฐานการเขียนโปรแกรมภาษา C# ที่นำไปใช้ในการเรียนการสอนในรายวิชา การพัฒนาเกม และคณิตร์ศาสตร์คอมพิวเตอร์ โดยเริ่มจากเรื่องของจำนวน การดำเนินการกับจำนวน เงื่อนไข การทำซ้ำ โปรแกรมย่อย อันนำไปสู่การประยุกต์ใช้คณิตศาสตร์เข้ากับเกมหรือนำไปใช้กับการเขียนโปรแกรมด้วย Unity ต่อไป ด้วยเครื่องมือการเขียนโปรแกรมอย่าง Visual Studio, Unity หรือ Godot mono เป็นต้น
ตัวเลขในภาษา C#
จำนวนที่ใช้กับ C# ประกอบด้วยจำนวนเต็มและทศนิยม โดยจำนวนมีขนาดแตกต่างกันตามตารางที่ 1 เพื่อให้ผู้เขียนโปรแกรมเลือกใช้ตามช่วงค่าที่ต้องการใช้ ทำให้ประหยัดปริมาณหน่วยความจำของคอมพิวเตอร์ หรืออุปกรณ์ที่รันโปรแกรม
ถ้าเป็นจำนวนเต็มให้ใช้ค่าตัวเลขระบุ เช่น 1, 5, -10, 0 หรือ -200 แต่ถ้าเป็นทศนิยมจะต้องใส่ค่าหลังเลขจำนวนเต็มประกอบ เช่น 1.0, 5.0, -10.0, 0.0 หรือ 200.0 โดยต้องกำหนดอักษร f ต่อท้ายตัวเลขเพื่อระบุประเภทของตัวเลขเป็นทศนิยมแบบ float แต่ถ้าไม่ระบุจำหมายถึง double เป็นต้น
ตัวเลขที่ถูกใช้ในภาษา C# มี 2 ประเภท คือ ตัวเลขที่เป็นค่าคงที่ และตัวเลขที่เก็บอยู่ในตัวแปร โดยในรูปแบบแรกนั้นเป็นการอ้างอิงชื่อเพื่อใช้แทนค่าตัวเลขทำให้สะดวกในการอ้างอิงหรือเปลี่ยนแปลงค่าแล้วส่งผลให้ทุกชื่อที่อ้างอิงนั้นเปลี่ยนเป็นค่าเดียวกันหมด ส่วนตัวแปรนั้นเป็นการจองหน่วยความจำของคอมพิวเตอร์เพื่อจัดเก็บตัวเลขลงในหน่วยความจำที่จองนั้น ดังนั้น ถ้าหน่วยความจำไม่เพียงพอจะส่งผลให้โปรแกรมไม่สามารถทำงานได้ และการจองหน่วยความจำที่ไม่เพียงพอต่อการเก็บส่งผลให้ค่านั้นเปลี่ยนแปลงไปเป็นค่าที่ไม่พึงประสงค์ได้ เช่น จองไว้ 1 ไบต์ ซึ่งเก็บค่าได้ -128 ถึง 127 (ดังตารางที่ 1-1) เมื่อใดที่มีค่าเป็น 127 แล้วเพิ่มค่าอีก 1 จะไม่ทำให้ค่าเป็น 128 แต่กลับกลายเป็น -128 เป้นต้น นอกจากนี้ในบางครั้งที่จองขนาดหน่วยความจำที่เกินกว่าจำเป็น เช่น ไม่ว่าอย่างไรค่าที่เก็บเป็นตัวเลขในช่วง 1 ถึง 8 แต่ผู้เขียนโปรแกรมจองหน่วยความจำเป็น UInt32 ซึ่งต้องการหน่วยความจำจำนวน 4 ไบต์ในการเก็บทั้งที่ใช้เพียง 1 ไบต์ก็เพียงพอ เป็นต้น
ตัวแปรและค่าคงที่
สำหรับจำนวนที่ผู้เขียนโค้ดต้องการให้มีการเปลี่ยนแปลงค่าได้ในภายหลังเรียกว่าตัวแปร (variable) และจำนวนที่ไม่ต้องการให้มีการเปลี่ยนแปลงค่าเรียกว่า ค่าคงที่ (constant) นั้นมีรูปแบบของการกำหนดดังนี้ ส่วนประเภทข้อมูล
ประเภทข้อมูล ชื่อตัวแปร;
const ประเภทข้อมูล ชื่อค่าคงที่ = ตัวเลข;
กรณีที่ต้องการประกาศตัวแปรโดยไม่ต้องการระบุประเภทของข้อมูลสามารถสร้างตามรูปแบบของคำสั่งต่อไปนี้
var ชื่อตัวแปร = ตัวเลข;
โดยประเภทของตัวแปรที่สร้างนี้จะเป็นจำนวนเต็มหรือทศนิยมด้วยการจำแนกจากตัวเลขที่กำหนดให้ตัวแปร
โครงสร้างการเขียนโค้ด
โครงสร้างโปรแกรมพื้นฐานของ C# เป็นดังด้านล่างนี้ โดยจะพบว่า เมื่อใดที่วัตถุถูกเรียกขึ้นใช้งาน และพร้อมทำงานจะมีการเรียกใช้ฟังก์ชัน Main() ให้ทำงานเป็นฟังก์ชันแรกเสมอ ส่วนคำสั่ง WriteLine() ใช้สำหรับแสดงข้อความจากข้อมูลที่ส่งให้ และเมื่อแสดงข้อมูลครบทุกตัวจะดำเนินการขึ้นบรรทัดใหม่ และด้านหน้า WriteLine() จะมีชื่อคลาส Console ซึ่งเป็นคลาสที่อยู่ภายใต้คลาส System ที่ถูกเรียกใช้ในบรรทัดแรกด้วยคำสั่ง using แต่ถ้าผู้เขียนโปรแกรมไม่ได้เรียก using System จะต้องใช้คำสั่ง WriteLine() ในรูปแบบต่อไปนี้
System.Console.WriteLine( ข้อมูล )
ข้อสังเกตเพิ่มเติมคือชื่อของคลาสจะเป็นชื่อเดียวกับไฟล์ และไฟล์ต้นฉบับ (Source Code) ภาษา C# จะมีนามสกุลเป็น .cs
โปรแกรม 1-1 รูปแบบของโปรแกรมภาษา C#
using System;
namespace ชื่อแอปพลิเคชัน
{
classชื่อคลาส
{
static void Main( string[] args )
{
Console.WriteLine( "Hi, C#!" );
}
}
}
ตัวอย่างโปรแกรมสำหรับการสร้างค่าคงที่ my_pi ให้เก็บค่า 3.1415 และตัวแปร x และ y สำหรับเก็บค่า 100 และ -50.2 แล้วแสดงผลของค่าที่ส่วนแสดงผลของโปรแกรมด้วยคำสั่ง print() สามารถเขียนได้ดังโปรแกรม 1-2 โดยตัวอย่างของผลลัพธ์เป็นดังภาพที่ 1-2
โปรแกรม 1-2 แสดงค่าจากตัวแปรและค่าคงที่
using System;
namespace Hi
{
class Program
{
static void Main(string[] args)
{
var x = 100;
var y = -50.2;
const float my_pi = 3.1415f;
Console.WriteLine("x = " + x);
Console.WriteLine("y = " + y);
Console.WriteLine("my_pi = " + my_pi);
}
}
}
การกำหนดค่า
การกำหนดค่าในทางคอมพิวเตอร์ใช้รูปแบบของการทำงานดังนี้
L = R;
โดย
L คือ ตัวแปร
R คือ นิพจน์ (expression) อันจะเป็นตัวเลข ค่าคงที่ ตัวแปร หรือโปรแกรมย่อยที่จะถูกกระทำหรือทำงานจนได้คำตอบเพื่อนำไปเก็บใน L
นิพจน์เป็นการดำเนินการระหว่างตัวดำเนินการตามรูปแบบชองเครื่องหมายดำเนินการ อันได้แก่
1. เครื่องหมายดำเนินการ ตัวดำเนินการ
2. ตัวดำเนินการ1 เครื่องหมายดำเนินการ ตัวดำเนินการ2
ในรูปแบบที่ 1 จะเป็นเครื่องหมายดำเนินการประเภทเปลี่ยนแปลงค่าของตัวดำเนินการ อันได้แก่
-a หมายถึง การนำ -1 คูณกับ a
!a หมายถึง กลับค่าตรรกะของ a ถ้าเดิม a เป็น true จะได้ผลลัพธ์เป็น
false และ ในทางกลับกันเมื่อเดิม a เป็น false จะได้ผลลัพธ์
เป็น true
not a หมายถึง กลับค่าตรรกะของ a ซึ่งให้ผลลัพธ์เหมือนกับการใช้คำสั่ง !a
ในรูปแบบที่ 2 เป็นการกระทำระหว่างตัวดำเนินการ1 กับตัวดำเนินการ2 ซึ่งเครื่องหมายในกลุ่มนี้ได้แก่ การดำเนินการทางคณิตศาสตร์ เป็นตามตารางที่ 1-1 และการดำเนินการทางตรรกะ เป็นตามตารางที่ 1-2 (ให้ผลลัพธ์เป็น false หรือ true)
จากตาราง 1-2 จะพบว่าการประยุกต์ใช้เครื่องหมายสำหรับการย่อการเขียนในกรณีที่ตัวดำเนินการเป็นตัวเดียวกัน เช่น การเพิ่มค่าตัวแปร a ขึ้น 1 ค่า สามารถเขียนได้เป็น
a = a + 1
แต่สามารถเขียนแบบย่อเพื่อให้คำสั่งสั้นลงเป็นดังนี้
a += 1
ดังนั้น เครื่องหมายสำหรับการเขียนแบบย่อจึงมีด้วยกัน 5 แบบ คือ
ตัวแปร += ค่า หมายถึง ตัวแปร = ตัวแปร + ค่า
ตัวแปร -= ค่า หมายถึง ตัวแปร = ตัวแปร – ค่า
ตัวแปร *= ค่า หมายถึง ตัวแปร = ตัวแปร * ค่า
ตัวแปร /= ค่า หมายถึง ตัวแปร = ตัวแปร / ค่า
ตัวแปร %= ค่า หมายถึง ตัวแปร = ตัวแปร % ค่า
จากตารางที่ 1-3 จะได้ผลลัพธ์ของการดำเนินการทางตรรกะแบบ และ เป็นตามตารางที่ 1-4 และการดำเนินการทางตรรกะแบบ หรือ เป็นผลลัพธ์ตามตารางที่ 1-5
การกระทำระหว่างจำนวนในเชิงของระบบคอมพิวเตอร์นั้นมีเงื่อนไขดังนี้
1. การกระทำระหว่างตัวเลขจำนวนเต็มกับจำนวนเต็มจะได้ค่าเป็นจำนวนเต็ม
2. การกระทำระหว่างตัวเลขทศนิยมกับเลขทศนิยมจะได้ค่าเป็นทศนิยม
3. การกระทำระหว่างตัวเลขจำนวนเต็มกับตัวเลขทศนิยมจะได้เป็นทศนิยม
4. การหารด้วย 0 จะได้ค่าเป็นอนันต์ (infinity) ซึ่งไม่ถูกนิยามในทางคณิตศาสตร์แต่ในระบบคอมพิวเตอร์จะก่อเกิดปัญหาเรื่อง divide by zero อันทำให้โปรแกรมที่เขียนนั้นเกิดความผิดพลาดและส่งผลให้สิ้นสุดการทำงานแบบเกิดความผิดพลาด
5. ตัวเลข 0 หารด้วยค่าใด ๆ ได้ผลลัพธ์เป็น 0 เสมอ
ตัวอย่างโปรแกรม 1-3 เป็นการคำนวณการแปลงค่าอุณหภูมิจาก 35 องศาเซลเซียสเป็นฟาเรนไฮต์ จากสมการแปลงค่าอุณหภูมิดังนี้
°F = °C x (9/5) + 32
โปรแกรม 1-3 ตัวอย่างการแปลง 35 องศาเซลเซียสเป็นฟาเรนไฮต์
using System;
namespace temp_conv
{
class Program
{
public static double C;
public static double F;
static void Main(string[] args)
{
C = 35.0;
F = C * 9.0 / 5.0 + 32;
Console.WriteLine(F);
}
}
}
จากโปรแกรม 1-3 ได้ประกาศตัวแปร C ให้มีค่าเป็น 35 และตัวแปร F ให้เป็นตัวแปรแบบทศนิยม หลังจากนั้นในฟังก์ชัน Main() ได้ทำการคำนวณนิพจน์ทางด้านขวาดังนี้
C * 9.0/5.0+32
จากนิพจน์จะได้ว่า โดยปกติแล้วหลักการทำงานของคอมพิวเตอร์จะทำภายใน ( ) ในสุดก่อน และถ้าพบเครื่องหมายดำเนินการจะแบ่งเป็น 3 กลุ่ม และทำตามลำดับก่อนหลังดังนี้
1. กลับค่า เช่น -A
2. การคูณ หาร
3. การบวก ลบ
ถ้าเครื่องหมายลำดับเดียวกันจะทำจากซ้ายไปขวา ด้วยเหตุนี้จากนิพจน์ข้างตนจึงได้ลำดับของการคำนวณดังนี้
1. C*9.0 ซึ่งได้ผลลัพธ์เป็น 35*9.0 หรือ 315.0
2. ผลลัพธ์จาก 1 ถูกหารด้วย 5 ซึ่งได้ผลลัพธ์จาก 315.0/5เป็น 63.0
3. ผลลัพธ์จาก 2 นำมาบวกด้วย 35 ทำให้ได้ผลลัพธ์ของ 63.0+32 เป็น 95.0
เมื่อทำครบทั้ง 3 ขั้นตอนจะนำผลลัพธ์ที่ได้จากขั้นตอนที่ 3 ไปเก็บไว้ในตัวแปรทางซ้ายมือ ทำให้ตัวแปร F เก็บค่า 95.0 เอาไว้ หลังจากนั้นนำค่าที่เก็บในตัวแปร F มาแสดงผลด้วยคำสั่ง WriteLine()
หมายเหตุ
ในตัวอย่างโปรแกรม 1-3 ได้ประกาศตัวแปร F และ C โดยระบุคำ public static ไว้หน้าประเภทและชื่อตัวแปร โดยมีความหมายดังนี้
public หมายถึง ยินยอมให้เข้าถึงได้จากภายนอกคลาส
static หมายถึง ให้สร้างตัวแปรนี้ในหน่วยความจำเมื่อมีการประกาศ
ดังนั้น เมื่อพบคำสั่ง
public static double C;
จึงมีความหมายว่า ให้ทำการสร้างตัวแปรชื่อ C ให้เป็นตัวแปรประเภททศนิยมที่ใช้พื้นที่ในการจัดเก็บ 8 ไบต์ หลังจากนั้นด้วยคำสั่ง static ทำให้ระบบทำการจองหน่วยความจำตามที่กำหนดเอาไว้ และกำหนดให้สามารถเข้าถึงได้จากนอกคลาส เป็นการสิ้นสุดการสั่งคำสั่ง
การสร้างเงื่อนไข
การสร้างเงื่อนไขใน C# มีรูปแบบการเขียนด้วยกัน 3 แบบ คือ
1.รูปแบบแรกเป็นการตรวจสอบเงื่อนไข และถ้าเงื่อนไขเป็นจริงจะทำตามโค้ดที่เขียน ดังรูปแบบต่อไปนี้ โดยหลักการทำงานเป็นตามผังงานภาพที่ 1.3.4-1
if (เงื่อนไข)
{
สิ่งที่ทำเมื่อเงื่อนไขเป็นจริง1
สิ่งที่ทำเมื่อเงื่อนไขเป็นจริง2
…
สิ่งที่ทำเมื่อเงื่อนไขเป็นจริงn
}
2. เป็นการตรวจสอบเงื่อนไข และถ้าเงื่อนไขเป็นจริงจะทำตามโค้ดที่เขียนไว้เพื่อรองรับ
การทำงานเมื่อไขเป้นจริง แต่ถ้าเงื่อนไขเป็นเท็จจะไปทำงานในส่วนที่อยู่ใน else โดยหลักการทำงานเป็นตามผังงานภาพที่ 1.3.4-2
if (เงื่อนไข)
{
สิ่งที่ทำเมื่อเงื่อนไขเป็นจริง
}
else
{
สิ่งที่ทำเมื่อเงื่อนไขเป็นเท็จ
}
3. เป็นแบบซ้อนเงื่อนไข คือ ทำการตรวจสอบเงื่อนไขภายใต้ if ถ้าเป็นจริงจะทำตามที่เขียนโค้ดเพื่อตอบสนองกรณีที่ if เป็นจริง แต่ถ้าเป็นเท็จจะดำเนินการตรวจสอบเงื่อนไขที่อยู่หลัง else if ถัดไป ถ้าเงื่อนไขเป็นจริงจะทำคำสั่งภายใต้ else if นั้น แต่ถ้าเป็นเท็จจะข้ามไปตรวจสอบ else if ถัดไปเรื่อย ๆ จนไม่พบ else if จะไปทำใน else โดยหลักการทำงานเป็นตามผังงานภาพที่ 1.3.4-3
if ( เงื่อนไข1 )
{
สิ่งที่ทำเมื่อเงื่อนไข1เป็นจริง
}
else if ( เงื่อนไข2 )
{
สิ่งที่ทำเมื่อเงื่อนไข2เป็นจริง
}
…
else if ( เงื่อนไขn )
{
สิ่งที่ทำเมื่อเงื่อนไขnเป็นจริง
}
else
{
สิ่งที่ทำเมื่อเงื่อนไขเป็นเท็จ
}
เครื่องหมายดำเนินการด้านการเปรียบเทียบเป็นดังตาราง 1-6 โดยผลลัพธ์ที่ได้จากการเปรียบเทียบเป็นจริงหรือเท็จ (True/False)
ตัวอย่างโปรแกรม 1-4 เป็นการกำหนดให้ตัวแปร x มีค่าเป็น 10 หลังจากนั้นตรวจสอบค่าที่เก็บในตัวแปร x ว่าเป็น 0 หรือไม่ ถ้าใช่จะแสดงคำว่า x == 0 แต่ถ้าไม่ใช่จะแสดง x !=0
โปรแกรม 1-4 ตัวอย่างการตรวจสอบค่าตัวแปร x มีค่าเป็น 0 หรือไม่
using System;
namespace if_else
{
class Program
{
static void Main(string[] args)
{
double x = 10.0;
if (x == 0.0)
{
Console.WriteLine(" x == 0 ");
}
else
{
Console.WriteLine(" x != 0 ");
}
}
}
}
ตัวอย่างโปรแกรม 1-5 เป็นการตรวจสอบระดับของผู้เล่นจากค่าที่เก็บในตัวแปร score โดยเงื่อนไขกำหนดไว้ดังนี้
1. ถ้าค่าน้อยกว่า 10 เป็น Level 0
2. ถ้ามีค่าเป็น 10 ถึง 19 เป็น Level 1
3. ถ้ามีค่าเป็น 20 ถึง 29 เป็น Level 2
4. ถ้ามีค่าเป็น 30 ถึง 39 เป็น Level 3
5. กรณีอื่น ๆ เป็น Level 4
สำหรับกรณีของการเปรียบเทียบความเท่ากันของตัวเลขทศนิยมจะมีปัญหาในบางกรณีตามรูปแบบขชองการใช้เลขทศนิยมแบบ IEEE 754 (The IEEE Standard for Floating-Point Arithmetic)
ดังเช่นโค้ดต่อไปนี้จะพบว่าค่าไม่เท่ากันทั้งที่ควรจะเท่ากัน
float a = 0.1f;
float b = 0.2f;
Console.WriteLine("a = ", a);
Console.WriteLine("b = ", b);
Console.WriteLine("a+b = ", (a+b));
if ((a+b) == 0.3)
{
Console.WriteLine("0.3");
}
else
{
Console.WriteLine("???");
}
วิธีการแก้ปัญหาคือ ใช้หลักของการหาความแตกต่างของค่า 2 ค่า ถ้าน้อยกว่าค่าที่กำหนด (epsilon) จะถือว่าเป็นค่าเดียวกัน แต่ถ้ามากกว่าหรือเท่ากันกับค่าดังกล่าวจะถือว่าเป็นตัวเลขทศนิยมทั้ง 2 ค่านั้นไม่เท่ากัน ดังตัวอย่างโปรแกรม 1-6
โปรแกรม 1-5 แสดงระดับของผู้เล่นจากตัวแปร score
using System;
namespace level_if
{
class Program
{
public static float score;
static void Main(string[] args)
{
score = 35.0f;
if (score <10) {
Console.WriteLine("Level 0");
} else if (score < 20) {
Console.WriteLine("Level 1");
} else if (score < 30) {
Console.WriteLine("Level 2");
} else if (score < 40) {
Console.WriteLine("Level 3");
} else {
Console.WriteLine("Level 4");
}
}
}
}
โปรแกรม 1-6 การเปรียบเทียบค่าทศนิยม
using System;
namespace err_float2
{
class Program
{
const float epsilon = 0.000001f;
static void Main(string[] args)
{
float a = 0.1f;
float b = 0.2f;
float c = a + b;
Console.WriteLine("a = ", a);
Console.WriteLine("b = ", b);
Console.WriteLine("a+b = ", (a + b));
if ((c - 0.3) < epsilon)
Console.WriteLine("0.3");
else
Console.WriteLine("???");
}
}
}
การทำซ้ำ
การวนรอบหรือทำซ้ำ (repetition) ใน C# เป็นการใช้ชุดคำสั่งเพื่อให้เกิดการทำซ้ำภายใต้เงื่อนไข เช่น ทำถ้าเป็นจริง และทำเรื่อย ๆ จนกว่าเงื่อนไขที่ตรวจสอบจะเป็นเท็จ หรือ ทำเมื่ออยู่ในช่วงที่กำหนด เป็นต้น
while (เงื่อนไข) {
สิ่งที่ทำ1
…
สิ่งที่ทำn
}
ในรูปแบบนี้เป็นการทำซ้ำเมื่อเงื่อนไขเป็นจริง และเมื่อทำในสิ่งที่กำหนดให้ทำจนเสร็จสิ้นจะกลับไปตรวจสอบเงื่อนไขอีกครั้ง ถ้าเงื่อนไขยังคงเป็นจริงจะทำต่อไปตราบจนได้ผลของเงื่อนไขเป็นเท็จจึงออกจากการทำซ้ำ เช่น การแสดงข้อมูล 0, 3, 6, 9 และ 12 สามารถเขียนได้ดังส่วนของโปรแกรมในโปรแกรม 1-7
โปรแกรม 1-7 การวนซ้ำแบบ while
using System;
namespace loop_while
{
class Program
{
static Int32 x;
static void Main(string[] args)
{
x = 0;
while (x <= 12)
{
Console.WriteLine(x);
x = x + 3;
}
}
}
}
กรณีที่ต้องการวนรอบโดยไม่ต้องตรวจสอบเงื่อนไข แต่เป็นการทำซ้ำที่เกิดจากการตรวจสอบค่าจากตัวแปรว่าอยู่ในช่วงค่าที่กำหนดหรือไม่จะใช้รูปแบบคำสั่งทำซ้ำเป็นดังนี้
for ( ค่าเริ่ม; เงื่อนไข; สิ่งที่ก่อนเริ่มรอบใหม่ ) {
สิ่งที่ทำ1
…
สิ่งที่ทำn
}
จากรูปแบบของคำสั่ง for สามารถเขียนขั้นตอนของการทำงานได้ดังนี้
1. ทำส่วนของค่าเริ่ม
2. ตรวจสอบเงื่อนไข ถ้าเงื่อนไขเป็นจริงจะทำ สิ่งที่ทำ1 ไปจนถึง สิ่งที่ทำn
แต่ถ้าเงื่อนไขเป็นเท็จจะข้ามการทำงานของคำสั่ง for
3. หลังจากทำสิ่งที่ทำn จะเข้าไปทำ สิ่งที่ก่อนเริ่มรอบใหม่
4. กลับไป 2
เมื่อนำโปรแกรมตัวอย่าง 1-7 มาเขียนในรูปแบบของ for จะเขียนได้ดังโปรแกรมตัวอย่าง 1-8
โปรแกรม 1-8 การวนซ้ำแบบ for
using System;
namespace loop_for
{
class Program
{
static Int32 x;
static void Main(string[] args)
{
for (x=0; x <= 12; x+=3)
{
Console.WriteLine(x);
}
}
}
}
และสำหรับการวนรอบหรือทำซ้ำโดยทำก่อน 1 รอบ หลังจากนั้นทำการตรวจสอบเงื่อนไข และถ้าเงื่อนไขเป็นจริงจะดำเนินการทำซ้ำอีกครั้งตราบเท่าที่เงื่อนไขนั้นเป้นจริง โดยรูปแบบของการใช้คำสั่งเป็นดังนี้
do {
สิ่งที่ทำ1
…
สิ่งที่ทำn
} while (เงื่อนไข);
นอกจากการทำซ้ำยังมีคำสั่งสำหรับออกจากการทำซ้ำ คือ break และคำสั่งสำหรับให้กลับไปตรวจสอบเงื่อนหลัง while โดยให้ข้ามคำสั่งถัดไป คือ continue
แถวลำดับของข้อมูล
แถวลำดับ (Array) เป็นโครงสร้างข้อมูลประเภทหนึ่งที่เกิดจากการจองข้อมูลประเภทเดียวกันเป็นจำนวน n ชุด ทำให้ข้อมูลอยู่ต่อเรียงกันไปเป็นลำดับที่ 0 ถึง n-1 อันทำให้สะดวกต่อการบริหารจัดการกับตัวแปร เช่น ต้องการสร้างตัวแปรเก็บพิกัดค่า x จำนวน 5 ชุด จะต้องสร้างตัวแปร 5 ตัว แต่ถ้าเป็นแถวลำดับจะใช้ตัวแปรตัวเดียว แต่อ้างอิงลำดับของข้อมูลเป็นข้อมูลลำดับที่ 0, 1, 2 ,3 และ 4 เป็นต้น
การสร้างตัวแปรประเภทแถวลำดับมีรูปแบบของการสร้างดังนี้
ชนิดตัวแปร[] ชื่อตัวแปร;
การกำหนดค่าให้กับแถวลำดับมีรูปแบบการสั่งงานดังนี้
ชนิดตัวแปร[] ชื่อตัวแปร;
สำหรับการประกาศตัวแปรพร้อมกับการระบุสมาชิกภายในแถวลำดับสามารถใช้งานตามรูปแบบดังต่อไปนี้
ชนิดตัวแปร[] ชื่อตัวแปร = new ชนิดตัวแปร[จำนวนสมาชิก];
ชนิดตัวแปร[จำนวนสมาชิก] ชื่อตัวแปร = {
ข้อมูล0, ข้อมูล1, ข้อมูล2, …, ข้อมูลจำนวนสมาชิก-1
};
ตัวอย่างการประยุกต์ใช้แถวลำดดับเพื่อเก็บค่าสถานะของตัวละคร เช่น ความแข็งแกร่ง (ST: Strength) ความแม่นยำ (AC: Accuracy) ความคล่องแคล่วว่องไว (DX: Dexterity) ความอดทน (RS: Resistance) แต้มชีวิต (HP: Hit Points) แต้มพลังเวทย์มนต์ (MP: Magic Points) และค่าประสบการณ์ ( EX: Experience ) โดยให้สมาชิกแต่ละตัวเก็บเป็นตัวเลขจำนวนเต็ม และค่าสูงสุดไม่เกิน 4000 พร้อมจัดเก็บแบบเรียงกันไปเป็นลำดับ 0,1,2,3,4 และ 5 สามารถเขียนได้ดังนี้
UIint16 [7] actor_stat;
การเข้าถึงสมาชิกของแถวลำดับจะต้องระบุตำแหน่งลำดับของสมาชิกนั้นดังรูปแบบการใช้งานด้านล่างนี้ โดยสมาชิกตัวแรกเป็นลำดับที่ 0 และลำดับสุดท้ายจะเท่ากับจำนวนสมาชิกลบด้วย 1
ชื่อตัวแปร[ ลำดับ ] = ค่า
สำหรับการอ้างอิงถึงค่าของข้อมูลในแถวลำดับให้ทำตามรูปแบบต่อไปนี้
ชื่อตัวแปร[ ลำดับ ]
การตรวจสอบจำนวนสมาชิกภายใแถวลำดับสามารถใช้คำสั่ง Length เพื่ออ่านค่าออกมาตามรูปแบบการใช้งานดังนี้
ชื่อตัวแปร.Length
กรณีที่กำหนดค่าของแต่ละคุณสมบัติให้มีค่าเรียงกันไปดังนี้ 5, 4, 5, 5, 10, 10 และ 0 หลังจากนั้นเขียนโปรแกรมเพื่อวนรอบเพื่อแสดงข้อมูลแต่ละรายการสามารถเขียนได้ดังตัวอย่างโรแกรม 1-9 และได้ผลลัพธ์ดังภาพที่ 1-3
โปรแกรม 1-9 แถวลำดับเก็บสถานะของตัวละคร
using System;
namespace array1
{
class Program
{
static UInt16[] actor_stat;
static void Main(string[] args)
{
actor_stat = new ushort[7];
String[] stat_info = {"ST","AC","DX","RS","HP","MP","EX"};
actor_stat[0] = 5; // ST
actor_stat[1] = 4; // AC
actor_stat[2] = 5; // DX
actor_stat[3] = 5; // RS
actor_stat[4] = 10; // HP
actor_stat[5] = 10; // MP
actor_stat[6] = 0; // EX
for (int idx=0; idx<actor_stat.Length; idx++)
{
Console.WriteLine(stat_info[idx].ToString() +
"="+ actor_stat[idx].ToString());
}
}
}
}
| หมายเหตุ การแปลงข้อมูลตัวเลขให้เป็นข้อความมีรูปแบบการใช้งานดังนี้ ข้อมูลตัวอักษร = ตัวแปร.ToString() |
โปรแกรมย่อย
โปรแกรมย่อย หรือ ฟังก์ชัน (function) หรือ เมธอด (method) เป็นการสร้างกลุ่มของคำสั่งเพื่อนำกลับมาใช้ในภายหลัง อันจะพบว่า ในโค้ดโปรแกรมที่ได้ศึกษามาในตัวอย่างก่อนหน้านี้มีฟังก์ชันหรือโปรแกรมย่อยชื่อ Main() ซึ่งเป็นโปรแกรมย่อยที่ไม่มีการคืนค่ากลับพร้อมทั้งไม่ต้องการพารามิเตอร์ และเป็นฟังก์ชันที่ถูกกำหนดให้เป็นฟังก์ชันแรกที่ถูกเรียกใช้เมื่อโปรแกรมเริ่มทำงาน โดยประเภทของโปรแกรมย่อยแบ่งเป็นหลายประเภท ได้แก่
1. โปรแกรมย่อยที่ไม่คืนค่าและไม่ต้องการพารามิเตอร์
2. โปรแกรมย่อยที่ไม่คืนค่าแต่ต้องการพารามิเตอร์
3. โปรแกรมย่อยที่คืนค่าแต่ไม่ต้องการพารามิเตอร์
4. โปรแกรมย่อยที่คืนค่าและต้องการพารามิเตอร์
โปรแกรมย่อยที่ไม่คินค่าและไม่ต้องการพารามิเตอร์
โปรแกรมย่อยประเภทนี้ไม่ต้องการข้อมูลนำเข้าและไม่คืนค่ากลับ โดยโครงสร้างของโปรแกรมย่อยแบบนี้เป็นดังนี้
void ชื่อโปรแกรมย่อย( )
{
คำสั่ง1;
คำสั่ง2;
…
คำสั่งn;
}
ตัวอย่างการเขียนโปรแกรมย่อยเพื่อแสดงข้อความ “Hello” สามารถเขียนได้ดังนี้
void say_hello() {
Console.WriteLine( “Helo” );
}
โปรแกรมย่อยที่ไม่คืนค่าแต่ต้องการพารามิเตอร์
โปรแกรมย่อยประเภทนี้ต้องการข้อมูลนำเข้าแต่ไม่คืนค่ากลับ ซึ่งข้อมูลนำเข้าเหล่านี้ถูกมองเสมือนเป็นตัวแปรภายในของโปรแกรมย่อยทำให้สามารถนำค่ามาใช้หรือเปลี่ยนแปลงค่าได้ตามความต้องการ โดยโครงสร้างของโปรแกรมย่อยแบบนี้เป็นดังนี้
void ชื่อโปรแกรมย่อย( ประเภทข้อมูล1 ข้อมูล1,
ประเภทข้อมูล2 ข้อมูล2,
…,
ประเภทข้อมูลn ข้อมูลn )
{
คำสั่ง1;
คำสั่ง2;
…
คำสั่งn;
}
ตัวอย่างโปรแกรมย่อยแสดงผลการบวกระหว่างตัวแปร x และ y ที่เป็น float สามารถเขียนได้ดังนี้
void show_add( float x, float y ) {
Console.WriteLine( x + y );
}
โปรแกรมย่อยที่คืนค่าแต่ไม่ต้องการพารามิเตอร์
โปรแกรมย่อยประเภทนี้ไม่ต้องการข้อมูลนำเข้า แต่มีการคืนค่ากลับหลังจากการทำงานเสร็จ เพื่อเปิดโอกาสให้ผู้ใช้งานโปรแกรมย่อยสามารถนำค่าคืนค่ากลับนี้ไปใช้ในการตรวสอบหรือนำไปเก็บในตัวแปรเพื่อนำไปใช้งานต่อไป โดยโครงสร้างของโปรแกรมย่อยแบบนี้เป็นดังนี้
ประเภทข้อมูล ชื่อโปรแกรมย่อย( )
{
คำสั่ง1;
คำสั่ง2;
…
คำสั่งn;
return ค่าคืนกลับ;
}
ตัวอย่างโปรแกรมการส่งค่าคืนกลับเป็นค่า Pi หารด้วย 180 สามารถเขียนได้ดังนี้
float pi_over_180() {
return ( 3.1415296f/180.0f );
}
โปรแกรมย่อยที่คืนค่าและต้องการพารามิเตอร์
โปรแกรมย่อยประเภทนี้ต้องการข้อมูลนำเข้า และคืนค่ากลับ ซึ่งข้อมูลนำเข้าเหล่านี้ถูกมองเสมือนเป็นตัวแปรภายในของโปรแกรมย่อยทำให้สามารถนำค่ามาใช้หรือเปลี่ยนแปลงค่าได้ตามความต้องการ พร้อมทั้งเมื่อทำงานเสร็จจะคืนค่ากลับไปให้ระบบ หรือนำไปเก็บในตัวแปรเพื่อเก็บผลลัพธ์ของการทำงานจากโปรแกรมย่อยนี้ต่อไป โดยโครงสร้างของโปรแกรมย่อยแบบนี้เป็นดังนี้
ประเภทข้อมูล ชื่อโปรแกรมย่อย( ประเภทข้อมูล1 ข้อมูล1,
ประเภทข้อมูล2 ข้อมูล2,
…,
ประเภทข้อมูลn ข้อมูลn )
{
คำสั่ง1;
คำสั่ง2;
…
คำสั่งn;
return ค่าคืนกลับ;
}
ตัวอย่างโปรแกรมย่อยแปลงค่ามุมแบบองศาให้เป็นเรเดียนเขียนได้ดังนี้
float degree_to_radian( float degree ) {
return degree * (180.0f/3.1415926f);
}
สรุป
จากบทความนี้จะพบว่าโครงสร้างการเขียนโปรแกรม C# โดยพื้นฐานมีความคล้ายกับการเขียนภาษา C/C++/Java/Kotlin คือ มีการประกาศประเภทของข้อมูล การตั้งชื่อ การดำเนินการแบบนิพจน์ การตรวจสอบเงื่อนไข การทำซ้ำ ข้อมูลแบบแถวลำดับ และโปรแกรมย่อย ทำให้เมื่อเข้าใจภาษาใดภาษาหนึ่งจักทำให้สามารถนำไปประยุกต์กับภาษาอื่น ๆ ได้ ในครั้งหน้าจะเป็นเนื้อหาของการใช้ C# ใน Godot Mono และขอให้สนุกกับการเขียนโปรแกรมครับ
(C) 2020-2023, โดย อ.ดนัย เจษฎาฐิติกุล/อ.จารุต บุศราทิจ
ปรับปรุงเมื่อ 2023-07-14, 2024-04-06