บทที่ 6

การใช้งานอาร์เรย์และสตริง


1.ตัวแปรอาร์เรย์ (Array)


ตัวแปรอาร์เรย์ เป็นกลุ่มของตัวแปรที่คุณประกาศขึ้นมา โดยใช้ชื่อของตัวแปรแต่ละตัวเหมือนกัน ข้อแตกต่างของตัวแปรแต่ละตัว จะใช้ค่า Index ในการอ้างอิง ตัวแปรชนิดนี้มีประโยชน์ในแง่ของการเก็บข้อมูลที่คล้ายๆ กัน เป็นชุดๆ โดยที่คุณไม่ต้องห่วงเรื่องการตั้งชื่อตัวแปรแต่ละตัว เพราะมีชื่อเหมือนกัน ต่างกันที่ค่า Index  จะทำให้การเรียกใช้งานตัวแปรเหล่านี้ง่าย และสะดวกกว่า   ซึ่งตัวแปรที่ประกาศเป็นแบบอาร์เรย์นี้   แต่ละตัวจะเรียกว่า สมาชิกตัวที่….  มีรูปแบบการประกาศดังนี้
Dim intCnt( ) As Integer
     จะเห็นได้ว่า มีความคล้ายกับการประกาศตัวแปรแบบปกติ ที่เพิ่มขึ้นมาก็คือ เครื่องหมายวงเล็บต่อท้ายชื่อตัวแปร ซึ่งหมายถึง คุณต้องการใช้งาน ตัวแปรแบบอาร์เรย์ ซึ่งสมาชิกแต่ละตัวในตัวแปรอาร์เรย์ จะต้องเป็นข้อมูลชนิดเลขจำนวนเต็ม Integer เท่านั้น ตัวแปรอาร์เรย์มี 2 ชนิด คือ
1.ตัวแปรอาร์เรย์แบบสแตติก (Static Arrays)
2.ตัวแปรอาร์เรย์แบบไดนามิก (Dynamic Arrays)

ตัวแปรอาร์เรย์แบบสแตติก (Static Arrays)

     เป็นอาร์เรย์ที่มีจำนวนสมาชิกที่แน่นอน ซึ่งคุณต้องระบุจำนวนสมาชิก โดยใช้เลขจำนวนเต็ม เข้าไปในวงเล็บด้วย ขอให้คุณจำลองหน่วยความจำในเครื่องว่า เป็นห้องๆ ติดกัน แต่ละห้องสามารถเก็บข้อมูลได้ 1 ตัวอักษร VB จะจองจำนวนห้องเพื่อเก็บข้อมูล ให้เท่ากับจำนวนตัวแปรอาร์เรย์ที่คุณระบุไว้ เช่น
Dim x(5 ) As Integer   หมายถึง ตัวแปร x เป็นตัวแปรอาร์เรย์ชนิดสแตติก ที่ใช้เก็บเลขจำนวนเต็ม Integer โดยที่มีสมาชิกทั้งสิ้น 5 ตัว การใช้งานตัวแปรแต่ละตัว โดยการใช้ชื่อ x(0) เป็นตัวที่ 1 หรือเรียกอีกอย่างหนึ่งว่า ขอบเขตล่าง ไปจนถึง x(4) เป็นตัวที่ 5 หรือเรียกอีกอย่างหนึ่งว่า ขอบเขตบน ซึ่งจะมีความสำคัญเป็นอย่างยิ่ง ในการใช้งานตัวแปรแบบอาร์เรย์ โดยปกติแล้วสมาชิกตัวแรกของตัวแปรแบบอาร์เรย์ จะมีลำดับที่ 0 เสมอ
Dim x(1 To 10 ) As Long  หมายถึง ประกาศตัวแปรอาร์เรย์ ที่มีสมาชิก 10 ตัว แต่ละตัวแทนข้อมูลชนิด Long โดยที่มีขอบเขตล่างเท่ากับ 1 สมาชิกตัวแรกคือ x(1) ไปจนถึง x(10) โดยที่มีขอบเขตบนเท่ากับ 10 เป็นต้น
     ค่าที่อยู่ในวงเล็บจะเรียกว่า ค่า Index ทำให้ตัวแปร x แต่ละตัวมีความแตกต่างกันนั่นเอง และในการใช้งาน ขอให้คุณใช้ตัวแปรอาร์เรย์ชนิดนี้ ให้น้อยที่สุดเท่าที่จะเป็นไปได้ เนื่องจากว่า เมื่อคุณประกาศตัวแปรอาร์เรย์แบบสแตติกแล้ว VB จะจองหน่วยความจำเท่ากับจำนวนสมาชิกทันที ถึงแม้ว่า คุณจะไม่มีการใช้งานตัวแปรก็ตาม หรือใช้งานตัวแปรไม่ครบทุกตัว คุณจะสูญเสียหน่วยความจำในส่วนนี้ไป เช่น กรณีข้างต้น สมมติว่า คุณใช้งานเพียง 3 ตัวแปร x(0), x(1) และ x(2) คุณต้องเสียหน่วยความจำไป 5 ส่วน ซึ่งไม่มีความจำเป็นแต่อย่างใด ขอให้คุณใช้อาร์เรย์ชนิดไดนามิกจะเหมาะสมกว่า

ตัวแปรอาร์เรย์แบบไดนามิก (Dynamic Arrays)

     เป็นตัวแปรอาร์เรย์ที่ใช้สำหรับกลุ่มของตัวแปร ที่คุณไม่ทราบจำนวนที่แน่นอน หรือคุณทราบแต่ต้องการใช้อาร์เรย์แบบไดนามิก เพื่อประหยัดทรัพยากรระบบ โดยที่ตัวแปรแบบอาร์เรย์ จะปรับขนาดจำนวนสมาชิกให้เท่ากับ จำนวนตัวแปรที่คุณต้องการใช้ในขณะนั้น จะเห็นได้ว่า มีการใช้ทรัพยากรระบบ เมื่อต้องการเท่านั้น ซึ่งเป็นข้อดีเป็นอย่างยิ่ง มีรูปแบบการประกาศดังนี้
Dim intCnt( ) As Integer
     ข้อแตกต่างของตัวแปรอาร์เรย์แบบไดนามิก คือ คุณไม่ต้องระบุจำนวนสมาชิกในวงเล็บ จะเห็นได้ว่ามีความยีดหยุ่นมากกว่า ตัวแปรอาร์เรย์แบบสแตติก แต่ถ้าในขณะรัน คุณต้องการกำหนดจำนวนสมาชิกที่แน่นอน คุณต้องใช้คำสั่งดังนี้
ReDim [Preserve] varname(subscripts) As type
  • คำสั่ง ReDim หมายถึง คุณต้องการกำหนดจำนวนสมาชิกในตัวแปรอาร์เรย์ใหม่
  • คำสั่ง Preserve หมายถึง คุณต้องการเก็บข้อมูลเดิม ที่ตัวแปรอาร์เรย์ดังกล่าวเก็บไว้
  • ตัวแปร varname หมายถึง ตัวแปรอาร์เรย์ที่คุณต้องการกำหนดจำนวนสมาชิก
  • ตัวแปร subscripts หมายถึง ขนาดจำนวนสมาชิกที่คุณต้องการ จะต้องเป็นเลขจำนวนเต็ม
  • ตัวแปร type หมายถึง ชนิดของข้อมูลที่คุณต้องการให้ตัวแปรอาร์เรย์ทดแทน เช่น
สมมติว่าคุณประกาศตัวแปรอาร์เรย์  Dim intCnt( ) As Integer ต่อมาคุณต้องการระบุขนาดจำนวนสมาชิกของตัวแปรดังกล่าว ให้คุณทำดังนี้
ReDim intCnt(10 ) As Integer
แต่ถ้าคุณต้องการรักษาค่า ที่ตัวแปรอาร์เรย์ intCnt ( ) เก็บไว้ด้วย คุณต้องเพิ่มเติมดังนี้
ReDim Preserve intCnt(10 ) As Integer
     จากกรณีที่กล่าวมา เป็นการสร้างตัวแปรอาร์เรย์แบบ 1 มิติ คุณสามารถเพิ่มเติมให้ตัวแปรอาร์เรย์มีประสิทธิภาพมากยิ่งขึ้น ด้วยการใช้ ตัวแปรอาร์เรย์แบบหลายมิติ

2. อาเรย์หลายมิติ


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

อาเรย์ 2 มิติ

อาเรย์ 2 มิติ เป็นอาเรย์ที่จะใช้ลำดับในการอ้างอิง 2 ตัว โดยที่ตัวหนึ่งเป็นตัวหลัก เปรียบได้กับเป็นแถวในตาราง และอีกตัวเป็นคอลั่ม ดังนั้นหากเราต้องการที่จะดึงข้อมูลออกมาจากอาเรย์ เราจะต้องรู้ว่าข้อมูลนั้นๆอยู่แถวที่เท่าไหร่ และอยู่คอลั่มที่เท่าไหร่
ตัวอย่างเช่น การเปรียบเทียบราคาของซีพียูอินเทลรุ่นหนึ่งในแต่ละร้าน และแต่ละปี จะนำข้อมูลมาเขียนเป็นตารางง่ายๆดังนี้
ปี / ชื่อร้านร้านนาย ก.ร้านนาย ข.ร้านนาย ค.ร้านนาย ง.
20123,1002,9903,1203,000
20133,0002,9003,0003,100
20142,9002,9103,0003,000
20152,0002,0002,0002,000
จากตาราง จะเห็นว่าอาเรย์มิติเดียวไม่สามารถเก็บข้อมูลที่มีจำนวนมากได้ จึงจำเป็นต้องใช้อาเรย์แบบ 2 มิติ ในเก็บข้อมูล ซึ่งข้อมูลจะถูกนำไปเก็บในอาเรย์ได้ จะป็นดังนี้
int price[4][5] = {
{2012, 3100, 2990, 3120, 3000}, 
{2013, 3000, 2900, 3000, 3100}, 
{2014, 2900, 2910, 3000, 3000}, 
{2015, 2000, 2000, 2000, 2000}
};
จะเห็นว่าการประกาศตัวแปรเริ่มต้น ยังเป็นรูปแบบ TYPE NAME[SIZE] อยู่ แต่มีการเพิ่มมิติเพิ่มขึ้นมา ทำให้ได้ออกมาเป็น TYPE NAME[SIZE1][SIZE2] แล้วจึงกำหนดค่า
จากโค้ดจะเห็นว่าผมได้กำหนขนาดของมิติแรกเป็น 4 เพราะในตารางมีข้อมูลทั้งหมด 4 ปีด้วยกัน คือปี 2012 2013 2014 และ 2015 ในมิติที่ 2 ได้กำหนดไว้ว่าจะมีข้อมูลย่อยอีก 5 ตัว ในรูปแบบของ ปี, ราคาร้านนาย ก., ราคาร้านนาย ข., ราคาร้านนาย ค., ราคาร้านนาย ง. เมื่อนำโค้ดด้านบนมาใส่ลงในตาราง จะได้เป็น
priceprice[x][0]price[x][1]price[x][2]price[x][3]price[x][4]
price[0][y]20123,1002,9903,1203,000
price[1][y]20133,0002,9003,0003,100
price[2][y]20142,9002,9103,0003,000
price[3][y]20152,0002,0002,0002,000
จะเห็นว่าตารางแรกจะแตกต่างจากตารางนี้ เพราะว่าเราไม่สามารถนำปี มาใช้เป็น Key ที่ใช้กำหนดลำดับของอาเรย์ได้ จึงต้องนำปีไปรวมกับข้อมูลของร้านนั้นๆ

การอ่านข้อมูลอาเรย์ 2 มิติ

จากที่ได้กล่าวไปข้างต้นนั้น เราจำเป็นที่จะต้องรู้ลำดับ หรือ Key ของอาเรย์เสียก่อน จึงจะสามารถนำค่าออกมาได้ ตัวอย่างหากผมต้องการดึงว่าตอนปี 2014 ของร้านนาย ค. ได้ขายซีพียูในราคาเท่าไหร่ ซึ่งหากเราพิจารณาจากตาราง จะพบว่าเราจะต้องดึงออกมาจากลำดับที่ 2,3 เพราะในปี 2014 มีข้อมูลอยู่ลำดับ หรือ Key ที่ 2 แล้วร้านนาย ค. อยู่ลำดับ หรือ Key ที่ 3 ดังนั้นหากจะดึงข้อมูลออกมา ก็สามารถทำได้ง่ายๆ ดังนี้
int val = price[2][3];
จากโค้ดจะเห็นว่าได้มีการดึงข้อมูลจากอาเรย์ในมิติแรกลำดับที่ 2 และในมิติที่สอง ลำดับที่ 3 แล้วจึงนำค่าที่ได้มาเก็บไว้ในตัวแปรชนิด int ชื่อตัวแปร val

การเซ็ตตัวแปรอาเรย์ 2 มิติ

การเซ็ตตัวแปรอาเรย์ 2 มิติ จะคล้ายๆกับการเซ็ตค่าของตัวแปรปกติ เพียงแต่จะต้องระบุลำดับของข้อมูลที่ต้องการแก้ไขในแต่ละมิติด้วย
price[2][3] = 2900;
อาเรย์หลายมิติ
อาเรย์แบบหลายมิติจะใช้เมื่อมีกลุ่มข้อมูลชนิดเดียวกันจำนวนมาก และใช้แค่ 2 มิติยังไม่พอ หากยังนึกภาพไม่ออกว่าอาเรย์หลายมิติมีรูปแบบอย่างไร ก็ให้นึกถึงกระดาษที่มีข้อมูลคล้ายๆกับอยู่วางซ้อนทับกันอยู่ ที่การจะนำข้อมูลจำนวนมากไปวางลงในกระดาษแผ่นเดียวนั้นไม่พอ จึงต้องมีการใช้กระดาษหลายแผ่น เมื่อนำมาวางซ้อนกัน จะทำให้เห็นภาพว่ามิติที่ 3 คืออะไร
* วิทยาศาสตร์อธิบายไว้ง่ายๆว่า หากเราระบุข้อมูลของอะไรก็ตามได้ 1 ตัว นั่นหมายถึงสิ่งนั้นมี 1 มิติ หากระบุได้ด้วย 2 ตัวเลข เช่นรูปสี่เหลี่ยม จะเป็น 2 มิติ แต่หากเป็นรูปทรงลูกบาศก์ ซึ่งจะเป็น 3 มิติ เนื่องจากระบุรายละเอียดได้ด้วย 3 ตัวเลข
การประกาศเป็นตัวแปรอาเรย์หลายมิติ จะเหมือนกับรูป 2 มิติ คือใช้เครื่องหมาย [] ในการระบุขนาดของมิติที่ 3 เพิ่มขึ้นมา เช่น
int price[10][2][2];
ส่วนการเรียกใช้ก็เช่นเดียวกัน คือ
int val = price[0][0][0];


3.ตัวแปรสตริง (String)


ตัวแปรสตริง (String)
ตัวแปร string หรือแถวตารางอาเรย์ของตัวหนังสือนั้น ภาษา C ไม่มีกลไกที่จะสนับสนุนได้โดยตรง ถ้าต้องการให้ภาษา C สามารถรองรับข้อมูลที่เป็นตัวหนังสือแล้ว
จะต้องมีการเตรียมพื้นที่หน่วยความจำให้เหมาะสมหรือการใช้สตริงค่าคงที่ (strong constant) ซึ่งจะทำให้โปรแกรมภาษา C เข้าถึงข้อมูลสตริง
ซึ่งจะเป็นทั้งข้อมูลที่เข้ามาในโปรแกรมและเป็นข้อมูลที่ออกจากโปรแกรมได้
โดยทั่วไปแล้วโปรแกรมภาษา C จะสนับสนุนข้อมูลที่เป็นอักษรโดยกำหนดให้อักษรแต่ละตัว ในรูปแบบตัวแปรประเภท char
และข้อมูลสตริงนั้นโปรแกรมที่เขียนด้วยภาษา C จะถือว่าเป็นชุดข้อมูลตัวหนังสือที่เรียงกันตามลำดับ
ขณะที่โปรแกรมที่เขียนด้วยภาษา C++ จะถือว่าสตริงเป็นตารางอาเรย์ข้อมูลประเภทตัวหนังสือ (Array of char)
โดยตัวหนังสือจะอยู่ในตารางแต่ละช่อง และ ณ ตำแหน่งสิ้นสุดของตารางอาเรย์ที่เก็บตัวแปรสตริงนั้นจะมีสัญลักษณ์ “{PBODY}”
(ตัวสิ้นสุดสตริง หรือ ตัว NULL) บรรจุอยู่ ดังนั้น ในการเตรียมเนื้อที่สำหรับตัวแปรสตริงที่ประกอบด้วยตัวหนังสือ n ตัวนั้น
จะต้องเตรียมตารางไดนามิกขนาด n+1 ช่องเสมอ ดังตัวอย่างต่อไปนี้

1) ตัวหนังสือ ‘a’ เป็นตัวแปร char จะใช้เนื้อที่ 1 ไบต์ แต่ “a” เป็นตัวแปร string แล้ว จะต้องใช้เนื้อที่ขนาด 2 ไบต์เพื่อจุตัวอักษร ‘a’ และ ตัวสิ้นสุดสตริง ({PBODY})
2) ตัวแปรสตริงสามารถประกาศให้อยู่ในรูปตารางต่อไปนี้ได้
a. ตารางอาเรย์ตัวหนังสือ char String1[10] สามารถรองรับตัวหนังสือได้มากที่สุด 9 ตัว และ ตัวสิ้นสุดสตริง
b. ตัวแปรพอยเตอร์ตัวหนังสือ char *String2 สามารถรองนับตัวหนังสือได้ตามที่ผู้เขียนโปรแกรมได้เตรียมเนื้อที่ตารางไดนามิกส์ไว้

ถ้าต้องการทำอะไรกับตัวแปรสตริงแล้วให้เรียกใช้เฮดเดอร์ไฟล์ string.h ซึ่งเป็นไลบรารีไฟล์มาตรฐานสำหรับจัดการกับตัวแปรสตริง
เราสามารถตั้งค่าเริ่มต้นให้ตัวแปรสตริงได้ 2 วิธีหลักคือ
char S1[] = “Example”;
ซึ่งภายในตัวแปรประกอบด้วย
S1 |E|x|a|m|p|l|e|{PBODY}|
ทั้งนี้เนื่องจากการเตรียมพื้นที่ขนาด 8 ช่องตาราง โดย 7 ช่องตารางแรกเก็บตัวหนังสือ และ ข้อมูลช่องสุดท้ายเก็บตัวสิ้นสุดสตริง
char S2[20] = “Another Example”; ซึ่งภายในตัวแปรประกอบด้วย
S2 |A|n|o|t|h|e|r| |E|x|a|m|p|l|e|{PBODY}||?|?|?|?|
ทั้งนี้เนื่องจากการเตรียมพื้นที่ขนาด 20 ช่องตาราง แต่ใช้จริง 16 ช่อง คือตัวหนังสือ 15 ช่องและ ช่องที่ 16 เก็บตัวสิ้นสุดสตริง
การตั้งต้นตัวแปรสตริง ดังตัวอย่างต่อไปนี้ถือว่าเป็นการตั้งต้นตัวแปรสตริงที่ถูกต้อง


ดังนั้น สิ่งที่เกี่ยวข้องสตริงสามารถสรุปออกมาได้ดังนี้
- ตัวแปรสตริงคือ ลำดับตัวหนังสือที่อยู่ภายในเครื่องหมายอัญประกาศ หรือเครื่องหมายคำพูด (“ ”) หรือ ตัวแปรสตริงคงที่ (String Constant)
- อีกทางหนึ่งตัวแปรสตริงถือว่าเป็นตัวแปรตารางอาเรย์ ของตัวหนังสือ (Array of char)
- สามารถใช้คำสั่ง printf scanf และ print ของภาษา C กับตัวแปรสตริงได้
- การประมวลเท็กซ์ คือการประมวลตัวแปรสตริง
- หน่วยข้อมูลพื้นฐานของตัวแปรสตริงคือตัวหนังสือหรือ ชุดตัวหนังสือ ไมใช่ตัวเลข
- การประยุกต์ใช้ตัวแปรสตริงนั้นคือ Word Processing หรือ Text Editor

ตัวอย่างการใช้ตัวแปรสตริงจะแสดงให้เห็นดังนี้
#include  
void main()
{
	char first[100], last[100];
	int i;

	printf("
Enter your first name:");
	scanf("%s", first );
	printf("
Enter your last name:");
	scanf("%s", last );
	printf("
Your full name is: %s %s
", first, last );
	printf("First name is: ");
	for( i=0; (i<100 && first[i] != '{PBODY}') ; i++ ){
	   printf("%c ",first[i]);
	}
	printf("
Last name is: ");
	for( i=0; (i<100 && last[i] != '{PBODY}') ; i++ ){
	   printf("%c ",last[i]);
	}
	printf("
");
}

ผลที่ได้การเขียนโปรแกรมเติมชื่อและนามสกุลจะแสดงให้เห็นในภาพที่ 7.1


การใช้งานตัวแปรสตริงนั้นมีหลักการดังนี้
- เตรียมพื้นที่ตารางอาเรย์ให้ใหญ่พอรับตัวหนังสือแทนคำและ ตัวสิ้นสุดสตริงดังต่อไปนี้
char str1[6] = “Hello”;
char str2[] = “Hello”;
char *str3 = “Hello”;
char str4[6] = {‘H’,’e’,’l’,’l’,’o’,’{PBODY}’};
ตัวแปรสตริงแต่ละตัวถือว่าเป็นตัวแปรคงที่ ดังนั้นจึง Assign ค่าแทนกันเช่นตัวอย่างต่อไปนี้ไม่ได้
Str1 = Str2; // ห้ามทำเช่นนี้กับตัวแปรสตริง เพราะมีวิธีอื่นที่ดีกว่านั้น

ตัวอย่างต่อไปนี้แสดงให้เห็น วิธี Assign ตัวแปรสตริงโดยใช้ตัวแปรพอยเตอร์ เข้าช่วย
char *S1 = “Hello”, *S2 = “Goodbye”; // ตัวแปร S1 และ S2 แก่ไขเปลี่ยนแปลงไม่ได้
char *S3;
S3 = S1; // บังคับให้ S3 ชี้ไปที่ แอดเดรสของตัวแปรพอยเตอร์ S1
S3 = S2; // บังคับให้ S3 ชี้ไปที่ แอดเดรสของตัวแปรพอยเตอร์ S2

อีกตัวอย่างในการ Assign ตัวแปรสตริงสามารถแสดงให้เห็นดังนี้
char Str[6] = “Hello”; // ตั้งต้นตัวแปร Str ด้วยคำว่า Hellow
char Str[0] = ‘Y’; char Str[4] = ‘{PBODY}’; // การแก้ไขให้ Str = “Yell”

อย่างไรก็ตาม วิธีแก้ไขเปลี่ยนแปลงข้อมูลสตริงในตารางมีเงื่อนไขว่า
- ตารางอาเรย์ที่ทำหน้าที่เป็นสตริงจะต้องปิดท้ายด้วย ‘{PBODY}’ เสมอ มิฉะนั้นตัวแปรอาเรย์ที่ทำหน้าที่เป็นสตริงจะไม่มีจุดสิ้นสุดสตริง
- สตริงที่แก้ไขต้องมีขนาดน้อยกว่าขนาดของตารางอาเรย์ที่เก็บค่าสตริง

การเปลี่ยนแปลงแก้ไขตัวแปรสตริงโดยใช้ไดนามิกอาเรย์นั้นต้องใช้ความระมัดระวังเป็นอย่างยิ่ง
เพราะตารางไดนามิกส์นั้นต้องเตรียมพื้นที่ให้ ตัวสิ้นสุดสตริง (NULL) มิฉะนั้นโปรแกรมจะพิมพ์ข้อมูลสตริงออกมาผิดไปจากที่ต้องการ
ดังตัวอย่างต่อไปนี้

char *s; 
	s = (char *)malloc(sizeof(char) * 0); // - WRONG, need to allocate 1 more space
	strcpy(s, "linux"); 
	printf("%s
", s);

กรณีที่ใช้คำสั่ง strlen เพื่อหา ขนาดอาเรย์ก่อนทำ Dynamic allocation (malloc) นั้น พึงรับทราบว่า คำสั่ง strlen
จะมีขนาดเพียงพอสำหรับตัวจำนวนอักษรที่ใช้ในตัวแปรสตริงเท่านั้น แต่ไม่ได้นับตัวแปร NULL ที่ใช้กำหนดจุดสิ้นสุดของสตริงด้วย
โดยที่รายละเอียดเกี่ยวกับคำสั่ง strlen จะกล่าวถึงในตอนต่อไป

การกำหนดค่าให้ตัวแปรสตริง (String Assignment)
ตัวอย่างการกำหนดค่าให้ตัวแปรสตริง
char s[5]="SIIT";      	// ใช้ได้, กำหนดค่าตัวแปรสตริงให้ตัวแปรอาเรย์
	char dept[5], *d=dept;  // ใช้ได้, กำหนดค่าตัวแปรสตริงให้ตัวแปรพอยเตอร์
	char name[20];
	name = “C. Sinthanayothin";	// ผิด อย่ากำหนดตัวแปรสตริงให้ตัวแปรอาเรย์ด้วยวิธีนี้
	strcpy(name,“C. Sinthanayothin");	// ใช้ได้, ให้ก๊อปปี้ค่าสตริงโดยใช้คำสั่ง strcpy  
	strcpy(dept,"IT");		// ใช้ได้, ก๊อปปี้ค่าสตริง ลงในตัวแปร dept
	printf("%s %s %s
",d,s,dept);	// ใช้ได้, แสดงผลค่าสตริงด้ว printf
	d = strcpy(s,"EE");		// ใช้ได้, นี่คือการคืนค่าตัวแปรสตริง ลงใน ตัวแปร d ด้วยคำสั่ง strcpy
	printf("%s %s %s %s
",name,d,s,dept);

	char c1[30], c2[30]=“This is new c1 string”;
	char s[30] = "c programming "; 
	char str1[30];  // วิธี้ทำให้ตัวแปร str1 ไม่เป็น l-value เพราะเป็น constant array
	char *str;	// วิธี้ทำให้ตัวแปร str เป็น l-value เพราะเป็น ตัวแปรพอยเตอร์ 
	strcpy(c1, c2);			// ใช้ได้, ก๊อปปี้ข้อมูลใน c2 ลงใน c1
	str = strcat(s,"is great!!");	// ใช้ได้, คือค่าเป็น ตัวแปรพอยเตอร์ประเภท char 
	str1 = strcat(s,"is great!!");	// ผิด, ฟังก์ชัน strcat ต้องคืนค่าด้วยตัวแปรพอยเตอร์ประเภท char 
                                                   ไม่ใช่ตารางอาเรย์ประเภท char
ข้อควรจำคือ: ต้องเตรียมพื้นที่หน่วยความจำไว้ให้พร้อมก่อนการกำหนดค่าให้ตัวแปรสตริงมิฉะนั้นอักษรบางตัวก็จะแหว่งหายไป
ตัวแปรสตริงนั้นจะใช้ %s เป็นตัว place holder ขณะที่ใช้คำสั่ง sscanf ในการอ่านข้อมูลจำพวกสตริงแล้วจัดการแปลงข้อมูลให้อยู่รูปตามที่กำหนด
ดังตัวอย่างต่อไปนี้
int sscanf( const char *buffer, const char *format [, argument ] ... ); 

char ch, int inum, float fnum; 
char buffer[100] = “A10 50.0”;
sscanf(buffer,”%c%d%f”,&ch,&inum,&fnum);	/* puts ‘A’ in ch, 10 in inum and 50.0 in fnum */

sscanf("  85  96.2  hello","%d%.3lf%s",&num,&val,word);

// results: num=85, val = 96.2, word = "hello"
 	ส่วน sprintf ใช้แสดงผลลัพธ์ที่อยู่ในรูปแบบต่างๆ ให้เป็นตัวแปรสตริงดังตัวอย่างต่อไปนี้
int sprintf( char *buffer, const char *format [, argument] ... );

char buffer[100];
sprintf(buffer,”%s, %s”,LastName,FirstName);
if (strlen(buffer) > 15)
  printf(“Long name %s %s
”,FirstName,LastName);







ถ้าต้องการแปลงตัวเลขให้เป็นข้อมูลสตริงให้ใช้ฟังก์ชัน sprintf และ ตัวแปรดัชนี้ char ทำตามคำสั่งต่อไปนี้






int sscanf(char *buffer, const char *format [, argument ] ... ); 
char S[10]; int day, month,year;
sprintf(S,”%d/%d/%d”, day, month, year);
ถ้า day = 23, month = 8, year = 2001 ผลลัพธ์คือ S = “23/8/2001”







ต่อไปนี้คือตัวอย่างการใช้ sprintf กับ sscanf เมื่อเปรียบเทียบกับ printf






#include 
#include 
int main()
{
	char s[30]="85  96.2  hello";
	int num, mon=8,day=23,year=2001;
	double val;
	char word[10];  // can we use: char *word;   
		// make sure your assign the proper address for pointer
	sscanf("  85  96.2  hello","%d%lf%s",&num,&val,word);
	printf("num=%d   val=%.3lf   word=%s
",num,val,word);
	sprintf(s,"%d/%d/%d", mon, day, year);
	printf("s = %s
",s);
	return 0;
}







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

int strlen(char *str); 
char str1 = “hello”; 
strlen(str1) จะคืนค่าออกเป็น 5 เพราะ มีอักษร 5 ตัว      	

strcpy(dst,src) 
– ก็อปปี้ข้อมูลจากตัวแปรสตริง src พร้อมตัวสิ้นสุดสตริง NULL ไปที่ตัวแปรสตริง dst แต่มีเงื่อนไขว่าตัวแปร des 
ต้องได้รับการเตรียมพื้นที่ให้ใหญ่พอๆกับตัวแปร src และการเตรียมพื้นที่ ให้ ตัวแปร src และ ตัวแปร dst 
ต้องไม่ทับซ้อนกันมิฉะนั้นจะให้ผลที่คาดเดาไม่ได้ การประกาศใช้ฟังก์ชัน strcpy จะทำได้ดังนี้   	

char *strcpy(char *dst, char *src)  strncpy(dst,src,n) 

– ก็อปปี้ข้อมูลจากตัวแปรสตริง src โดยไม่ก๊อปปี้ตัวสิ้นสุดสตริง NULL ไปที่ตัวแปรสตริง dst เนื่องจากมีจำนวนตัวอักษร n เป็นตัวจำกัดไว้ 
แต่มีเงื่อนไขว่าตัวแปร des ต้องได้รับการเตรียมพื้นที่ให้ใหญ่พอๆกับตัวแปร src และการเตรียมพื้นที่ ให้ ตัวแปร src 
และ ตัวแปร dst ต้องไม่ทับซ้อนกันมิฉะนั้นจะให้ผลที่คาดเดาไม่ได้ การประกาศใช้ฟังก์ชัน strncpy จะทำได้ดังนี้   

char *strncpy(char *dst, char *src, int n)      	

strcmp(str1,str2) 
– เปรียบเทียบข้อมูลในตัวแปร str1 กับข้อมูลในตัวแปรสตริง str2 โดยใช้อักษรตัวแรกที่เริ่มต่างกันเป็นหลักซึ่งให้ผลดังนี้  
น้อยกว่า 0  
-- ถ้าค่า  ASCII ที่เริ่มแตกต่างใน str1 มีขนาดเล็กกว่า str2 หรือ str1 เริ่มต้นเหมือนกับ str2 แต่ str2 นั้นมีตัวอักษรมากกว่า 
มากกว่า 0 
-- ถ้าค่า  ASCII ที่เริ่มแตกต่างใน str1 มีขนาดใหญ่กว่า str2 หรือ str1 เริ่มต้นเหมือนกับ str2 แต่ str1 นั้นมีตัวอักษรมากกว่า 0 
ถ้าตัวแปรสตริงทั้ง 2 ตัวนั้นใช้ตัวอักษรเดียวกันและความยาวเท่ากัน   

การประกาศใช้ฟังก์ชัน strcmp จะทำได้ดังตัวอย่างต่อไปนี้





int strcmp(char *str1, char *str2) 
#include 
#include 
void main()
{
	printf("%d 
", strcmp("hello","hello")); // returns 0
	printf("%d 
", strcmp("yello","hello")); //returns value > 0
	printf("%d 
", strcmp("Hello","hello")); // returns value < 0
	printf("%d 
", strcmp("hello","hello there")); // returns value < 0
	printf("%d 
", strcmp("some diff","some dift")); //returns value<0
}







strncmp(str1,str2,n) 
– เปรียบเทียบข้อมูลในตัวแปร str1 กับข้อมูลในตัวแปรสตริง str2 เป็นจำนวนอักษร n ตัวโดยใช้อักษรตัวแรกที่เริ่มต่างกันเป็นหลัก 
และ จะมีการเปรียบเทียบในกรณีที่อักษรในตัวแปรมีจำนวนน้อยกว่า n   การประกาศใช้ฟังก์ชัน strncmp จะทำได้ดังตัวอย่างต่อไปนี้  

int strncmp(char *str1, char *str2,int n)   

ความแตกต่างระหว่าง strcmp และ strncmp จะแสดงให้เห็นดังตัวอย่างต่อไปนี้  
strcmp(“some diff”,”some DIFF”)           
 -- returns value > 0 
strncmp(“some diff”,”some DIFF”,4)            
 -- returns 0   	

strcat(str1,str2)
– ใช้ในการนำข้อมูลในตัวแปร str2 ไปต่อท้ายตัวแปร str1  ซึ่งจะคืนค่าเป็น str1 ที่ได้รับการต่อให้ยาวขึ้น 
ตัวอย่างเช่น 
 char *s1 = “C. “, *s3 = strcat(s1,“Sinthanayothin”); 
ผลลัพธ์: s1 = s3 = “C. Sinthanayothin”  

การประกาศใช้ฟังก์ชัน strcat จะทำได้ดังตัวอย่างต่อไปนี้ 

char* strcat(char *s1, const char* s2); 	

strncat(str1,str2,n) 
 – ใช้ในการนำข้อมูลในตัวแปร str2 จำนวน n อักษรไปต่อท้ายตัวแปร str1  ซึ่งจะคืนค่าเป็น str1 ที่ได้รับการต่อให้ยาวขึ้น 

ตัวอย่างเช่น  
char s1[10] = "IT "; 
char *s3 = strncat(s1,"050Basic",3);
printf("%s 
", s1);	
printf("%s 
", s3); 
ผลลัพธ์: s1 = s3 = IT 050  

การประกาศใช้ฟังก์ชัน strncat จะทำได้ดังตัวอย่างต่อไปนี้

char* strncat(char *s1, const char* s2ม int n);  

ฟังก์ชันเหล่านี้มีอยู่ในไลบรารีเฮดเดอร์ไฟล์ string.h ซึ่งต้องใช้คำสั่ง #include  ถึงจะเรียกใช้ได้   	
เราสามารถสร้างตารางอาเรย์ให้ตัวแปรสตริง (Array of string) ดังตัวอย่างต่อไปนี้  

char month[12][10] = {“January”, “February”, “March”, “April”, “May”, “June”, “July”, 
“August”, “September”, “October”, “November”, “December” };   

แต่ถ้าต้องการให้ตารางอาเรย์สำหรับตัวแปรสตริง สามารถรองรับข้อมูลสตริงที่มีความยาวต่างกัน (Ragged array of string) ให้ดังนี้
char *MonthNames[13]; /* an array of 13 strings */ 
MonthNames[1] = “January”; /* String with 8 chars */ 
MonthNames[2] = “February”; /* String with 9 chars */ 
MonthNames[3] = “March”; /* String with 6 chars */
 …  

ตัวอย่างตารางอาเรย์ให้ตัวแปรสตริงแสดงวันทั้ง 7 แบบ Ragged array of string จะแสดงให้เห็นในตัวอย่างต่อไปนี้






#include 
#include 
void main() 
{
  char *days[7]; char TheDay[10];int day;
  days[0] = "Sunday";	days[1] = "Monday";
  days[2] = "Tuesday";	days[3] = "Wednesday";
  days[4] = "Thursday";	days[5] = "Friday";
  days[6] = "Saturday";
  printf("Please enter a day: ");
  scanf("%9s",TheDay);
  day = 0;
  while ((day < 7) && (strcmp(TheDay,days[day])))
        day++;
  if (day < 7) printf("%s is day %d.
",TheDay, day);
  else printf("No day %s!
",TheDay);
} 






ในการรับและส่งข้อมูลจำพวกสตริงนั้นทำได้หลายวิธี ได้แก่
1)	ในกรณีที่ใช้คำสั่ง printf และ scanf นั้นให้ใช้ %s ในการอ่านข้อมูลและ แสดงข้อมูลสตริงออกมา  
2)	ใช้คำสั่ง gets ในการข้อมูลสตริงออกมาทีละบรรทัด ดังตัวอย่างต่อไปนี้  
char name1[10], name2[30]; 
scanf(“%s”,name1);    // Input: IT 050
gets(name2);	// Input: C Programming 
printf(“Course is %s
”,name);  // Output: IT 050 
printf(“Detail is %s
”,name2); // C Programming     

[[5540]]   


การใช้งานคำสั่งกับตัวแปร อักษร (char operators)  
นี่คือตัวอย่างการใช้งานฟังก์ชันที่คุมการรับส่งข้อมูลตัวอักษร  

char ch; 
ch = getchar();              // Input ch – ใช้แทน scanf("%c",&ch);
putchar(ch);                  // Output ch – ใช้แทน printf("Character  is %c
",ch);  
ch = 'S';	                   // ใช้ได้ ตัวอย่างการกำหนดค่าตัวอักษรให้ตัวแปร 
char putchar(ch);		   // ผลที่ได้ออกมาคือ S 
putchar('T');		   // ผลที่ได้ออกมาคือ T  	

ฟังก์ชันที่ใช้กำหนดการทำงานให้ตัวแปร char ได้แก่  
คำสั่ง: isalpha(ch); 
การใช้งาน: คืนค่าเป็น TRUE (จริง) ถ้า ch มีค่าในช่วง A-Z หรือ a-z 
ตัวอย่าง: c = isalpha(ch);    // คืนค่า TRUE ถ้า ch=‘M’ และ คืนค่า FALSE ถ้า ch=‘5’  

คำสั่ง: isdigit(ch); 
การใช้งาน: คืนค่าเป็น TRUE (จริง) ถ้า ch มีค่าในช่วง0-9 
ตัวอย่าง: d = isdigit(ch);      // คืนค่า FALSE ถ้า ch=‘M’ และคืนค่า TRUE ถ้า ch=‘5’  

คำสั่ง: islower(ch); 
การใช้งาน: คืนค่าเป็น TRUE (จริง) ถ้า ch มีค่าในช่วง a-z 
ตัวอย่าง: c = islower(ch);      // คืนค่า FALSE ถ้า ch=‘M’ return false, และคืนค่า TRUE ถ้า  ch=‘m’  

คำสั่ง: isupper(ch); 
การใช้งาน: คืนค่าเป็น TRUE (จริง) ถ้า ch มีค่าในช่วง A-Z 
ตัวอย่าง: c = isupper(ch);     // คืนค่า TRUE ถ้า ch=‘M’ return false, และคืนค่า FALSE ถ้า  ch=‘m’ 

คำสั่ง: isspace(ch); 
การใช้งาน: คืนค่า TRUE ถ้า ch คิอช่องว่างขาว (space, newline, tab ) 
ตัวอย่าง: c = isspace(ch);      // คืนค่า TRUE ถ้า ch = ‘
’ คืนค่า FALSE ถ้า ch=‘m’  

คำสั่ง: tolower(ch); 
การใช้งาน: คืนค่าตัวพิมพ์เล็กจากค่าอักษรในตัวแปร ch ถ้าเป็นไปได้ 
ตัวอย่าง: c = tolower(ch);       // คืนค่า ‘m’ ให้ c ถ้า ch=‘M’  

คำสั่ง: toupper(ch); 
การใช้งาน: คืนค่าตัวพิมพ์ใหญ่จากค่าอักษรในตัวแปร ch ถ้าเป็นไปได้ 

คำสั่ง: c = toupper(ch);   // คืนค่า ‘M’ ให้ c ถ้า ch=‘m’

ไม่มีความคิดเห็น:

แสดงความคิดเห็น

สมัครสมาชิก: บทความ (Atom)