Monthly Archives: พฤศจิกายน 2007

หุ่นยนต์อาร์ทรี-ซีชาร์พ (R3-C#)

ไปหน้าแรก | สารบัญ | Laploy.comระเบียนบทความ | บทความจากลาภลอย

ใหม่! ครั้งแรกในประเทศไทย!

หุ่นยนต์ที่ควบคุมด้วย C#.NET สไตล์ OOP

ชีวิตอิสระกับหุ่นยนต์แท้ๆ ในราคาที่ท่านเป็นเจ้าของได้ มาแล้วตามคำเรียกร้อง! …
อาร์ทรี-ซีชาร์พ (R3-C#) หุ่นยนต์ที่จะช่วยให้ท่านเก่ง OOP+C# และได้รับความบันเทิงไปด้วยพร้อมๆ กัน

 ทำให้เพื่อนๆ ของท่านทึ่ง ทำให้แฟนของท่านหวีดร้อง ด้วยหุ่นยนต์ที่น่ารัก-น่ากอด มีขนาดเล็กพอที่จะวางบนฝ่ามือได้ เคลื่อนไหวคล่องกายีในทุกลีลา ค่าตัวไม่แพง

ท่านสามารถเรียนวิธีเขียนโปรแกรมควบคุมหุ่นยนต์ได้ด้วยตนเอง ศึกษาการใช้ภาษา C# ควบคุมการทำงานของหุ่นยนต์ ใช้หลักการ OOP ฝึกเขียนคลาสห่อหุ้มหุ่นยนต์ กำหนด ฟิลด์ พร็อพเพอร์ตี เมธอด ฯลฯ ให้แก่หุ่น

เป็นการเรียนวิธีพัฒนาโปรแกรมเชิงวัตถุโดยการใช้วัตถุจริงๆ ชุดฝึกนี้จะช่วยเปลี่ยนวิธีคิดของท่านให้กลายเป็น OOP ได้อย่างรวดเร็ว ลุ่มลึก

ไม่ต้องรอเข้าคลาสเรียนหุ่นยนต์ หรือซื้อหุ่นยนต์จากต่างประเทศตัวละหมื่นกว่าบาท “ชุดฝึกเพื่อการเรียนรู้ OOP ด้วยตนเอง” R3-C# ราคาถูกกว่าหลายเท่า แต่จะทำให้ท่านเก่ง OOP และหุ่นยนต์ศาสตร์ได้พร้อมๆ กัน

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

หุ่นทำงานได้สองโหมด คือโหมดคนบังคับ (manual) และโหมดคิดเองทำเอง (A.I.) มอเตอร์ทดเฟืองทรงพลัง เดินเหินเพ่นพ่านปีนป่ายสบายใจไม่ท้อแท้ ทำงานต่อเนื่องได้ทั้งวัน 

จากนิยายวิทยาศาสตร์สู่โต๊ะทำงานของท่าน! R3-C# เป็นลูกหลานขนาดจิ๋วของ R2-D2 ในภาพยนตร์เรื่อง Star wars มันคือ “แอสโตรมิชดรอย” (astromech droid คือ astro-mechanic droid หมายถึงหุ่นยนต์ทำหน้าที่ดูแลเครื่องยนต์ เพื่อการเดินทางในอวกาศ) แม้ความสามารถของ R3-C# อาจจะห่างชั้นจากบรรพบุรุษของมัน แต่ผู้เขียนรับประกันได้ว่า ความน่ารักน่าอุ้มของ R3-C# ไม่ด้อยไปกว่า R2-D2 แต่อย่างใด

กรุณาชมวิดีโอสาทิตการทำงานของหุ่นยนต์ R3-C# ได้ในกรอบวิดีโอข้างล่างนี้ 

 คุณสมบัติเด่น

  • เขียนโปรแกรมควบคุมให้กลายเป็นหุ่นอัจฉริยะได้ด้วยตัวของท่านเอง!
  • เคลื่อนที่ได้ซับซ้อนหลากหลาย ท้ายทายสติปัญญา!
  • ไม่ต้องใช้ถ่านไฟฉาย ทำงานได้ทั้งวันอย่างต่อเนื่อง!
  • ชิ้นส่วนไม่ซับซ้อน สร้างง่ายด้วยตนเอง!
  • เหมาะใช้ฝึกคิดเป็น OOP และเรียนเขียนภาษา C# อย่างยิ่ง!
  • ตัวเล็กน่ารักแต่ทรงพลัง เคลื่อนไหวได้แม่นยำ

ดูรายละเอียดเพิ่มเติมและสั่งซื้อได้ ที่นี่

Advertisements

Web Desktop ตอน 1

ไปหน้าแรก | สารบัญ | Laploy.comระเบียนบทความ | บทความจากลาภลอย

Web Desktop ตอน 1
สร้างเว็บแอพลิเกชันยุคใหม่ที่มีการใช้งานแบบเดียวกับโปรแกรมในเดกส์ทอป
ลาภลอย วานิชอังกูร (laploy.com)

 

บทความนี้จะสอนวิธีสร้างหน้าเว็บที่เลียนแบบการทำงานของเดกส์ทอป คือมีฉากหลังของเดกส์ทอป ไอคอน สำหรับเปิดหน้าต่าง และมีหน้าต่างที่สามารถเปิด-ปิดได้ โดยจะสร้างทั้งหมดเป็นออพเจ็กต์ที่สามารถนำกลับมาใช้ใหม่ได้ นำไปเพิ่มเติมความสามารถ หรือเปลี่ยนแปลงคุณสมบัติได้ตามหลักการโปรแกรมวัตถุวิธี (OOP) เตรียมไว้นำไปบูรณาการเป็นเว็บแอพลิเกชันที่มีส่วนติดต่อกับผู้ใช้ซับซ้อนสวยงาม (Rich Internet Application หรือ RIA) เทียบเท่าโปรแกรมในเดกส์ทอป


 หน้าเว็บเมื่อสร้างเสร็จประกอบด้วยเดกส์ทอป หน้าต่าง และไอคอน ทดลองใช้งานได้ที่ laploy.com/actionscript/0501

 

ท่านผู้อ่านที่เพิ่งอ่านบทความนี้เป็นตอนแรกโปรดทราบว่านี่เป็นอิพิโสด 5 ในซีรีส์สอนวิธีพัฒนาเว็บแอพลิเกชันด้วยภาษา ActionScript และ Flex เวอร์ชันใหม่สุด อิพิโสดก่อนหน้านี้สนุกทุกตอน กรุณาสั่งซื้อนิตยสารฉบับย้อนหลังมาอ่านได้เลย รับรองไม่ผิดหวัง

 

การสร้างเดสก์ทอป

โจทย์ของเราคือต้องการสร้างเว็บแอพลิเกชันซึ่งมีคุณสมบัติดังนี้
•    มีฉากหลังของเดสก์ทอป : กำหนดภาพ wallpaper ได้  กำหนดขนาดได้
•    มีไอคอน : กำหนดขนาดได้ กำหนดภาพไอคอนได้ กำหนดตำแหน่งได้ กำหนดหน้าต่างที่จะเปิดได้
•    มีกรอบหน้าต่าง : หดให้เล็กได้ (minimize) คืนขนาดเดิมได้  ปิดได้ ซ้อนทับได้ เปลี่ยนลำดับการเรียงซ้อนทับหน้า-หลังได้เมื่อผู้ใช้คลิกเมาส์

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

กรุณาติดตามอ่านบทความเต็มๆ ในนิตยสาร Windows IT Pro

Flash memory – แผ่นจิ๋วแห่งความจำ

ไปหน้าแรก | สารบัญ | Laploy.comระเบียนบทความ | บทความจากลาภลอย

Flash memory – แผ่นจิ๋วแห่งความจำ

การ์ดความจำจิ๋วขนาดเล็บนิ้วมือนี้มีความเป็นมาอย่างไร และจะมีอนาคตเป็นอย่างไร อะไรคือ NAND อะไรคือ NOR การ์ดแบบ  SD ต่างจาก MMC อย่างไร มันจะมาแทนที่ฮาร์ดดิสก์ได้หรือไม่

ผู้เขียน : ลาภลอย วานิชอักูร      จาก : นิตยสาร WinMag

 

 กรอบรูปแขวนผนังแสดงภาพเคลื่อนไหว (เหมือนในนิยายแฮรี่พ็อตเตอร์)  โน้ตบุ๊คที่ไม่มีฮาร์ดดิสก์ คอมพิวเตอร์มือถือที่มีหน่วยความจำมหาศาล เครื่องความจำสำรองขนาดใหญ่ที่เย็น เงียบ และทำงานรวดเร็ว เทคโนโลยีที่ทำให้ทั้งหมดนี้เป็นความจริงอยู่รอบๆ ตัวของเราเรียบร้อยแล้ว

บทความนี้ผู้เขียนได้รับมอบหมายจากท่าน บก. อานันทยุทธ ให้ไปตรวจสอบข้อมูลล่าสุดของเทคโนโลยีหน่วยความจำแบบแฟลชมาเขียนรับใช้ผู้อ่าน เพราะหน่วยความจำแฟลชขณะนี้มีฟอร์แมตต่างๆ หลากหลายจนน่าสับสน หากนำข้อมูลเหล่านี้มานำเสนอ น่าจะเป็นประโยชน์ตามสมควร

 

ในบทความนี้ผู้เขียนจะเล่าความเป็นมาของหน่วยความจำแฟลช (Flash memory) รูปแบบต่างๆ ของการ์ดหน่วยความจำจิ๋วที่ทำจากแฟลช เช่น CompactFlash, SD, MMC, Memory Stick ฯลฯ หลักการทำงานและ ข้อจำกัดของหน่วยความจำชนิดนี้ ความแตกต่างของแฟลชแบบ NOR และ NAND สิ่งควรพิจารณาในการเลือกใช้ และสุดท้ายจะพูดถึงแนวโน้มของมันในอนาคต

 

แฟลช ยิ่งเล็กยิ่งดี

หน่วยความจำแบบแฟลช เป็นหน่วยความจำของคอมพิวเตอร์ชนิดที่ข้อมูลไม่หายไปแม้ไม่มีไฟเลี้ยง (non-volatile) สามารถลบและเขียนใหม่ได้โดยกรรมวิธีทางไฟฟ้า (บางทีเรียกว่า EEPROM)เป็นเทคโนโลยีที่ใช้เป็นหลักในการ์ดหน่วยความจำ USB drive (หรือบางทีเรียกว่า thumb drive และ memory stick) ซึ่งนิยมใช้เพื่อการเก็บข้อมูลทางดิจิตอลทั่วไป หรือใช้เพื่อโอนถ่ายข้อมูลระหว่างคอมพิวเตอร์ และใช้ในสินค้าดิจิตอลต่างๆ

ปัจจุบันเราจะพบ หน่วยความจำแฟลช ได้ในสินค้าที่ได้รับความนิยมหลายอย่าง เช่นเครื่องเล่น MP3 กล้องดิจิตอล โทรศัพท์เคลื่อนที่ คอมพิวเตอร์แบบพกพา (PDA) และเครื่องเล่นเกมแบบพกพา (เพื่อให้เราบันทึกฉากเกมที่เล่นค้างไว้ได้)

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

 

ความเป็นมาของแฟลช

หน่วยความจำแฟลชเป็นสิ่งประดิษฐ์จากการคิดค้นของ ดร. ฟูจิโอะ มัสซุโอกะ ระหว่างทำงานให้โตชิบาในปีค.ศ. 1984 สาเหตุที่ตั้งชื่อว่า “แฟลช” เพราะเพื่อร่วมงานของ ดร. ฟูจิโอะ ตั้งข้อสังเกตว่า กระบวนการลบข้อมูลของมันชวนให้นึกถึงแสงวาบจากกล้องถ่ายรูป ดร. ฟูจิโอะ นำเสนอรายงานสิ่งประดิษฐ์ใหม่นี้ต่อสมาคม IEEE ในปีเดียวกันและได้รับความสนใจจากบริษัท Intel ซึ่งเห็นศักยภาพของสิ่งประดิษฐ์นี้และต่อมาได้นำมาสร้างเป็นสินค้า แฟลชที่วางตลาดครั้งแรกเป็นชนิด NOR ในปีค.ศ.1988

แฟลชแบบ NOR แม้จะเขียนและลบข้อมูลได้ช้า แต่ก็เหมาะที่จะนำมาใช้แทน ROM ในงานที่ไม่ต้องเขียนหรือลบข้อมูลบ่อยเช่น BIOS ของเครื่องคอมพิวเตอร์ และ firmware ของกล่องเคเบิ้ลทีวี แฟลชแบบ NOR ทนการลบและเขียนข้อมูลได้ 10,000 ครั้ง อุปกรณ์ที่มีคอมพิวเตอร์ฝังในตัวรุ่นแรกๆ จะใช้แฟลชแบบ NOR ทั้งนั้น

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

แฟลชแบบ NAND เหมาะจะใช้ทำหน่วยความจำสำรอง ดังนั้นเราจึงเห็นมีบริษัทผู้ผลิตนำแฟลชแบบ NAND มาทำเป็นการ์ดหน่วยความจำแบบต่างๆ โดยเริ่มจาก SmartMedia (SM) ตามด้วย MultiMediaCard (MMC), Secure Digital (SD), Memory Stick และการ์ด xD-Picture ปัจจุบันมีผู้ผลิตนำ NAND มาสร้างหน่วยความจำรูปแบบใหม่ออกมาเรื่อยๆ เช่น RS-MMC, MiniSD, MicroSD และอื่นๆ อีกมาก

 

การ์ดจิ๋วหลากแบบ

แม้จะมีการ์ดหน่วยความจำแฟลชลักษณะต่างๆ จำนวนมาก แต่ก็ไม่ยุ่งยากต่อการใช้งานนัก เพราะหากเราซื้อเครื่องอ่านการ์ดหน่วยความจำแบบอ่านได้หลายชนิด (multi reader) เราจะอ่านหน่วยความจำเหล่านี้ได้เกือบทุกแบบ เช่น SD, MMC, CompactFlash และ Memory Stick คงมีเพียงไม่กี่แบบที่อ่านไม่ได้ เช่นการ์ดขนาดจิ๋วที่ใช้ในโทรศัพท์มือถือ

 

  • CompactFlash : CompactFlash เป็นหน่วยความจำแฟลชรูปแบบเก่าแก่สุดที่ยังคงใช้กันอยู่ สาเหตุที่ยังไม่ตายน่าจะเป็นเพราะมีใช้มากในกล้องถ่ายรูปดิจิตอลระดับมืออาชีพ CompactFlash มีรูปร่างที่โดดเด่นกว่าหน่วยความจำแฟลชแบบอื่นๆ เพราะมันมีขนาดใหญ่กว่าเพื่อน  CompactFlash แบ่งออกเป็นสองมาตรฐานคือ Type I และ Type II ทั้งสองมาตรฐานมีความกว้างยาวของการ์ดเท่ากันคือ 43×36 มิลลิเมตร สิ่งที่ทำให้ Type II ต่างจาก Type I คือ Type II จะมีความหนากว่า Type I และหลายๆ รุ่นถูกสร้างขึ้นจาก “ไมโครไดร์ฟ” ซึ่งเป็นฮาร์ดดิสก์ขนาดจิ๋ว ไม่ใช่หน่วยความจำแฟลช
  • Memory Stick : Memory Stick เป็นหน่วยความจำแฟลชที่มีต้นกำเนิดจากบริษัท Sony มาตั้งแต่ปี ค.ศ. 1998 รุ่นแรกมีขนาด 50×21.5 มิลลิเมตร ความจุ 128MB ต่อมา Sony ประกาศ Memory Stick แบบใหม่ที่มีความจุสูงขึ้น เรียกว่า Memory Stick Pro โดยมีความจุสูงถึง 4GB และมีความเร็วในการทำงานไม่ต่ำกว่า 15MBs และต่อมาได้เปิดตัว Memory Stick Pro Duo เพื่อใช้ในโทรศัพท์มือถือ (ยี่ห้อ Sony-Ericsson) และเครื่องเล่นเกม PlayStation รุ่นพกพา และเมื่อไม่นานมานี้ Sony ได้ประกาศตัว Memory Stick แบบใหม่ที่มีขนาดเล็กลงไปอีก คือมีขนาดเพียง 15×12.5×1.2 มิลลิเมตร สามารถทำงานได้โดยใช้ไฟเลี้ยงเพียง 3.3 หรือ 1.8โวลต์

 

เล็ก เล็กกว่า เล็กที่สุด

หากท่านเดินชมสินค้าในห้างจำหน่ายสินค้าไอที ท่านจะพบว่ามีหน่วยความจำแฟลชรูปแบบต่างๆ มากมาย อาทิ SD, MMC, RS-MMS, MMC Micro, miniSD และ MicroSD ท่านเคยสงสัยหรือไม่ว่าการ์ดเหล่านี้แตกต่างกันอย่างไร

SD ย่อจาก Secure Digital เป็นหน่วยความจำแฟลชชนิดที่พบเห็นได้ทั่วไป โดยพัฒนามาจาก MMC หรือ MultiMedia Card ที่เริ่มมีใช้มาตั้งแต่ปี ค.ศ. 1997 โดยขนาดของ MMC คือ 24x32x1.5 มิลลิเมตร ส่วน SD จะมีขนาด 32x24x2.1 มิลิเมตร แม้จะมีขนาดแตกต่างกันแต่โครงสร้างการทำงานเหมือนกัน ทำให้อุปกรณ์ที่สนับสนุน SD จะสามารถอ่านเขียน MMC ได้ด้วย

บริษัทที่ใช้ SD และ MMC เป็นหลักได้แก่ โกดัก แคนนอน และซัมซุง โดยใช้ในกล้องดิจิตอล PDA และอุปกรณ์มัลติมีเดียแบบพกพา โดยทั่วไปแล้ว SD จะมีความจุไม่เกิน 2GB แต่ก็มี SD แบบพิเศษที่มีความจุ 4GB หรือมากว่า เช่น SDHC ซึ่งมีขนาดและรูปร่างเหมือนกับ SD แต่มีความจุ 4GB อย่างเช่น SDHC ยี่ห้อ Sandisk

มี MMC รุ่นพิเศษที่มีขนาดเล็กกว่า MMC ธรรมดาครึ่งหนึ่ง เรียกว่า RS-MMC (Reduce size MMC) ซึ่งมีขนาดเพียง 24x16x1.5 มิลลิเมตร

ราวกับต้องการแกล้งให้ผู้ซื้อสับสนยิ่งขึ้นอีก ผู้ผลิตจึงนำเสนอ SD แบบใหม่อีกหลายแบบ เช่น MiniSD ซึ่งมีขนาด 20×21.5×1.4 มิลลิเมตร และยังมีแบบที่มีขนาดเล็กไปกว่านั้นอีกเรียกว่า MicroSD ซึ่งเล็กกว่าเท่าตัว คือมีขนาดหดเหลือเพียงแค่ 11x15x1 มิลลิเมตร MicroSD ส่วนใหญ่จะถูกผลิตขายโดยบริษัท ScanDisc ภายใต้ชื่อทางการค้าว่า TransFlash (ทรานส์แฟลช)

 

 ไดร์ฟขนาดนิ้วมือ

การประยุกต์ใช้งานหน่วยความจำแฟลชที่เราพบเห็นบ่อยที่สุดคือ Thumb drive หรือ USB drive เป็นอุปกรณ์หน่วยความจำที่ถูกสร้างจากชิพคอมพิวเตอร์ขนาดจิ๋วและหน่วยความจำแฟลชแบบ NAND ผนึกรวมกันไว้ในแท่งพลาสติกเล็กๆ มีหัวเสียบ USB เพื่อให้สามารถใช้งานกับ PC และอุปกรณ์ทุกอย่างที่มีขั้วต่อ USB ได้ทันที  โดย Thumb drive รุ่นเก่าๆ ถูกออกแบบมาให้ทำงานกับ USB รุ่น 1.1 ขณะที่ Thumb drive รุ่นใหม่ๆ ถูกออกแบบให้ทำงานได้กับ USB รุ่น 2.0 ซึ่งเร็วกว่า

Thumb drive มีหลายขนาดหลายราคา เริ่มตั้งแต่แบบมีความจุไม่กี่เม็กกะไบต์ ไปจนถึง 8GB และนานวันก็เริ่มมีความจุต่อราคาลดลงเรื่อย ในขณะที่กำลังเขียนบทความนี้ Thumb drive ขนาด 1GB ราคาลดเหลือประมาณ 400 บาท คาดว่าอีกไม่นานเราคงได้ใช้ Thumb drive ขนาด 32GB ที่มีราคาไม่ถึงพันบาท

 

NAND กับ NOR ต่างกันอย่างไร

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

โดยธรรมเนียมปฏิบัติเราจะใช้ NOR เพื่อเก็บคำสั่งที่มีจำนวนไม่มากนักของเครื่องคอมพิวเตอร์พกพาและโทรศัพท์เคลื่อนที่ NOR เหมาะกับงานลักษณะนี้เพราะทำงานเร็ว และสามารถเข้าถึงข้อมูลทีละบิตได้ เราจึงมักเห็น NOR ถูกนำมาใช้ทำหน้าที่เป็น firmware ใช้ทำเป็นคำสั่งบู๊ตระบบปฏิบัติการ และใช้เก็บข้อมูลที่เปลี่ยนแปลงบ่อย

NAND มักถูกใช้เพื่อเก็บข้อมูลปริมาณมากๆ เช่นทำเป็น USB Thumb drive หน่วยความจำในกล้องดิจิตอลและเครื่องเล่น MP3 เนื่องจากมีราคาต่ำกว่า ความจุสูงกว่า เขียนและลบข้อมูลได้เร็วกว่า มีอายุการใช้งานที่ยืนยาวกว่า NAND จึงเหมาะกับการนำมาใช้ในงานที่ต้องอ่านเขียนข้อมูลปริมาณมากๆ เป็นข้อมูลแบบเรียงต่อเนื่องกัน หรือไฟล์ใหญ่ๆ ที่ต้องถูกโหลดจากหน่วยความจำอย่างรวดเร็วและถูกแทนที่ด้วยข้อมูลใหม่อยู่เรื่อยๆ

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

ทั้ง NAND และ NOR มีข้อดีข้อเสียงที่แตกต่างกัน NOR มีข้อดีที่อ่านข้อมูลที่มีอยู่ได้รวดเร็ว แต่มีข้อเสียที่ลบและเขียนข้อมูลใหม่ได้ช้า ขณะที่ NAND มีข้อดีที่ลบและเขียนข้อมูลใหม่ได้เร็วกว่า แต่การเข้าถึงข้อมูลแต่ละไบต์แบบไม่เรียงตามลำดับ (random access) ทำได้ช้ากว่า และ NAND มีแนวโน้มที่จะมีความผิดพลาดในระดับบิตสูงกว่า ทำให้ต้องมีฮาร์ดแวร์หรือซอฟท์แวร์เพื่อตรวจสอบและเฝ้าระวังความผิดพลาด

 

หลักการทำงานของแฟลช

หน่วยความจำแบบแฟลชเก็บข้อมูลไว้ในแถวของทรานซิสเตอร์แบบ floating-gate ที่เรียกว่า “เซล” โดยภายในหนึ่งเซลสามารถเก็บข้อมูลได้หนึ่งบิต หน่วยความจำแฟลช รุ่นใหม่ๆ ใช้เทคโนโลยีการผลิตที่เรียกว่า “เซลหลายระดับ” (multi-level cell หรือ MLC) ทำให้เก็บข้อมูลได้มากกว่าหนึ่งบิตภายในเซลเดียว

การผลิตแฟลชแบบ NOR ทำได้โดยนำทรานซิสเตอร์แบบมอสเฟต (MOSFET) มาใช้สร้างเซล แต่เป็นมอสเฟตพิเศษที่มีขาเกตสองขา (ปรกติทรานซิสเตอร์แบบมอสเฟตจะมีขาเกตเพียงขาเดียว) เกตบนเรียกว่าเกตควบคุม (control gate ต่อไปจะเรียกว่า CG) ซึ่งเหมือนกับทรานซิสเตอร์แบบมอสทั่วไป และมีเกตล่าง เรียกว่าเกตลอยหรือ floating-gate (ต่อไปจะเรียกย่อว่า FG) เกตทั้งสองถูกแยกไว้ไว้ด้วยชั้นบางๆ ของออกไซด์

 

ด้วยเหตุที่ FG และ CG ถูกแยกกันไว้ด้วยชั้นบางๆ จึงมีผลให้ประจุอิเล็กตรอนถูกกักไว้ในบริเวณนั้นได้นานหลายปี หากไม่ถูกป้อนไฟฟ้า เซลของ NOR จะมีตรรกะเป็นจริง (ตรงกับเลข 1 ในระบบเลขฐานสอง) วิธีโปรแกรมให้เซลกลายเป็นศูนย์ทำได้โดยใช้กรรมวิธีต่อไปนี้

 

  • ป้อนไฟฟ้าไปยัง CG
  • อิเล็กตรอนจะไหลระหว่างขาซอร์สและขาเดรน
  • แรงดันที่ขา CG จะเพิ่มขึ้นจนเกิดสนามไฟฟ้าที่แรงมากพอจะกักอิเล็กตรอนไว้ในช่องว่างได้ กระบวนการนี้เรียกว่า “การฉีดอิเล็กตรอนร้อน” (hot-electron injection)

หน่วยความจำแฟลชแบบ NOR มีสองแบบ แบบแรกมีราคาถูก เรียกว่า Single Level Cell เหมาะใช้ในอุปกรณ์ที่มีความจุไม่มากนัก คือประมาณ 16 ถึง 128MB และแบบ Multi Level Cell ที่มีราคาแพงกว่า เหมาะใช้ในอุปกรณ์ที่ต้องการความจุระหว่าง 256MB ถึง 1GB เราอาจพบหน่วยความจำแฟลชแบบ NOR ได้ในอุปกรณ์หลากหลายประเภท เช่น BIOS, PDA, เครื่องพิมพ์, เราเตอร์ และแลนสวิทช์

ส่วนหน่วยความจำแฟลชแบบ NAND เรามักพบในอุปกรณ์พกพาที่มีตัวเชื่อมต่อแบบ USB เช่น USB แฟลชไดร์ฟและการ์ดหน่วยความจำในท้องตลาดจะเป็นแฟลชแบบ  NAND เสียเป็นส่วนใหญ่

 

ข้อจำกัดของแฟลช

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

ข้อจำกัดอีกอย่างของหน่วยความจำแฟลชคือมีอายุใช้งานที่จำกัด โดยสามารถลบและโปรแกรมได้เพียงหนึ่งล้านครั้งเท่านั้น เมื่อคำนวณค่าเฉลี่ยแล้วจะมีระยะการใช้งานประมาณ 51 ปี

 

 

อนาคตของแฟลช

“ปัจจุบันเรามีฮาร์ดดิสก์สองแบบ แบบแรกคือที่พังแล้ว แบบที่สองคือที่กำลังจะพัง” นี่คือคำกล่าวของ Kohut ผู้เชี่ยวชาญด้านคอมพิวเตอร์ของ Lenovo “ภายในห้าปีคอมพิวเตอร์ส่วนใหญ่จะวิ่งระบบปฏิบัติการในหน่วยความจำแฟลช” ผู้เชี่ยวชาญเชื่อว่าหน่วยความจำแฟลชจะถูกนำมาใช้แทนที่ฮาร์ดดิสก์เพราะมีข้อดีกว่าหลายอย่าง เช่นไม่มีชิ้นส่วนที่เคลื่อนไหว จึงทำงานเงียบกว่า มีความร้อนน้อยกว่า ทนทานกว่า มีความเชื่อถือได้สูงกว่า ใช้พลังงานไฟฟ้าน้อยกว่า และมีความเร็วสูงกว่า

ในปัจจุบันนี้คอมพิวเตอร์ที่ใช้หน่วยความจำแฟลชแทนฮาร์ดดิสก์เริ่มปรากฏให้เห็น เช่นคอมพิวเตอร์ PC รุ่น Q30-SSD ของซัมซุงใช้หน่วยความจำแฟลชแบบ SSD ความจุ 32 GB  และคอมพิวเตอร์สำหรับเด็กในโครงการ OLPC ก็ไม่มีฮาร์ดดิสก์เพราะใช้หน่วยความจำแฟลชเช่นกัน แต่คอมพิวเตอร์รุ่นใหม่ๆ ส่วนใหญ่ยังคงใช้ฮาร์ดดิสก์เหมือนเดิม สาเหตุที่ฮาร์ดดิสก์ยังไม่ล้มหายตายจากไปในตอนนี้คือราคาที่ตำกว่ามาก เมื่อคำนวณราคาต่อความจุแล้ว หน่วยความจำแฟลชมีราคาแพงกว่าฮาร์ดดิสก์หลายเท่า

 

เมื่อดูจากแนวโน้มในขณะนี้ ผู้เชี่ยวชาญคาดว่าภายในห้าปี ราคาของหน่วยความจำแฟลชจะใกล้เคียงกับฮาร์ดดิสก์ “ภายในปีหน้าคุณจะเห็นฮาร์ดดิสก์ที่ทำจากแฟลช มีความจุ 60GB แต่มีราคาเพียงสองในสามของตอนนี้” Kohut กล่าว แม้ปัจจุบันจะมีการ์ดหน่วยความจำแฟลชหลายชนิดจนผู้ใช้สับสนแล้ว แต่แน่นอนว่าบริษัทผู้ผลิตจะยังคงนำเสนอเทคโนโลยีแฟลชแบบใหม่ๆ ตามออกมาอีกเพื่อตอบสนองความต้องการของผู้ซื้อที่ไม่มีวันสิ้นสุด

แนะนำ “ชุดฝึกเพื่อการเรียนรู้ OOP ด้วยตนเอง”

ไปหน้าแรก | สารบัญ | Laploy.comระเบียนบทความ | บทความจากลาภลอย

แนะนำ “ชุดฝึกเพื่อการเรียนรู้ OOP ด้วยตนเอง

เรียน OOP จะเครียดทำไม? มาทำโครงงานสนุกๆ กันเถอะ

ผู้เขียนมีความยินดีที่จะแจ้งให้ท่านทราบว่า ผู้เขียนได้จัดทำ “ชุดฝึกเพื่อการเรียนรู้ OOP ด้วยตนเอง” ขึ้น มีหลายชุด เป็นโครงงานที่ผู้เขียนออกแบบขึ้นเอง มีจุดมุ่งหมายให้การเรียนรู้ OOP เป็นไปอย่างเพลิดเพลิน เป็นการฝึกด้วยการทำงานจริง (hand-on practicing) ได้ประสบการตรง เอกสารประกอบโครงงานมีรูปแบบเดียวกับเนื้อหาในหนังสือ “เรียนรู้ด้วยตนเอง OOP C# ASP.NET” เหมือนเป็นภาคต่อของหนังสือฯ

เนื้อหาในหนังสือ “เรียนรู้ด้วยตนเอง OOP C# ASP.NET” ผู้เขียนเน้นที่การสร้างเว็บแอพลิเกชัน ส่วน “ชุดฝึกเพื่อการเรียนรู้ OOP ด้วยตนเอง” จะเน้นที่การสร้างวินฟอร์ม การควบคุมทางไกลผ่านอินเตอร์เน็ต การเขียนคลาสห่อหุ้มฮาร์ดแวร์เพื่อนำไปสร้างออพเจ็กต์ที่นำกลับมาใช้ใหม่ได้ และการเขียนโปรแกรมควบคุมฮาร์ดแวร์ เช่นเซอร์โว จอ LCD และสเต็ปมอเตอร์ ฯลฯ และเต็มไปด้วยเทคนิคต่างๆ ที่ใช้บ่อยในการเขียนโปรแกรมภาษา C# ในงานประจำวัน ผู้เขียนออกแบบชุดฝึกแต่ละชุดอย่างพิถีพิถัน คัดเลือกอุปกรณ์อย่างดี จัดหาและตรวจสอบด้วยตนเองทุกชิ้น จัดทำเอกสารประกอบโครงงานโดยละเอียด มีภาพถ่ายแสดงวิธีประกอบสร้างวงจรและส่วนกลไกทุกขั้นตอน ส่วนอธิบายโค้ดแสดงวิธีประยุกต์ใช้หลักการ OOP โดยละเอียด

ผู้เขียนจะไม่ดูถูกสติปัญญาของท่านด้วยการบอกว่าจัดทำชุดฝึกฯ เหล่านี้เพราะต้องการให้คนไทยเก่ง OOP ไม่ได้หวังผลกำไรใดๆ อันที่จริงผู้เขียนต้องการรายได้ ซึ่งจะนำไปเป็นค่าใช้จ่ายในการทำหนังสือเล่มต่อไป และนำไปใช้เพื่อพัฒนาชุดฝึกฯ ให้ดียิ่งขึ้น (เช่นสั่งทำแผ่นวงจรพิมพ์สำเร็จรูป และจัดทำชุดประกอบสำเร็จ) และจัดทำชุดฝึกฯ ที่ครอบคลุมเนื้อหากว้างขึ้น

กรุณาดูรายละเอียดของ “ชุดฝึกเพื่อการเรียนรู้ OOP ด้วยตนเอง” [ที่นี่]

สร้าง Stack ด้วย C#

ไปหน้าแรก | สารบัญ | Laploy.comระเบียนบทความ | บทความจากลาภลอย

สร้าง Stack ด้วย C#

บทความโดย : ลาภลอย วานิชอังกูร จากนิตยสาร Windows IT Pro ฉบับ July 2007

นักเขียนโค้ดจำนวนมากคิดว่าภาษา C# ใช้เขียนโปรแกรมสร้าง Stack ไม่ได้ การสร้าง Stack จำเป็นต้องเขียนด้วยภาษาซีหรือภาษา C++ เท่านั้น ความเข้าใจเช่นนั้นผิด เราสามารถใช้ภาษา C# สร้าง Stack ได้ และสนุกด้วย

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

จุดสำคัญในเรื่อง Stack คือ เมื่อเราต้องการใช้จาน เราจะต้องหยิบใบบนสุดไปใช้ก่อนเสมอ เราจะไม่พยายามหยิบใบที่อยู่ตรงกลาง หรือใบล่างสุดออกมา (หากต้องการทำเช่นนั้นต้องใช้คิวแบบอื่นที่ไม่ใช้ Stack ) หลักการทำงานเช่นนี้รู้จักกันในนามว่า “เข้าล่าสุดออกก่อน” หรือ LIFO (Last in First Out)

 

การทำงานของ Stack รู้จักกันในนามว่า “เข้าล่าสุดออกก่อน” หรือ LIFO (Last in First Out)เป็นโครงสร้างข้อมูลที่เราพบเห็นทั่วไปในวงการคอมพิวเตอร์

 

Stack เป็นโครงสร้างข้อมูลที่เราพบเห็นทั่วไปในวงการคอมพิวเตอร์ ตัวอย่างการใช้งาน Stack คือ การทำงานของไมโครโปรเซสเซอร์ที่ใช้ Stack เมื่อทำ interrupt และเรียกโปรแกรมย่อย การใช้ Stack เพื่อแก้ปัญหาในการค้นหาข้อมูล และการใช้ Stack ในตัวจัดการหน่วยความจำ (ส่วน CLR) ของ .NET เป็นต้น

 

Stack และ Array
Stack และอาร์เรย์เป็นสิ่งที่คู่กันจนแยกกันไม่ออก เพราะเมื่อเราสร้าง Stack เรามักใช้ array เพื่อเก็บข้อมูลของ Stack สิ่งนี้ทำให้หลายๆ คนสับสน เข้าใจผิดว่า array คือ Stack หรือ Stack คือ array อันที่จริงแล้วไม่ใช่ เพราะองค์ประกอบของ Stack นอกจากจะมี array แล้วยังต้องมีสิ่งอื่นๆ ด้วย เช่น ตัวชี้ยอด Stack ตัวกำหนดขนาดของ Stack และฟังก์ชันเพื่อนำข้อมูลเข้า-ออกจาก Stack เป็นต้น

การนำข้อมูลเข้าไปใส่ใน Stack จะใช้คำสั่ง Push เมื่อ Push แล้วข้อมูลจะถูกนำไปเก็บไว้ใน array และปรับเลื่อนตัวชี้ยอด Stack ขึ้น ในทางตรงกับข้าม การนำข้อมูลออกจาก Stack ใช้คำสั่ง Pop เมื่อ Pop แล้วข้อมูลชิ้นบนสุดจะถูกนำออกไป และตัวชี้ยอด Stack (Stack Pointer ต่อไปจะเรียก SP) จะถูกปรับลดลงหนึ่งหน่วย

ข้อมูลหนึ่งชิ้นของ Stack จะเก็บอยู่ใน Array หนึ่งหน่วยเรียกว่า Array element (ต่อไปจะเรียกย่อว่า AE) AE แต่ละตัวจะมีหมายเลขกำกับเรียกว่า Array Index (ต่อไปจะเรียกย่อว่า AI)

 

คลาส Stack2
ต่อไปเราจะนิยามคลาสชื่อ Stack2 เพื่อสาทิตการสร้าง Stack โดยใช้ภาษา C# โค้ดแบบย่อ (outline) ของคลาส Stack2 เป็นดังนี้

using System;

namespace StackTest
{
    class Stack2
    {
        private int size = 10;
        private int top;
        private string[] value;
        public Stack2(int size)
        private bool isFull()
        public void Push(string x)
        private bool isEmpty()
        public string Pop()
    }
}


จากโค้ดข้างบนจะเห็นว่าคลาส Stack2 มีสมาชิกทั้งสิ้น 8 ตัว สามตัวแรกเป็นฟิลด์สมาชิกของคลาส อีกห้าตัวที่เหลือเป็นเมธอดสมาชิก ขอให้สังเกตว่าฟิลด์ทั้งหมดเป็น instance field หรือ object ฟิลด์ คือเป็นฟิลด์ที่จะใช้เก็บข้อมูลของ object (ซึ่งจะถูกสร้างจากคลาสนี้) ฟิลด์เหล่านี้มี access modifier เป็นแบบ private ทำให้โค้ดภายนอก (หรือ client class คือคลาสที่สร้าง object จากคลาสนี้ ต่อไปจะเรียกย่อว่า CC) ไม่สามารถเข้าถึงได้ เพราะเราไม่ต้องการให้ CC เปลี่ยนแปลงค่าของฟิลด์เหล่านี้

โปรดสังเกตต่อไปอีกว่าเมธอดบางตัวมี access modifier เป็นแบบ private เพราะเป็นเมธอดที่เรานิยามขึ้นเพื่อให้โค้ดภายในคลาสนี้เรียกใช้เท่านั้น ไม่ต้องการให้ CC เรียกใช้ ส่วนเมธอดที่มี access modifier เป็นแบบ public เป็นเมธอดที่เราต้องการให้ CC สามารถเรียกใช้งานได้โดยตรง

สมาชิกแต่ละตัวมีหน้าที่ดังนี้

• size: กำหนดขนาดของ Stack
• top: เป็นตัวชี้ตำแหน่งยอดของ Stack (SP)
• value: เป็น array เก็บข้อมูลของ Stack
• Stack2: คือ method constructor
• isFull: ตรวจสอบว่า Stack เต็มหรือยัง
• Push: ใส่ข้อมูลใหม่
• isEmpty: ตรวจสอบว่า Stack ว่างเปล่าหรือไม่
• Pop: นำข้อมูลออกจาก Stack

ฟิลด์สมาชิกของคลาส Stack2
คลาส Stack2 มีฟิลด์สมาชิกสามตัวโดยมีรายละเอียดดังนี้
private int size = 10;
บรรทัดนี้ประกาศฟิลด์สมาชิกชื่อ size เป็นแบบเลขจำนวนเต็ม size ทำหน้าที่กำหนดขนาดของ Stack เราจะนำค่าของ size ไปกำหนดจำนวน AE ที่เราจะใช้เก็บข้อมูลใน Stack

private int top;



บรรทัดนี้ประกาศฟิลด์สมาชิกชื่อ top เป็นแบบเลขจำนวนเต็ม top ทำหน้าที่เป็นตัวชี้ยอดของ Stack หรือ SP ซึ่งจะเปลี่ยนแปลงตลอดเวลาเมื่อเราใช้งาน Stack

private string[] value;



บรรทัดนี้ประกาศฟิลด์สมาชิกชื่อ value ให้เป็น array แบบ string เราจะใช้ value เป็นที่เก็บข้อมูลของ Stack จำนวน AE ของ value ถูกกำหนดโดยฟิลด์ size

 

เมธอดสมาชิกของคลาส Stack2
ต่อไปนี้ผู้เขียนจะอธิบายโค้ดส่วนเมธอดสมาชิกทั้งห้าตัวของคลาส Stack2 โดยเริ่มจาก Method Constructor (ต่อไปจะเรียกย่อว่า MC) เป็นตัวแรก

        public Stack2(int size)
        {
            this.size = size;
            value = new string[size];
            top = -1;
        }


โค้ดที่เห็นข้างบนคือ MC ของคลาส Stack2 ซึ่งเป็นเมธอดที่ทำงานโดยอัตโนมัติเมื่อเราสร้าง object คลาสในภาษา C# จำเป็นต้องมี MC ทุกคลาส หากเราละไว้ ตัวแปลภาษา C# จะสร้าง MC ให้เราโดยอัตโนมัติ (เป็น MC ว่างๆ ที่ไม่มี argument เรียกว่า default MC)

MC ของคลาส Stack2 มีโค้ดเพียงสามบรรทัด ทำหน้าที่กำหนดค่าเริ่มต้นให้ object ที่เป็น Stack ที่เพิ่งถูกสร้างขึ้นใหม่ โค้ดสามบรรทัดนี้เป็นการเตรียมการให้ Stack พร้อมต่อการถูกนำไปใช้งาน

โค้ดบรรทัดแรกทำหน้าที่นำค่าที่ได้รับจากพารามิเตอร์มากำหนดให้ฟิลด์สมาชิกดังนี้

this.size = size;



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

value = new string[size];

บรรทัดนี้ทำหน้าที่กำหนดความลึกให้ array (กำหนดจำนวน AE) ค่าที่ใช้กำหนดคือ size ซึ่งเป็นตัวแปรพารามิเตอร์ของเมธอดนี้

top = -1;



คำสั่งนี้กำหนดค่า top ให้เป็นลบหนึ่งเพื่อเป็นเครื่องแสดงว่าขณะนี้ Stack ว่างเปล่า ไม่มีข้อมูล เป็นการกำหนดค่าเริ่มต้นให้แก่ SP

 

โค้ดภาษา C# เพื่อการ Push
การ Push ทำได้โดยนำข้อมูลไปใส่ใน array แล้วปรับค่า SP ให้เลื่อนขึ้น แต่ก่อนที่เราจะนำข้อมูลไปใส่ใน array เราจำเป็นต้องตรวจสอบก่อนว่า Stack เต็มแล้วหรือไม่ หาก Stack เต็มแล้วเราจะต้องยกเลิกการ Push

เพื่อให้โค้ดอ่านง่ายเราจึงนิยามโค้ดตรวจสอบการเต็มของ Stack แยกออกมาเป็นอีกเมธอดหนึ่งชื่อ isFull ดังนี้

        private bool isFull()
        {
            if (top < size - 1)
                return false;
            else
                return true;
        }


หัวใจของเมธอด isFull คือคำสั่ง if ทำหน้าที่ตรวจสอบว่าค่าของ SP มีค่าน้อยกว่าจำนวน AE -1 หรือไม่ หากน้อยกว่าแสดงว่า Stack ยังไม่เต็ม หากมากกว่าแสดงว่า Stack เต็มแล้ว สาเหตุที่ค่าของ size ต้องลบด้วยหนึ่งเพราะตัวเลขใน top เป็นตัวเลขที่เราจะนำไปใช้เป็น AI โดยตรง ในภาษา C# ค่า AI จะเริ่มจากศูนย์ จึงทำให้มันมีค่าน้อยกว่าจำนวน AE อยู่ 1 เสมอ

ผลลัพธ์จากการตรวจสอบว่า Stack เต็มหรือไม่ จะถูกส่งกลับไปยังโค้ดที่เรียกเมธอดนี้ด้วยค่าส่งกลับหรือ return value ที่เรากำหนดไว้ว่าเป็น bool หรือบูลีนซึ่งเป็นค่าทางตรรกะที่เป็นไปได้เพียงจริงหรือเท็จเท่านั้น

        public void Push(string x)
        {
            if (!isFull())
            {
                top++;
                value[top] = x;
            }
        }


เมธอด Push ทำหน้าที่ใส่ข้อมูลเข้าไปใน Stack ก่อนใส่ข้อมูลจะเรียกเมธอด isFull เพื่อตรวจสอบว่า Stack เต็มหรือยัง เครื่องหมายตกใจที่อยู่หน้าเมธอดใส่ไว้เพื่อกลับค่าตรรกะ ทำให้คำสั่ง if มีความหมายว่า “หาก Stack ยังไม่เต็มจงทำคำสั่งในวงเล็บปีกกา”

หาก Stack เต็มเมธอดจะหยุดการทำงานไปโดยไม่ดำเนินการใดๆ หากพบว่า Stack ยังไม่เต็มเราจะเพิ่มค่าของ top ขึ้นหนึ่งเพื่อเลื่อน SP ไปยัง AE ที่อยู่เหนือข้อมูลล่าสุดของ Stack จากนั้นนำข้อมูลที่ได้รับมาในพารามิเตอร์ x ไปใส่ไว้ในตำแหน่งนั้น

 

โค้ดภาษา C# เพื่อการ Pop
การ Pop มีการทำงานตรงข้ามกับ Push การ Pop ทำได้โดยอ่านข้อมูลตัวบนสุดของ Stack แล้วปรับตำแหน่งยอดของ Stack ให้ลดลงหนึ่ง แต่ก่อนจะ Pop ได้เราจะต้องแน่ใจเสียก่อนว่าใน Stack มีข้อมูลเหลืออยู่ให้ Pop เราจึงต้องนิยามเมธอดชื่อ isEmpty เพื่อใช้ตรวจสอบว่า Stack ว่างเปล่าหรือไม่ โดยมีโค้ดดังนี้

        private bool isEmpty()
        {
            if (top == -1)
                return true;
            else
                return false;
        }


จากโค้ดข้างบนจะเห็นว่าการตรวจทำได้ง่ายมากเพียงแค่ตรวจสอบค่าของ top ว่าเป็น -1 หรือไม่ สาเหตุที่เป็นเช่นนั้นเพราะ AE แรก (ล่างสุดของ Stack) ย่อมเป็นตำแหน่งที่ศูนย์เสมอ และทุกครั้งหลักจากที่เรา Pop แล้ว เราจะลดค่า top ลงหนึ่ง ด้วยเหตุนี้เมื่อเรา Pop ถึงข้อมูลตัวสุดท้ายค่า top จึงเปลี่ยนจากศูนย์เป็น -1 ไปโดยอัตโนมัติ

        public string Pop()
        {
            string retVal = "-";
            if (!isEmpty())
            {
                retVal = value[top];
                top--;
            }
            return retVal;
        }


โค้ดที่เห็นข้างบนคือเมธอด Pop ซึ่งทำหน้าที่นำข้อมูลออกจาก Stack คำสั่งบรรทัดแรก (ภายในวงเล็บปีกกา) ทำหน้าที่ประกาศตัวแปรท้องถิ่นชื่อ retVal เพื่อใช้เก็บพักข้อมูลที่จะส่งไปให้ CC เรากำหนดค่าเริ่มต้นให้ retVal เป็นตัวเคาะวรรค (white space) เพื่อส่งค่านี้กลับไปในกรณีที่ Stack ว่างเปล่า

คำสั่ง if ทำหน้าที่ตรวจสอบว่า Stack ว่างเปล่าหรือไม่ ขอให้สังเกตว่าเราต้องใช้เครื่องหมายตกใจเพื่อกลับตรรกะของ isEmpty คำสั่งบรรทัดนี้จึงมีความหมายว่า “ถ้า Stack ไม่ว่างเปล่า” หากการตรวจสอบได้ผลลัพธ์เป็นจริง (คือว่างเปล่า) เมธอดนี้จะจบการทำงานโดยส่งค่าตัวเคาะวรรคกลับไปเพื่อแสดงว่า Stack ว่าง

หากตรวจสอบแล้วพบว่าใน Stack มีข้อมูล โปรแกรมจะอ่านค่าจาก array มาใส่ในตัวแปร retVal เพื่อเตรียมส่งกลับให้ผู้เรียกเมธอด ถัดมาเราลดค่าฟิลด์ top ลงหนึ่งเพื่อปรับลดตัวชี้ยอด Stack ลงหนึ่งตำแหน่ง หากข้อมูลที่กำลัง Pop เป็นข้อมูลตัวสุดท้ายใน Stack ค่าของ top ก่อนปรับลดจะเป็นศูนย์ เมื่อโปรแกรมทำคำสั่ง top – – ค่าของ top จะกลายเป็น -1 ซึ่งเป็นเครื่องแสดงว่าบัดนี้ Stack ว่างเปล่าแล้ว

โปรแกรมทดสอบคลาส Stack2
เมื่อนิยามคลาส Stack2 เสร็จแล้วเราต้องสร้างโปรแกรมทดสอบหรือ client class โดยเขียนโค้ดสร้าง object Stack แล้วทดลอง Push และ Pop ข้อมูลดู โค้ดสำหรับทดสอบเป็นดังนี้

            // my custom stack test
            Stack2 myStack = new Stack2(5);
            myStack.Push("one");
            myStack.Push("two");
            myStack.Push("three");
            textBox1.Text = "My custom Stack\r\n";
            textBox1.Text += "==============\r\n";
            for (int i = 0; i < 3; i++)
                textBox1.Text += myStack.Pop() + "\r\n";


บรรทัดแรกสร้าง object และกำหนดให้มีตัวแปรอ้างอิง object ชื่อ myStack ซึ่งเป็น object ที่ถูกสร้างจากคลาส Stack2 ที่เรานิยามไว้ ให้สังเกตว่าเราใส่ค่า 5 เป็น argument ให้ MC ซึ่งจะถูกนำไปใช้กำหนดขนาดของ Stack

สามบรรทัดถัดไปเราทดลอง Push ข้อมูลลง Stack เป็นข้อความ one, two และ three ตามลำดับ ดังนั้น one จะอยู่ล่างสุดและ three จะอยู่บนสุดใน Stack

สองบรรทัดถัดไปแสดงข้อความว่า My custom Stack และขีดเส้นใต้ และสุดท้ายเราจัดตั้งคำสั่งวนซ้ำ (for loop) เพื่อทำงานซ้ำสามหน โดยแต่ละหนจะ Pop ค่าออกจาก Stack แล้วนำค่าที่ได้มาแสดงใน TextBox1

 

สร้าง Stack แบบ object จากคลาสของ .NET
ในคลาส Stack2 เรานิยามคลาส Stack ขึ้นด้วยตนเองทั้งหมด แต่ในการใช้งานจริงเราไม่จำเป็นต้องทำเช่นนั้นก็ได้ เพราะ .NET Framework จัดเตรียมคลาส Stack ไว้ให้แล้วใน namespace System.collections ที่เราสามารถนำมาใช้งานได้ทันทีดังนี้

            // .NET object stack test
            Stack myStack = new Stack();
            myStack.Push(11);
            myStack.Push(12);
            myStack.Push(13);
            textBox1.Text = ".NET Object Stack\r\n";
            textBox1.Text += "==============\r\n";
            foreach (Object obj in myStack)
                textBox1.Text += obj + "\r\n";

จะเห็นว่าวิธีเรียกใช้งานก็คลายๆ คลาส Stack2 ที่เรานิยามไว้ แต่มีข้อดีกว่าคือมีเมธอดเตรียมไว้ให้เราใช้มากมาย เช่นเมธอด Peek ทำหน้าที่ตรวจสอบข้อมูลตัวบนสุดของ Stack และเมธอด Clone ทำหน้าที่ทำสำเนา Stack เป็นต้น

 

สร้าง Stack แบบ Generic จากคลาสของ .NET
คลาส Stack2 มีข้อเสียร้ายแรงคือรับข้อมูลได้เพียงแบบ string เท่านั้น หากต้องการให้รับข้อมูลแบบอื่นเช่น int หรือ float เราต้องนิยามคลาสใหม่อีกหลายๆ คลาสเท่าจำนวนชนิดข้อมูลที่ต้องการ ซึ่งไม่ใช่วิธีทำงานที่ดีนัก ส่วนคลาส Stack ในหัวข้อก่อหน้านี้รับข้อมูลแบบ object จึงสามารถทำงานกับข้อมูลชนิดใดก็ได้ แต่ก็มีข้อเสียจะเกิดการ boxing และ unboxing เพื่อแปลงชนิดข้อมูลอยู่ตลอดเวลา จึงนับว่าเป็นวิธีที่ไม่มีประสิทธิภาพเช่นกัน

โชคดีใน .NET Framework เวอร์ชัน 2.0 ขึ้นไปมี Generic ที่ช่วยให้เรากำหนดชนิดข้อมูลที่จะใช้กับคลาสให้เป็น type อะไรก็ได้ ทำให้เรารับมือกับปัญหาเรื่อง type ได้สะดวกมาก และที่สะดวกมากยิ่งขึ้นไปอีกคือใน .NET Framework เวอร์ชัน 2.0 ขึ้นไปมีคลาส Stack แบบ Generic ไว้ให้แล้วใน namespace System.collections.Generic เราจึงสามารถนำมาใช้งานได้ทันทีดังนี้

            // .NET generic stack test
            Stack<string> myStack = new Stack<string>();
            myStack.Push("c1d0c2c1");
            myStack.Push("b7d8e0c3d5c2b9");
            myStack.Push("c5d4e9b9a8d5e8");
            textBox1.Text = ".NET Generic Stack\r\n";
            textBox1.Text += "==============\r\n";
            foreach (string number in myStack)
                textBox1.Text += number + "\r\n";
        }  

สรุปเรื่อง Stack ในภาษา C#
การสร้างและใช้งาน Stack ในภาษา C# ทำได้ง่ายมากเพราะในคลาสไลบรารีของ .NET Framework มีคลาส Stack มาให้แล้ว ในบทความตอนนี้ผู้เขียนแสดงวิธีนิยามคลาส Stack ขึ้นเอง เพียงเพื่อสาทิตวิธีทำงานภายในของ Stack

ผู้เขียนจัดทำโค้ดตัวอย่างประกอบบทความนี้ไว้เป็นไฟล์ชื่อ StackInCSharp.zip (ภายในเป็น solution ที่สร้างจาก MS Visual Studio .NET 2005) ท่านสามารถดาวน์โหลดได้จากเว็บไซต์ของผู้เขียนที่ http://www.laploy.com (เลือกหัวข้อ download) หากท่านมีข้อสงสัยใดๆ โปรดโพสคำถามไว้ในเว็บบอร์ดที่เว็บไซต์ดังกล่าว