Monthly Archives: พฤษภาคม 2008

ระเบียนบทความ

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

ระเบียนบทความ

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

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

 


  

สร้างกราฟอย่างง่ายใน ASP.NET   
ฝึกหัดสร้างกราฟเส้นอย่างง่ายในหน้าเว็บแบบ ASP.NET โดยใช้ control สำเร็จรูปชื่อ WebChart สอนวิธีเขียนโปรแกรมภาษา C# เพื่อกำหนดค่าของกราฟ เป็นแบบฝึกที่ละขั้น (step by step approach) อย่างง่ายที่สุดสำหรับมือใหม
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!636.entry

 


  
  

เชื่อมต่อฐานข้อมูล Oracle   
ฐานข้อมูลสำหรับ WebApp นอกจาก Microsoft SQL แล้วหน่วยงานต่างๆ ยังนิยมใช้ Oracle 10g กันมาก เนื่องจากมีท่านผู้อ่านสอบถามมาในกระดานข้อความ http://www.laploy.com/gbook เกี่ยวกับเรื่องนี้มาก ผู้เขียนตัดสินใจเขียนรับใช้เป็นบทความนี้ โดยจะสอนวิธีเซตค่าให้หน้าเว็บ ASP.NET 2.0 เพื่อเชื่อมต่อกับฐานข้อมูล Oracle 10g โดยใช้ control ของ .NET Framework ชื่อ SqlDataSource
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!661.entry

 


 

วัดอุณหภูมิและความชื้นด้วย C# ตอน 1   
เขียนโปรแกรมภาษา C# ใน .NET Framework นิยามคลาสวัดอุณหภูมิและความชื้นที่นำไปใช้ได้ทั้งใน WinForm และ WebForm
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!709.entry

 

 

วัดอุณหภูมิและความชื้นด้วย C# ตอน 2 (ตอนจบ)   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!876.entry

 


  

สร้างหุ่นยนต์ใหม่จากซากไดร์ฟเก่า   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!755.entry
ดัดแปลงดิสก์ไดร์ฟที่เสียแล้วนี้ให้เป็นหุ่นหนูน้อย (สับเซทของหุ่นหนู)พื้นฐานการใช้งานสเต็ปปิ้งมอเตอร์ การประกอบโครงสร้างหุ่น และการใช้คอมพิวเตอร์ในการควบคุมหุ่น

 


  

สร้าง Hash table ( ตารางแฮช ) ด้วยภาษา C++ และจาวา ตอน 1   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!807.entry
ตารางแฮช หรือ Hash table คือโครงสร้างข้อมูลชนิดหนึ่ง นักเขียนโปรแกรมสามารถนำตารางแฮช มาใช้เก็บข้อมูลขนาดใหญ่ได้อย่างมีประสิทธิภาพ ในบทความนี้คุณจะได้เรียนวิธีสร้างและประยุกต์ใช้งาน

 

  

สร้าง Hash table ( ตารางแฮช ) ด้วยภาษา C++ และจาวา ตอน 2   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!808.entry

 


  

หน่วยความจำ ชนิดของข้อมูล และการระบุตำแหน่ง   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!841.entry
ถ้าคุณพยายามค้นหาชื่อของคุณที่อยู่ในรายชื่อหนึ่งล้านชื่อ คุณต้องพยายามมากสุดกี่ครั้ง ถ้าตอบว่าหนึ่งล้านครั้งละก็ผิด ไม่ใกล้เคียงเลยด้วยซ้ำ อันที่จริงแล้วคำตอบคือ 20 แต่คุณจะต้องจัดรายชื่อให้เป็นโครงสร้างที่ค้นหาได้ง่าย

 


  

Windows Mobile 6   
WM6 มีอินเตอร์เฟสที่สวยทันสมัยเข้ากับ Windows Vista และทำงานเร็วขึ้นมาก เพียงเท่านี้จะคุ้มค่ากับการอัพเกรดหรือไม่ การปรับปรุงคุณสมบัติต่างๆ แม้จะไม่หวือหวา แต่เมื่อมองโดยรวมแล้ว WM6 น่าใช้กว่า WM5 จริงหรือ
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!894.entry

 


  

Gostai บริษัทหุ่นยนต์ผู้ท้าชนไมโครซอฟต์   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!964.entry
บริษัทเล็กๆ ที่เพิ่งก่อตั้งได้ปีเดียว มีพนักงานไม่ถึงสิบคน มีไม้ตายอะไรจึงกล้าท้าชนยักษ์ใหญ่?

 

สร้าง Stack ด้วย C#   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!970.entry
นักเขียนโค้ดจำนวนมากคิดว่าภาษา C# ใช้เขียนโปรแกรมสร้าง Stack ไม่ได้ การสร้าง Stack จำเป็นต้องเขียนด้วยภาษาซีหรือภาษา C++ เท่านั้น ความเข้าใจเช่นนั้นผิด เราสามารถใช้ภาษา C# สร้าง Stack ได้ และสนุกด้วย

 


   

Flash memory – แผ่นจิ๋วแห่งความจำ   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!976.entry
การ์ดความจำจิ๋วขนาดเล็บนิ้วมือนี้มีความเป็นมาอย่างไร และจะมีอนาคตเป็นอย่างไร อะไรคือ NAND อะไรคือ NOR การ์ดแบบ  SD ต่างจาก MMC อย่างไร มันจะมาแทนที่ฮาร์ดดิสก์ได้หรือไม่

 


   

Multi-touch screen ลาก่อนแป้นพิมพ์-เมาส์ สวัสดี!จอหลากสัมผัส    
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1034.entry
อหลากสัมผัสเป็นนวัตกรรม มันแตกต่างจากจอภาพระบบสัมผัสธรรมดาที่เราคุ้นเคยกัน จอภาพระบบสัมผัสธรรมดาอย่างที่เห็นตามตู้เอทีเอ็ม ตู้ให้ข้อมูลตามห้างสรรพสินค้า (kiosk) หรือแม้แต่ในเครื่องคอมพิวเตอร์พกพา  (PDA) รับรู้การกดได้เพียงจุดเดียวเท่านั้น แต่จอหลากสัมผัสรับรู้การกดพร้อมๆ กันได้หลายจุด (มากกว่า 50 ตำแหน่ง)  นอกจากนั้นมันยังสามารถแยกแยะอากัปกริยาของนิ้วและความหนักเบาในการกดได้อีกด้วย ยิ่งไปกว่านั้น จอชนิดนี้สามารถ “เห็น” สิ่งที่ถูกวางไว้บนมัน และมีปฏิสัมพันธ์กับอุปกรณ์พกพาดิจิตอลที่มันเห็นได้

 


    

ActionScript 3 ตอน 1 สร้างเว็บลวดลายจัด   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1087.entry
ยุคการสร้าง application ในเว็บมาถึงนานแล้ว นานจนกระทั่งคำว่า client/server ไม่มีใครพูดกันอีก เพราะใครๆ ก็สร้าง web application (webapp) ที่เป็น client/server จนเป็นเรื่องธรรมดา แต่ webapp วันนี้จะไม่เป็นเพียง form ที่มีช่องให้กรอกมีปุ่ม submit ให้กดส่งข้อมูลอีกต่อไป webapp สมัยใหม่ต้องมีลูกเล่นมากมีลวดลายจัด

 


    

นิยายนักสืบตอน 1 : Hackarmy-A   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1109.entry
“ดูเหมือนว่า…” คำพูดของผมหายไปเฉยๆ จนต้องกลืนน้ำลายแล้วกระแอมก่อนจะพูดต่อไปว่า “file server ของคุณได้กลายเป็นแหล่งเผยแพร่ซอฟท์แวร์เถื่อนไปแล้วนะครับ”

 


    

   
    

มาทำลายคอมพิวเตอร์กันเถอะ!!  
ขั้นตอนง่ายๆ และประหยัด ที่คุณก็ทำเองได้ เพื่อทำให้คอมพิวเตอร์ของคุณมีประสิทธิภาพต่ำกว่าศูนย์
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1120.entry
ความสุขของคุณคือการเห็นคอมพิวเตอร์ชำรุด – การได้แบกคอมฯ ไปซ่อมที่ร้าน – การได้จ่ายเงินค่าซ่อมให้ช่าง เป็นอย่างนั้นใช่หรือไม่? ถ้าใช่! โปรดอ่านบทความนี้ เพราะผู้เขียนจะแนะนำเคล็ดลับต่างๆ เพื่อให้คุณสมหวังได้ไม่ยาก!

 

   

สร้าง IrDA ด้วยตนเอง   
สร้างตัวรับส่งอินฟราเรดโดยใช้อุปกรณ์หาง่ายราคาถูก เพื่อเชื่อมต่อคอมพิวเตอร์ของคุณกับอุปกรณ์ไฮเทคแบบไร้สาย
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1168.entry
สอนวิธีสร้าง IrTxRx ขึ้นใช้เอง โดยใช้วัสดุเหลือใช้รอบๆ ตัว หรือซื้อจากร้ายขายอะไหล่อิเล็กทรอนิกส์ วงจรไม่ซับซ้อน (ออกแบบโดย Alain Gailland) ใช้อุปกรณ์ไม่กี่ชิ้น ใครก็ตามที่บัดกรีเป็นก็สามารถทำได้เอง และจะแสดงตัวอย่างการประยุกต์ใช้งาน โดยการสาทิตวิธีเชื่อมต่อ Pocket PC กับเครื่องพีซีเพื่อทำ ActiveSync แบบไร้สาย และสุดท้ายจะแสดงวิธีเชื่อมต่อกับโทรศัพท์มือถือเพื่อเข้าอินเตอร์เน็ตผ่านระบบ GPRS

 


    

ชนิดข้อมูลในภาษา C# (ตอน 1)   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1176.entry
อ่านเรื่องซับซ้อนก้าวหน้ากันมามากแล้ว วันนี้มาดูเรื่องพื้นฐานใกล้ๆ ตัวที่ต้องพบเจอกันทุกวันบ้าง ในบทความชุดนี้จะนำเสนอเรื่องของหน่วยความจำ การอ้างแอดเดรส และชนิดข้อมูลในภาษา C# กันหน่อย เพราะเป็นเรื่องสำคัญในการเขียนโปรแกรมจัดการข้อมูลและโครงสร้างข้อมูลทุกแบบ

 


    

ชนิดข้อมูลในภาษา C# (ตอน 2)  
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1192.entry
เรากำหนดขนาดของหน่วยความจำที่ต้องการจองได้โดยเลือกกลุ่มชนิดของข้อมูล จากนั้นก็ต้องเลือกชนิดของข้อมูลที่อยู่ในกลุ่มนั้น ว่าชนิดใดจึงเหมาะกับข้อมูลที่จะจัดเก็บ

 


    

ชนิดข้อมูลในภาษา C# (ตอนจบ)   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1199.entry
การอ้างหน่วยความจำหรือ memory addressing หมายถึงการระบุตำแหน่งของหน่วยความจำ (แรมในคอมพิวเตอร์) เพื่อบอกให้ตัวแปลภาษารู้ว่าเราจะเอาอะไรไปเก็บที่ไหน เนื่องจากภาษา C# มีลักษณะ managed code ทำให้ปรกติเราจะไม่เขียนอ่านหน่วยความจำโดยตรง แต่จะให้ CLR และระบบปฏิบัติการจัดการให้โดยอัตโนมัติ ที่ผู้เขียนหยิบยกเรื่องนี้มาพูด เพราะการการรู้ว่าการอ้างหน่วยความจำเป็นอย่างไร ก็เป็นสิ่งที่น่าสนใจและจะช่วยให้เห็นภาพรวมของโครงสร้างข้อมูลได้ดี

 

นิยายนักสืบ ตอน : วิชามาร Social Engineering    
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1209.entry
หากผมล้วงงูพิษหรือระเบิดออกมาวางบนโต๊ะ ปฏิกิริยาของผู้เข้าประชุมคงไม่แตกต่างจากตอนนี้ เพราะทุกคนทำท่าทางเลิกลักส่งเสียงพึมพำ เว้นแต่คุณลีลาวดีที่ไม่ส่งเสียงอะไร นั่งนิ่งหน้าถอดสี

 


    

แจกโค้ด C# วันสงกรานต์ 2551   
วันนี้ฤกษ์งามยามดี วันสงกรานต์ ปี พ.ศ. 2551 อะไรจะดีสำหรับผมไปกว่าการเขียนรับใช้ท่านผู้อ่าน โดยแจกโค้ดแบบ Tricks & Tips ที่น่าสนใจและมีประโยชน์
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1212.entry
เชื่อมสองเทเบิ้ลภายในหนึ่งดาต้าเซต  /  สร้างวิวภายในดาต้าเทเบิ้ล /  โหลดไฟล์ XML เข้าสู่ดาต้าเซต  /  การสร้างเท็กซ์ไฟล์  /  การอ่านเท็กซ์ไฟล์  /  การแทรกข้อมูลเข้าสู่เท็กซ์ไฟล์  /   เซฟรูปภาพสามฟอร์แมต  /  จับข้อมูลใส่ DataGridView   /   อัพเดตฐานข้อมูลจาก DataGridView /  ยืนยันการลบ  /  กำหนดความกว้างโดยอัตโนมัติให้ DataGridView  /  กำหนดความกว้างโดยอัตโนมัติให้ DataGridView  /  เลือกและทำแถบเน้นให้ DataGridView

 


    

สกิมเมอร์ : เทคโนโลยีโฉดเพื่อทรชน   
ว้ายร้ายยุคไฮเทคปล้นเงินของคุณได้โดยไม่ต้องชักมีดหรือปืน อาวุธเพียงอย่างเดียวของมันคือสกิมเมอร์
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1250.entry
สกิมเมอร์ (skimmer เครื่องดูดหรือกวาดข้อมูล) คือสิ่งประดิษฐ์ที่คนร้ายสร้างขึ้นโดยนำเครื่องอ่านแถบแม่เหล็ก วงจรถอดรหัส และวงจรหน่วยความจำมาประกอบเข้าด้วยกัน สกิมเมอร์มีหลายขนาดตั้งแต่เท่ากับกล่องใส่รองเท้า ไปจนถึงขนาดเท่าซองบุหรี่ที่คนร้ายซ่อนไว้ในอุ้งมือได้ ใช้พลังงานจากแบตเตอรี่จึงสามารถพกพาได้สะดวก

 

 

    

คิวสวยด้วย C#  
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1259.entry
ในบทความตอนที่แล้วผู้เขียนเสนอวิธีสร้าง Stack ด้วยภาษา C# บทความตอนนี้ก็เป็นเรื่องของโครงสร้างข้อมูลอีกเช่นกัน แต่คราวนี้เราจะมาดูวิธีสร้าง “คิว” (Queue) โดยใช้ภาษา C# กันบ้าง สิ่งที่ท่านจะได้เรียนรู้จากบทความตอนนี้คือ
    * หลักการทำงานของโครงสร้างข้อมูลแบบคิว
    * วิธีนิยามคลาสคิวด้วยภาษา C#
    * วิธีทำ constructor overloading
    * วิธีใช้งาน generic queue ของ .NET Framework

 


    

ActionScript ตอน 2 สร้างลูกศรหันตามเมาส์   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1287.entry
เขียนโปรแกรมภาษา ActionScript 3.0 สร้างออพเจ็กต์ลูกศรที่หันหัวชี้ไปตามการเคลื่อนไหวของเมาส์พอยน์เตอร์ ได้ผลลัพธ์เป็น Flash Movie ไว้ใช้งานในหน้าเว็บ

 


    


    

มาสร้างแผงเสียบ USB กันเถอะ   
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1326.entry
สร้างแผงเสียบ USB ติดตั้งด้านหน้าเครื่องเพื่ออำนวยความสะดวกในการใช้งานอุปกรณ์ USB

 

    

เขียนโค้ดให้สนุกในยุค 64 บิต  
เชิญท่องแดนหฤหรรษ์แห่งการเขียนโปรแกรมในซีพียูแบบ 64 บิต
http://thai-cs.spaces.live.com/blog/cns!4D52C1812766D2D7!1356.entry
บัดนี้ซีพียู 64 บิตกลายเป็นซีพียูมาตรฐานไปแล้ว จึงได้ฤกษ์อันเป็นมงคล ที่เหล่าโปรแกรมเมอร์ จะอพยพจากโลก 32 บิต ไปเขียนโค้ดแบบ 64 บิตกันเสียที ผู้เขียนขอเสนอตัวเป็นมัคคุเทศก์ นำท่านไปเที่ยวชมโมเดลการเขียนโปรแกรม 64 บิต ทั้งแบบอินเทลและแบบ AMD ความเป็นมาของซีพียู 64 บิต สาเหตุที่ทำให้ AMD สามารถสร้างซีพียูเลียนแบบอินเทลได้และแซงหน้าไปในที่สุด  ตำนานสถาปัตยกรรม อิทาเนียม อันลือลั่นของอินเทล ที่ AMD เยาะว่าไม่ช้าจะสิ้นชื่อ

Advertisements

เขียนโค้ดให้สนุกในยุค 64 บิต

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

  • วันจันทร์ที่ 15 ตุลาคม พ.ศ. 2550
  • บทความโดย : ลาภลอย วานิชอังกูร (laploy.com)
  • ลงพิมพ์ใน : นิตยสาร WinMag

เขียนโค้ดให้สนุกในยุค 64 บิต
เชิญท่องแดนหฤหรรษ์แห่งการเขียนโปรแกรมในซีพียูแบบ 64 บิต

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

หากท่านต้องการทราบคำตอบว่า อะไรคือสถาปัตยกรรม x86-64, IA32, IA64, EM64, Intel64 และ AMD64 โมเดลเขียนโปรแกรมของซีพียู 64 บิตจาก AMD และอินเทล เหมือนหรือแตกต่างกันหรือไม่ ซอฟต์แวร์เดิมแบบ 16 และ 32 บิตจะยังทำงานกับซีพียู 64 บิตได้หรือไม่ นักเขียนโปรแกรมต้องปรับตัว หรือเปลี่ยนวิธีเขียนโปรแกรมอย่างไรบ้าง จึงจะสามารถสร้างซอฟต์แวร์แบบ 64 บิตได้ ขอเชิญพบคำตอบเหล่านี้ และหัวข้อที่น่าสนใจอื่นๆ อีกมากได้ในบทความนี้

 

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

ระบบปฏิบัติการสำหรับซีพียู 32 บิตอ้างหน่วยความจำได้สูงสุดเพียง 4 GB และคำนวณเลขทศนิยมได้ไม่เร็วนัก งานที่ต้องใช้หน่วยความจำมากๆ และต้องคำนวณเลขทศนิยมอย่างหนัก เช่น เกมและโปรแกรมสร้างภาพสามมิติจึงทำงานได้อย่างจำกัด ส่วนระบบปฏิบัติการซีพียู 64 บิต อ้างหน่วยความจำได้สูงสุด 16 เทราไบต์ เรียกใช้งานรีจิสเตอร์ 64 บิตและรีจิสเตอร์คำนวณเลขทศนิยม 128 บิตได้เต็มที่ ทำให้เกมและโปรแกรมสร้างภาพสามมิติทำงานเร็วขึ้นมาก

 

ที่มาของตัวเลข 64

หน่วยต่ำสุดของข้อมูลที่คอมพิวเตอร์ประมวลผลได้คือหนึ่งบิต แทนค่าได้สองค่าคือศูนย์และหนึ่ง เหมือนสวิทช์หนึ่งตัวที่อาจอยู่ในตำแหน่งปิดหรือปิด เนื่องจากบิตเดียวไม่สามารถแทนข้อมูลอะไรได้มากนัก การประมวลผลจึงใช้หน่วยไบต์ หรือแปดบิต สาเหตุที่เป็นแปดบิต (แทนที่จะเป็นเจ็ดหรือเก้าบิต) เพราะในระบบเลขฐานสองการเพิ่มหลักของตัวเลขจะเพิ่มแบบยกกำลังสอง (คือเพิ่มจาก 2 เป็น  4,8,16,32,64,128 ฯลฯ)

การพิจารณาว่าไมโครโปรเซสเซอร์มีขนาดกี่บิต ให้ดูจากขนาดของหน่วยประมวลผลทางตรรกะและคณิตศาสตร์ หรือ ALU (Arithmetic Logic Unit) ไมโครโปรเซสเซอร์ ตัวแรกของบริษัทอินเทล ชื่อ 4004 มี ALU ขนาดสี่บิต ออกจำหน่ายในปี ค.ศ. 1971 แต่ไมโครโปรเซสเซอร์ที่ได้รับความนิยมนำไปใช้ในไมโครคอมพิวเตอร์คือ 8088 ที่ออกจำหน่ายในปี 1979 ไมโครโปรเซสเซอร์ 8088 เป็นซีพียูแบบกึ่งแปดบิตกึ่งสิบหกบิต เพราะ ALU มีขนาด 16 บิต รีจิสเตอร์ภายในก็เป็นสิบหกบิต แต่บัสข้อมูลมีขนาดแปดบิต

ไมโครโปรเซสเซอร์ 8088

 

นิทานอินเทล

บริษัทอินเทลออกจำหน่ายไมโครโปรเซสเซอร์ 8086 ซึ่งเป็นซีพียูขนาด 16 บิตตัวแรกในปี 1978 และตามด้วย 80386 ซึ่งเป็นซีพียูขนาด 32 บิตในปี 1986 ปัจจุบันอินเทล เรียกสถาปัตยกรรมนี้ว่า IA-32  กลายเป็นรากฐานของโมเดลการเขียนโปรแกรมมาตลอดสิบสองปีไม่เปลี่ยนแปลง ซีพียูรุ่นต่อมาไม่ว่าจะเป็น  486, เพนเทียม, เพนเทียมทู, เพนเทียมทรี, Celeron, แพนเทียมโฟร์, Xenon, แพนเทียมเอ็ม ฯลฯ ล้วนใช้โมเดลเดียวกันนี้

จุดเด่นของสถาปัตยกรรม IA-32 คือบัสข้อมูลภายนอกและภายในเป็น 32 บิตล้วน สามารถอ้างหน่วยความจำได้ต่อเนื่องเป็นผืนเดียวกัน (flat memory space) และมีกลไกที่ช่วยให้ใช้ฮาร์ดดิสก์เป็นหน่วยความจำเสมือนได้ง่าย ถึงสามารถรันโปรแกรมและอ้างถึงข้อมูลที่มีขนาดใหญ่กว่าปริมาณของแรมในเครื่องได้ อินเทลมีซีพียูแบบ IA-32 บิตที่ได้รับความนิยมจำนวนมาก เช่น Celeron, Pentium 4, Dual-Core, Core2Duo และ Xenon

    
สถาปัตยกรรมของซีพียู 386DX จะเห็น ALU บัสข้อมูลภายนอกและภายในเป็น 32 บิตล้วน  (กดเพื่อขยาย)

 


สถาปัตยกรรม อิทาเนียม จะเห็นว่าบัสภายในมีขนาด 64, 128 และ 256 บิต

64 บิตสไตล์อินเทล

อินเทลเริ่มพัฒนาซีพียู 64 บิตมาตั้งแต่ปี 1994 โดยทำงานร่วมกับบริษัท ฮิวเลต เพคการ์ด (HP) เพื่อสร้างโปรเซสเซอร์สำหรับเครื่องแม่ข่าย ช่วงแรกเรียกสถาปัตยกรรมนี้ว่า IA-64 แต่ต่อมาเปลี่ยนเป็น อิทาเนียม สถาปัตยกรรมนี้แตกต่างจากสถาปัตยกรรม IA-32 มาก มีนวัตกรรมโดดเด่นหลายอย่าง มีรีจิสเตอร์เลขจำนวนเต็ม 128 ตัว รีจิสเตอร์เลขทศนิยม 128 ตัว และรีจิสเตอร์คำสั่งกระโดด 64 ตัว อ้างตำแหน่งหน่วยความจำแรมได้ 16 เทราไบต์ โปรเซสเซอร์มีหน่วยทำงานภายในภายในสามสิบหน่วย แต่ละหน่วยทำงานเป็นอิสระจากกันและทำงานพร้อมๆ กันได้ แบ่งออกเป็นกลุ่มต่างๆ ดังนี้

* หน่วยประมวลผลทางคณิตศาสตร์และตรรกะ (ALU) หกหน่วย * หน่วยเลขจำนวนเต็มสองหน่วย * หน่วยสำหรับเลื่อนบิตหนึ่งหน่วย * หน่วยแคชข้อมูลสี่หน่วย * หน่วยมัลติมีเดียหกหน่วย * หน่วยเลื่อนบิตแบบขนาดสองหน่วย * หน่วยคูณแบบขนานหนึ่งหน่วย * หน่วยนับหนึ่งหน่วย * หน่วยประมวลผลเลขทศนิยมแบบสะสมสองหน่วย * หน่วยประมวลผลเลขทศนิยมแบบจิปาถะสองหน่วย * หน่วยจัดการคำสั่งกระโดดสามหน่วย

 

อิทาเนียมรุ่นที่ออกขายก่อนปี 2006 มีฮาร์ดแวร์ที่สนับสนุนสถาปัตยกรรม IA-32 เพื่อให้ใช้งานได้กับแม่ข่ายรุ่นเก่า ในชิพรุ่นหลังปี 2006 เช่น อิทาเนียม II : Montecito อินเทลได้เพิ่มคุณสมบัติใหม่บางอย่างเช่น สนับสนุนการทำงานแบบหลายเทรธ แบบใหม่ที่มีประสิทธิภาพมากขึ้น และคุณสมบัติที่ทำให้วิ่งซอฟต์แวร์ระบบปฏิบัติการมากกว่าหนึ่งระบบได้พร้อมกันได้ ปัจจุบันมีระบบปฏิบัติการที่ใช้กับอิทาเนียมได้หลายตัว เช่น Windows Server 2003, Windows Vista, Linux, HP-UX, และ OpenVMS

แม้จะเริ่มออกจำหน่ายตั้งแต่ปี 2001 แต่ซีพียูอิทาเนียมไม่เคยได้รับความนิยมในโลกของเดสก์ทอปเลย ส่วนมากจะถูกบริษัทผู้ผลิตคอมพิวเตอร์นำไปใช้สร้างเครื่องแม่ข่ายระดับสูง (high-end server) ปัจจุบันอินเทลเปลี่ยนชื่อ อิทาเนียมทู โดยตัดคำว่า ทู ออก อิทาเนียมถูกผลิตออกมาแล้วหลายรุ่นดังนี้

•    อิทาเนียม : Merced ออกจำหน่ายปี 2001
•    อิทาเนียม ทู : McKinley ออกจำหน่ายปี 2004
•    อิทาเนียม ทู : Madison 9M ออกจำหน่ายปี 2005
•    อิทาเนียม ทู : Montecito เป็นอิทาเนียม ที่มีจำหน่ายในปัจจุบัน

อิทาเนียมทู McKinley

 

เทพนิยาย  AMD

ยุคก่อนเครื่องเลียนแบบไอบีเอ็มพีซี (IBM PC Compatible หรือเครื่องโคลน) ลูกค้ารายใหญ่ที่ซื้อชิพ 8086 ของอินเทลมีไอบีเอ็มเจ้าเดียว ในปี 1982 ไอบีเอ็มออกนโยบายจัดซื้อให้ซื้อจากผู้ผลิตอย่างน้อยสองราย บีบให้อินเทล ต้องจับมือกับบริษัท AMD ( AMD  Advance Micro Device) และเปิดเผยเทคโนโลยีการผลิตชิพแก่ AMD 

เมื่อเครื่องโคลนครองตลาดคอมพิวเตอร์ส่วนบุคคลในปี 1986 ไอบีเอ็มไม่ใช่ลูกค้าสำคัญอีกต่อไป บริษัทอินเทลจึงยกเลิกสัญญาเปิดเผยเทคโนโลยีผลิตชิพ แต่ AMD ก็สามารถผลิตชิพรุ่นต่อมาที่เข้ากันได้กับชิพของอินเทล ช่วงแรก AMD ตั้งชื่อชิพโดยใช้เลขอนุกรมตรงกับอินเทล (คือ 8088, 8086, 80286 และ 80386) ในปี 1993 อินเทลเปลี่ยนวิธีตั้งชื่อซีพียูจากตัวเลขไปเป็นตัวอักษร (คือ 80586 เป็นอินเทลเพนเทียม)  AMD ไม่สามารถใช้ชื่อนี้ได้จึงเปลี่ยนไปใช้ชื่อที่นำหน้าด้วยตัว K โดยกลุ่ม K6 เทียบได้กับเพนเทียม ถึงเพนเทียมทรี และ K7 เทียบได้กับ เพนเทียม 4

    
    AMD K6-III

 

64 บิต ของดีของ  AMD

ชิพไมโครโปรเซสเซอร์หลักของบริษัท AMD ในปัจจุบันคือสถาปัตยกรรม K8 (หรือ ADM64) เป็นซีพียูแบบ 64 บิต มีผลิตออกจำหน่ายหลายตระกูลดังนี้

•    Athlon 64 : เป็น K8 แบบคอร์เดียว มีทั้งแบบเดกส์ท็อปและโน้ตบุ๊ก  เป็นซีพียูหลักของ AMD
•    Athlon 64×2 : เป็น K8 แบบสองคอร์
•    Opteron :  เป็น K8 รุ่นที่ออกมาก่อนเพื่อน เพื่อให้นำไปสร้างคอมพิวเตอร์แม่ข่าย
•    Sempron 64 : เป็น K8 รุ่นราคาสบายกระเป๋า มีทั้งแบบเดกส์ท็อปและโน้ตบุ๊ก มาแทนที่ซีพียู Duron เพื่อต่อกรกับ Celeron D 64 ของอินเทล
•    Turion 64 : เป็น K8 รุ่นกินพลังงานน้อย เหมาะใช้ทำโน้ตบุ๊ก

นอกจาก K8 แล้ว AMD ยังซุ่มพัฒนาสถาปัตยกรรม K9 มาตั้งแต่ปี 2001 โดยตั้งใจจะให้เป็นสถาปัตยกรรมซึ่งจะมาแทนที่ K8 แต่โครงการนี้ถูกล้มเลิกไปในปี 2006 เพราะ AMD ต้องการผลักดันโครงการที่ใหม่กว่า นั่นคือ K10 (ข้ามจาก K8 ไปเป็น K10 เลย)  AMD แถลงว่าจะนำ Phenom ซีพียู 64 บิตแบบสี่คอร์ (ซึ่งจะเป็นซีพียูที่ใช้สถาปัตยกรรม K10 ตัวแรก) ออกวางตลาดได้ช่วงปลายปีนี้ (พ.ศ. 2550)

 

ไฟล์ภาพ 003.png : สถาปัตยกรรม K8

 

อินเทล 64 ตัวทำเงิน

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

•    Core 2 Duo : ซีพียู 64 บิตสองคอร์สำหรับเดสก์ทอป เป็นซีพียูหลักของอินเทล
•    Celeron D 64 : ซีพียู 64 บิตราคาย่อมเยา มีทั้งแบบเดสก์ทอปและโน้ตบุ๊ก
•    Centrino Duo และ Pro : ซีพียู 64 บิตสองคอร์เพื่อใช้สร้างโน้ตบุ๊ก
•    Core 2 Quad : ซีพียู 64 บิตสี่คอร์สำหรับแม่ข่ายหรือเดสก์ทอปที่ต้องการซีพียูพลังสูงเป็นพิเศษ
•    Xeon : ซีพียู 64 บิตมีทั้งแบบสองและสี่คอร์สำหรับแม่ข่ายระดับสูงสุด

 Xeon แบบสี่คอร์

 

เรื่องไส้ๆ ของ K8

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

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


 

 

เทียบเท่าถึงปู่ทวด

ลองมาดูรีจิสเตอร์ A หรือแอคคิวมูเลเตอร์ซึ่งเป็นรีจิสเตอร์หลักของซีพียูกันหน่อย จากรูปจะเห็นว่าหากเขียนโปรแกรมแบบ 64 บิต รีจิสเตอร์นี้จะมีชื่อว่า RAX มีขนาด 64 บิต หากเขียนโปรแกรมแบบ 32 บิต รีจิสเตอร์นี้จะมีชื่อว่า EAX มีขนาด 32 บิต หากเขียนโปรแกรมแบบ 16 บิต รีจิสเตอร์นี้จะมีชื่อว่า AX มีขนาด 16 บิต และหากเขียนโปรแกรมแบบ 8 บิต รีจิสเตอร์นี้จะกลายเป็นรีจิสเตอร์ขนาด 8 บิตสองตัว คือ AH และ AL

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

ขนาดของแอคคิวมูเลเตอร์ในสถาปัตยกรรม K8

 

ตัวอย่างโปรแกรม K8

ต่อไปมาดูคำสั่งภาษาแอสเซมบลีของ K8 ในการบวกเลขจำนวนเต็มสองจำนวน เลขจำนวนแรกเก็บอยู่ในรีจิสเตอร์ A และตัวที่สองอยู่ใน B เราจะนำค่าใน A ไปบวกกับ B ผลลัพธ์จะถูกนำไปเก็บไว้ใน B

ก่อนการบวก A และ B มีค่าดังนี้ RAX = 0002_0001_8000_2201 RBX = 0002_0002_0123_3301

•    บวกแบบ 64 บิต : ADD RBX,RAX      ผลลัพธ์: RBX = 0004_0003_8123_5502
•    บวกแบบ 32 บิต : ADD EBX,EAX      ผลลัพธ์: RBX = 0000_0000_8123_5502
•    บวกแบบ 16 บิต : ADD BX,AX           ผลลัพธ์: RBX = 0002_0002_0123_5502
•    บวกแบบ 8 บิต :   ADD BL,AL           ผลลัพธ์: RBX = 0002_0002_0123_3302

โปรดสังเกตว่าการบวกแบบ 64 บิตให้ผลลัพธ์ครบสมบูรณ์ ส่วนการบวกแบบ 32 บิตๆ ที่63 ถึง 32 ถูกถมด้วยศูนย์และไม่ถือเป็นส่วนหนึ่งของผลลัพธ์ การบวกแบบ 16 บิตๆ ที่ 63 ถึง 16 ถูกกันไว้และไม่นับว่าเป็นส่วนหนึ่งของผลลัพธ์ และการบวกแบบ 8 บิตๆ ที่ 63 ถึง 8 ถูกกันไว้และไม่นับว่าเป็นส่วนหนึ่งของผลลัพธ์ จะเห็นว่าคำสั่งบวกแบบ 64 บิตไม่แตกต่างจากการเขียนโปรแกรมแบบ 8, 16, หรือ 32 บิต มากนัก

 

 
ซีพียู Opteron แบบสี่คอร์

 

คำสั่งที่เปลี่ยนไปใน AMD64

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

 

  • เพิ่ม REX : REX คือเป็นโค้ดชุดใหม่เอี่ยม ใช้เติมด้านหน้าคำสั่งเดิมเพื่อการระบุรีจิสเตอร์และโอเปอเรนด์ขนาด 64 บิต
  • เปลี่ยนแปลง Segment-Override Prefixes (SOP) : เมื่อเขียนโปรแกรมแบบ 64 บิต SOP  จะไม่มีผลกับ DS, ES, SS และ CS แต่มีผลกับ FS และ GS
  • การบังคับขนาดโอเปอเรนด์ : ขนาดโดยปริยายของโอเปอเรนด์ในการเขียนโปรแกรมแบบ 64 บิต คือ 32 บิต แต่สามารถใช้ REX เปลี่ยนเป็น 64 บิตได้
  • การเติมศูนย์นำหน้าผลลัพธ์ : อย่างที่เห็นในหัวข้อที่แล้ว เมื่อเราดำเนินการแบบ 32 บิต เลขศูนย์จะถูกเติมไว้ด้านหน้าของผลลัพธ์จนครบ 64 บิต
  • การบังคับขนาดตำแหน่งหน่วยความจำ : เมื่อเขียนโปรแกรมแบบ 64 บิตขนาดของตำแหน่งหน่วยความจำจะเป็น 64 บิต แต่เราสามารถใช้โค้ด 67h เพื่อเปลี่ยนเป็น 32 บิตได้
  • ค่าป้อนสด (Displacement และ Immediate) : ยังคงเป็น 32 บิตเท่าเดิม ยกเว้นคำสั่ง MOV ที่มีเพิ่มให้ใส่เป็น 64 บิตได้ด้วย
  • การเติมศูนย์นำหน้าตำแหน่งหน่วยความจำ : เมื่อทำการคำนวณตำแหน่งหน่วยความจำแบบ 16 และ 32 บิต เลขศูนย์จะถูกเติมด้านหน้าจนครบ 64 บิต
  • การอ้างตำแหน่งหน่วยความจำแบบใหม่ : วิธีอ้างตำแหน่งหน่วยความจำแบบสัมพันธ์โดยใช้ค่าในรีจิสเตอร์ชี้คำสั่งบวกกับดีสเพลสเมนท์ ได้ผลลัพธ์เป็นตำแหน่งหน่วยความจำขนาด 64 บิต
  • สแต็กขนาด 64 บิต : เพิ่มคำสั่งที่เกี่ยวข้องกับรีจิสเตอร์ชี้สแต็กขนาด 64 บิต (RSP)
  • คำสั่งกระโดด (branch) : คือคำสั่งในกลุ่มที่เปลี่ยนแปลงค่าของรีจิสเตอร์ RIP เช่น CALL, JMP และ RET ถูกนิยามการทำงานใหม่แตกต่างจากเดิมเล็กน้อย (ทั้งแบบกระโดดใกล้และกระโดดไกล)
  • การสลับสแต็ก : การสลับสแต็กแบบอัตโนมัติถูกเปลี่ยนแปลงให้สนับสนุน 64 บิต
  • คำสั่ง NOP : ออพโค้ด 90h ในเลกาซีคือคำสั่ง XCHG EAX, EAX ถูกเปลี่ยนเป็นไม่ทำอะไรเลยจริงๆ (เหมือนในสมัยแปดบิต)
  • เปลี่ยนโค้ด INC และ DEC : สองคำสั่งนี้เดิมใช้เพิ่มค่ารีจิสเตอร์ แต่ใน K8 โค้ดกลุ่มนี้ถูกนำไปใช้ทำอย่างอื่น ออพโค้ดของสองคำสั่งนี้จึงถูกเปลี่ยนใหม่
  • คำสั่ง MOVSXD : เป็นคำสั่งใหม่ ทำหน้าที่คล้ายคำสั่ง MOVSX เดิม
  • ยกเลิกคำสั่ง : มีคำสั่งหลายคำสั่งถูกยกเลิกไป เช่น AAA, INTO, LES ฯลฯ หากนำไปใช้จะเกิดเออเรอร์ตอนแปลโปรแกรม สาเหตุที่ยกเลิกเพราะบางคำสั่งออพโค้ดถูกนำไปใช้ทำอย่างอื่น (เช่นนำไปใช้ร่วมกับ REX) ขณะที่บางคำสั่งถูกยกเลิกเพราะเข้ากันไม่ได้กับสถาปัตยกรรม 64 บิต
  • เก็บไม่ให้เหลือ : คำสั่ง FXSAVE คำหน้าที่นำข้อมูลในรีจิสเตอร์ทั้งหมดไปเก็บในหน่วยความจำ และคำสั่ง FXRSTOR ทำหน้าที่นำข้อมูลกลับคืนมาใส่ในรีจิสเตอร์

 
Athlon 64 บิตแบบสองคอร์

 

 

เขียนโปรแกรม 64 บิตใน อิทาเนียม

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

•    โปรเทคโหมด : เป็นการทำงานแบบโปรเทคโหมดภายใต้ซีพียูอิทาเนียม
•    เรียลโหมด : เป็นการทำงานแบบเรียลโหมดภายใต้ซีพียูอิทาเนียม
•    เวอร์ช่วลโหมด : เป็นการทำงานแบบเวอร์ช่วลโหมดภายใต้ซีพียูอิทาเนียม
•    โหมดอิทาเนียม : เป็นการทำงานแบบอิทาเนียมเต็มรูปแบบ

อิทาเนียมสามารถสลับการทำงานระหว่าง 32 และ 64 บิตได้ตลอดเวลาโดยอาศัยคำสั่งพิเศษและอินเตอร์รัพต์ โดยขณะทำงานอยู่ในโหมด 64 บิตจะใช้คำสั่ง br.ia เพื่อเปลี่ยนไปเป็นแบบ 32 บิต และคำสั่ง jmpe เพื่อเปลี่ยนไปเป็น 64 บิตขณะทำงานแบบ 32 บิต

 

อิทาเนียมทู

 

รีจิสเตอร์ของอิทาเนียม

รีจิสเตอร์ของอิทาเนียมที่เกี่ยวข้องกับนักเขียนโค้ดซึ่งเขียนโค้ดระดับต่ำ อย่างภาษาแอสเซมบลีหรือภาษาซี (รวมถึง C++) มีดังนี้

•    รีจิสเตอร์ใช้งานทั่วไป (GR): จำนวน 128 ตัวขนาด 64 บิต ใช้งานอเนกประสงค์
•    รีจิสเตอร์เลขทศนิยม (FR): จำนวน 128 ตัวขนาด 82 บิต ใช้คำนวณเลขมีทศนิยม
•    รีจิสเตอร์พยากรณ์ (PR): จำนวน 64 ตัวขนาด 1 บิต ใช้พยากรณ์การกระโดด
•    รีจิสเตอร์กระโดด (BR): จำนวน 8 ตัวขนาด 64 บิต ใช้ในการกระโดด
•    รีจิสเตอร์ตัวชี้คำสั่ง (IP): จำนวน 1 ตัวขนาด 64 บิต ใช้ชี้คำสั่ง
•    รีจิสเตอร์สร้างเฟรม (CFM): จำนวน 1 ตัวขนาด 38 บิต ใช้บอกสภาพสแต็กเฟรม
•    รีจิสเตอร์ประยุกต์ (AR): จำนวน 128 ตัวขนาด 64 บิต กลุ่มรีจิสเตอร์ใช้งานเฉพาะกิจ
•    รีจิสเตอร์เฝ้าระวัง (PMD): ขนาด 64 บิต ใช้ตรวจสอบประสิทธิภาพของฮาร์ดแวร์
•    รีจิสเตอร์มาสก์ (UM): ขนาด 6 บิต ทำหน้าที่เหมือนแฟลก
•    รีจิสเตอร์ระบุโปรเซสเซอร์ (CPUID): ขนาด 64 บิต ใช้บอกข้อมูลจำเพาะของชิพ

ในการเขียนโค้ดแบบอิทาเนียม 64 บิตเต็มยศรีจิสเตอร์เหล่านี้จะถูกใช้ทั้งหมด และเพื่อให้เข้ากันได้กับการเขียนโค้ดในสถาปัตยกรรม IA-32 เดิม รีจิสเตอร์เหล่านี้จะถูกจำลอง (register mapping) เป็นรีจิสเตอร์ของแพนเทียม 32 บิต

 

 

 

 

ตัวอย่างโปรแกรมอิทาเนียม

ไม่ใช่แค่ใน C# และจาวาเท่านั้นที่มีเนมสเปส แต่ในภาษาแอสเซมบลีของอิทาเนียมก็มีเนมสเปสกับเขาด้วยเหมือนกัน แต่ความหมายคนละเรื่องกันเลย เนมสเปสในอิทาเนียมมีสามตัวคือ ซิมโบล (Symbols สัญลักษณ์) รีจิสเตอร์ และนีโมนิก ลองดูตัวอย่างโค้ดต่อไปนี้

1    r5:
2    movl r4=r5#
3    ld4 r28=[r8]
4    add r9=2,r1

จากโค้ดข้างบน คำสั่งบรรทัดที่หนึ่งเรากำหนดลาเบลชื่อ r5 นี่คือตัวอย่างการใช้ซิมโบล บรรทัดต่อมาคำสั่ง movl ทำหน้าที่นำข้อมูลในหน่วยความจำตำแหน่งที่ระบุโดย r5 มาใส่ไว้ในรีจิสเตอร์ r4 คำสั่งบรรทัดที่ 3 โหลดข้อมูลสี่ไบต์มาใส่ใน r28 นี่คือตัวอย่างของการอ้างถึงรีจิสเตอร์ บรรทัดที่ 4 นำ 2 มาบวกกับ r1 แล้วนำไปใส่ใน r9 คำสั่ง add คือนีโมนิก ซึ่งอาจะเป็นคำสั่งของอิทาเนียมจริงๆ หรืออาจเป็นพซิวโดออพ (Pseudo-op หมายถึงคำสั่งเทียมที่จะถูกนำไปแปลเป็นภาษาเครื่องอีกที) ก็ได้

 

ภาษาแอสเซมบลี 64 บิต

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

 

C++ 64 บิต

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

char buf[9];
sprintf(buf, "%p", pointer);

โค้ดสองบรรทัดนี้หากทำงานใน 32 บิตจะปรกติดี แต่เมื่อทำงานแบบ 64 บิตจะเกิดเออเรอร์แบบ บัฟเฟอร์ล้น เพราะขนาดของพอยน์เตอร์โตกว่าเดิม หรืออย่างโค้ดต่อไปนี้

size_t ArraySize = N * 4;
intptr_t *Array = (intptr_t *)malloc(ArraySize);

อย่างนี้ก็จะเออเรอร์เช่นกันเพราะจองเนื้อที่อาร์เรย์ไว้ไม่พอ วิธีแก้คือใช้ฟังก์ชัน sizeof() ดังนี้

size_t ArraySize = N * sizeof(intptr_t);
intptr_t *Array = (intptr_t *)malloc(ArraySize);

ถ้าเขียนแบบนี้โปรแกรมจะทำงานได้ถูกต้องทั้งใน 32 และ 64 บิต ต่อไปลองดูปัญหาที่เกิดจากการเลื่อนบิต

ptrdiff_t SetBitN(ptrdiff_t value, unsigned bitNum) {
  ptrdiff_t mask = 1 << bitNum;
  return value | mask;
}

ฟังก์ชันนี้หาก bitNum เท่ากับ 32 เมื่อทำงานแบบ 32 บิต mask จะเป็นศูนย์ แต่ถ้าทำงานแบบ 64 บิต mask จะไม่ใช่ศูนย์ปัญหาเกิดจากเลข 1 ที่ใช้ทำ mask มีจำนวนไบต์ต่างจาก ptrdiff_t  วิธีแก้ง่ายๆ คือทำแปลงไทป์ให้ตรงกันแบบนี้ จะทำงานได้ถูกต้องทั้งใน 32 และ 64 บิต

ptrdiff_t mask = ptrdiff_t(1) << bitNum;

 

จาวา 64 บิต

นักเขียนโค้ดภาษาจาวาสบายกว่าเพื่อน เพราะไม่ต้องแก้ไขโปรแกรมแม้แต่บรรทัดเดียว (อันที่จริงไม่ต้องแม้แต่คอมไพล์โปรแกรมใหม่เสียด้วยซ้ำ) โปรแกรมเดิมที่เคยเขียนไว้จะสามารถทำงานได้ทั้งในซีพียู 64 บิตของอินเลทและ AMD   ที่เป็นไปได้เช่นนั้นเพราะโปรแกรมที่สร้างด้วยภาษาจาวาจะอยู่ในสภาพของ “จาวาไบต์โค้ด” เมื่อนำไปรันในคอมพิวเตอร์เครื่องใด จาวารันทามน์จะคอมไพล์โปรแกรมให้กลายเป็นภาษาเครื่อง (native code) ซ้ำอีกครั้ง เมื่อเป็นเช่นนี้คลาสที่นิยามไว้จึงทำงานได้ทั้งในสภาพแวดล้อม 32 และ 64 บิต

ตอนนี้มีจาวารันทามน์หลายแพลตฟอร์ม เช่น ในระบบปฏิบัติการโซลาริสสำหรับซีพียู SPARC 64 บิต ใน Windows Server 2003 ที่ใช้ซีพียู Opteron และในลินุกซ์เรดแฮต ที่ใช้ Opteron เช่นกัน ส่วนจาวารันทามน์ที่ทำงานได้ในซีพียูอิทาเนียมตอนนี้ยังไม่เห็นแม้แต่เงา

       

 

ดอตเน็ต 64 บิต

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

มีข้อยกเว้นอยู่บ้างเหมือนกัน เช่นในกรณีที่เรียกใช้ไลบรารี Win32 แบบอินเตอร์ออพ (interop) หากนำโปรแกรมแบบนี้ไปรันในแพลตฟอร์ม 64 บิต รันทามน์ของดอตเน็ตจะแจ้งข้อความเออเรอร์ว่าลบรารี Win32 แต่การแก้ไขทำได้ไม่ยาก เพียงนำซอร์สโค้ดของไลบรารี Win32 มาคอมไพล์ใหม่ให้เป็น Win64 แค่นั้นก็เรียบร้อย (แต่ถ้าท่านไม่มีซอร์สโค้ดของไลบรารี Win32 ก็ถือว่าประสบเภทภัยมากกว่าวาสนา) มีดอตเน็ตเฟรมเวิร์คพร้อมเครื่องเมื่อพัฒนาโปรแกรมรูปแบบในสถาปัตยกรรม K8 และอิทาเนียม

 

ActionScript 64 บิต
ภาษา ActionScript เวอร์ชันสาม (AS3) ที่ใช้ร่วมกับ Flex 2 ถือว่าเป็นภาษาที่มีกลุ่มผู้ใช้มาก เป็นภาษา OOP คล้าย C# และจาวา แต่คอมไพล์ออกมาเป็น .swf จึงทำงานได้กับตัวเล่นแฟลช 9 ได้ ทำให้นักเขียนโค้ดเขียนสคริปต์ฝั่งไคลเอนได้อย่างหวือหวา ผู้เขียนโค้ดภาษา AS3 ก็เช่นเดียวกับนักเขียนโค้ดดอตเน็ตและจาวา คือไม่ต้องกังวลกับการอพยพจาก 32 ไปยัง 64 บิต เพราะรันทามน์ในตัวเล่นแฟลชจะเป็นผู้จัดการทุกอย่างให้ทั้งหมด ปัญหาหลักคือขณะนี้บริษัท Adobe ยังสร้างตัวเล่นแฟลชที่ทำงานในบราวเซอร์ 64 บิตไม่เสร็จ (ตัวปลักอิน) และยังไม่มีกำหนดว่าจะเสร็จเมื่อใด

        

 

อนาคตสดใสในโลก 64 บิต

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

เมื่อมีผู้ใช้ชิพ 64 บิตมากขึ้นอีกไม่นานเราคงได้เห็นซอฟต์แวร์ 64 บิตพันธุ์แท้ มันจะเป็นซอฟต์แวร์ที่ทรงพลังอย่างที่ไม่เคยมีมาก่อน โปรแกรมที่จะได้รับประโยชน์จากการเขียนโค้ดแบบ 64 บิต คือโปรแกรมที่กินแรงซีพียู และต้องการหน่วยความจำมากๆ เช่นโปรแกรมสร้างภาพสามมิติและเกม ลองนึกภาพดูว่า เกมเอนจิน (game engine)อย่าง Half-Life2 หรือ Oblivion หากถูกนำมาสร้างใหม่เป็นแบบ 64 บิตจะดีเด่นเพียงใด แค่คิดก็ตื่นเต้นจนอดใจรอไม่ไหวแล้ว

เกี่ยวกับผู้เขียน
ลาภลอย วานิชอังกูร
  : เป็นผู้เชี่ยวชาญด้าน .Net C# และ OOP ทำงานด้านคอมพิวเตอร์มานานกว่ายี่สิบปี เขียนโปรแกรมคล่องหลายภาษา เคยทำงานด้านคอมพิวเตอร์ที่ประเทศสหรัฐอเมริกา ประเทศเยอรมัน และประเทศสวิส เคยเป็นครูสอนวิชาคอมพิวเตอร์ เคยเป็นบรรณาธิการนิตยสารคอมพิวเตอร์ มีผลงานบทความ และตำราคอมพิวเตอร์จำนวนมาก ปัจจุบันทำหน้าที่เป็นผู้ให้คำปรึกษาด้าน .Net ให้แก่บริษัท Accenture ท่านสามารถติดต่อผู้เขียนได้ที่ กระดานบทความในเว็บไซต์ laploy.com และที่อีเมล laploy@gmail.com

    

มาสร้างแผงเสียบ USB กันเถอะ

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

มาสร้างแผงเสียบ USB กันเถอะ

สร้างแผงเสียบ USB ติดตั้งด้านหน้าเครื่องเพื่ออำนวยความสะดวกในการใช้งานอุปกรณ์ USB

 

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

 

บทความโดย : ลาภลอย วานิชอังกูร www.laploy.com

จากนิตยสาร CompToday

 

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

วิธีแก้ปัญหาที่ง่ายที่สุดคือซื้อ USB hub แต่จะเสียเงินทำไม ในเมื่อบนเมนบอร์ดก็มีพอร์ท USB มาให้ฟรีอยู่แล้ว ผมจึงพยายามหาซื้อแผงด้านหน้าที่มีช่อง USB สี่ช่อง แต่ก็หาซื้อไม่ได้ เห็นมีขายแต่แผงซึ่งมีช่องเสียบ USB สองช่อง Firewire สองช่อง ช่องเสียบ SATA หนึ่งช่อง ฯลฯ ซึ่งไม่ตรงกับความต้องการ เมื่อหาซื้อไม่ได้ก็ต้องสร้างขึ้นเอง ก็ดีเหมือนกัน เพราะผมชอบการประดิษฐ์และดัดแปลงเครื่องคอมพิวเตอร์อยู่แล้ว

สิ่งที่ผมจะทำคือนำฝาปิดช่องไดร์ฟด้านหน้า (คือชิ้นพลาสติกแบนๆ ยาวๆ ที่ใช้ปิดช่องว่างสำหรับติดตั้งซีดีรอมไดร์ฟด้านหน้าเครื่อง) มาเจาะรู้ใส่ช่องเสียบ USB ผลลัพธ์ที่ได้เป็นอย่างที่เห็นในรูปที่ 1

 

แผงเสียบ USB ด้านหลังแบบสองช่อง (ดูรูปที่ 2) เป็นอุปกรณ์ที่หาซื้อได้ตามศูนย์ไอทีทั่วไป แผงนี้จะมีหัว USB แบบ A ตัวเมียติดอยู่สองตัว พร้อมสายยาวประมาณยี่สิบสี่นิ้ว ซึ่งเหมาะพอดี (หัว USB มีสองแบบคือแบบแบนๆ ที่เราเห็นอยู่ที่ตัวคอมพิวเตอร์เรียกว่าแบบ A และแบบสี่เหลี่ยมที่เราเห็นตามอุปกรณ์รอบข้างเช่นเครื่องพิมพ์และสแกนเนอร์ เรียกว่าแบบ B)

<< รูปที่ 1 : แผงเสียบ USB ติดตั้งด้านหน้าเครื่องที่ประดิษฐ์ขึ้นเอง

 

เพื่อให้ข้อความกะทัดรัด ต่อไปจะเรียก “แผงเสียบ USB ด้านหลังแบบสองช่อง” ว่า USBP เรียก “ฝาปิดช่องไดร์ฟด้านหน้า” ว่า DP และเรียก “หัว USB แบบ A ตัวเมีย” ว่า USBAF

รูปที่ 2 : แผงเสียบ USB ด้านหลังแบบสองช่อง >>

     

 

แกะ USBAF ออกจาก USBP แล้วนำมายึดไว้กับ DP ตอนแรกผมลองยึดแบบแนวนอน ปรากฏว่าไม่สามารถใส่ USBAF ครบสี่ตัวบน DP ชิ้นเดียวได้ จึงเปลี่ยนไปยึดแบบแนวตั้งแทน

 

<< รูปที่ 3 : การยึด USBAF กับ DP แบบแนวนอนซึ่งไม่ใช่วิธีที่ถูกต้อง

 

การเจาะช่องเสียบ USBAF บน DP จะต้องอาศัยแบบ (template) ที่ถูกต้อง ผมจึงนำ USBP ที่ถอด USBAF ออกแล้ว ไปเข้าเครื่องสแกนแล้วพิมพ์ออกมา

 

รูปที่ 4 : แบบที่สร้างจากการนำ USBP (ที่ถอด USBAF ออกแล้ว) นำไปสแกนแล้วพิมพ์ >>

     

 

ด้านหลังของ DP จะมีแนวเส้นพลาสติกซึ่งทำหน้าที่เพิ่มความแข็งแรงให้ DP ไม่บิดงอง่าย เราจะเป็นต้องเอาเส้นแนวเหล่านี้ออก เฉพาะตรงส่วนที่จะใส่ USBAF ผมเจียรออกโดยใช้ไขควงไฟฟ้าใส่หินเจียร

 

<< รูปที่ 5 : เจียรแนวเส้นพลาสติกออกเพื่อให้ใส่ USBAF ได้

รูปที่ 6 : นำ USBAF มายึดกับ DP เจาะรูใส่นอต โดยยังไม่ต้องเจาะช่องเสียบ USB

รูปที่ 7 : ด้านหน้า DP เมื่อยึดนอตแล้ว

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

รูปที่ 9 : เจาะช่องโดยใช้สว่านแล้วตะใบให้ได้ช่องสี่เหลี่ยมผืนผ้าที่เรียบตรง

รูปที่ 10 : เมื่อเจาะช่องเสร็จแล้วนำ USBAF มายึดไว้ด้วยนอต

รูปที่ 11 : เมื่อนำสาย USB มาเสียบจะเป็นแบบนี้


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

รูปที่ 12 : ทำซ้ำกับส่วนที่เหลืออีกสามช่อง

 

 

 

 

รูปที่ 13 : ถ้ามีซากซีดีไดร์ฟอยู่ใกล้มือจะดีมาก ถ้าไม่มี ให้ซื้อซีดีไดร์ฟที่เสียแล้วจากศูนย์ไอที

รูปที่ 14 : แกะไส้ในของซีดีไดร์ฟออก ให้เหลือแต่โครงเปล่าๆ

รูปที่ 15 : ตัดด้านหน้าของฝาซีดีไดร์ฟออกครึ่งนิ้วเพื่อให้ใส่แผ่น DP ได้พอดี

รูปที่ 16 : นำ DP มาติดตั้งด้านหน้าซีดีไดร์ฟ ยึดด้วยหนังยาง ใส่กาวอิพ็อกซี่ ทิ้งไว้ให้แห้งหนึ่งคืน เมื่อกาวแห้งแล้วให้แถะหนังยางออก

รูปที่ 17 : นำโครงซีดีไดร์ฟ (ซึ่งมี DP อยู่ด้านหน้า) ติดตั้งลงในเคส แล้วนำสาย USB ทั้งหกเส้นเสียบกับขาต่อพอร์ท USB เมนบอร์ด

รูปที่ 18 : เมื่อติดตั้งเสร็จสมบูรณ์แล้วจะเป็นแบบนี้

 

รายการอุปกรณ์

  • แผงเสียบ USB ด้านหลังแบบสองช่อง 2 ชิ้น
  • ซีดีรอมไดร์ฟที่เสียแล้ว 1 ตัว
  • ฝาปิดช่องไดร์ฟด้านหน้า 1 ชิ้น

 

สรุป

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

สร้างลูกศรหันตามเมาส์

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

บทความนี้เขียนขึ้นเมื่อ วันอังคารที่ 28 สิงหาคม พ.ศ. 2550

ผู้เขียน : ลาภลอย วานิชอังกูร www.laploy.com

ลงพิมพ์ในนิตยสาร Windows IT Pro

 

สร้างลูกศรหันตามเมาส์

เขียนโปรแกรมภาษา ActionScript 3.0 สร้างออพเจ็กต์ลูกศรที่หันหัวชี้ไปตามการเคลื่อนไหวของเมาส์พอยน์เตอร์ ได้ผลลัพธ์เป็น Flash Movie ไว้ใช้งานในหน้าเว็บ

 

ในบทความตอนที่แล้วผู้เขียนแนะนำวิธีพัฒนาโปรแกรมด้วยภาษา ActionScript เวอร์ชัน 3.0 (ต่อไปจะเรียกว่า AS3) เบื้องต้น ได้แนะนำไว้ว่าภาษา AS3 ต่างจากภาษา ActionScript เวอร์ชันก่อนๆ มาก ภาษา ActionScript เวอร์ชัน 1 และ 2 เป็นเพียงภาษาสคริปต์ที่ผูกติดกับทามน์ไลน์ (time line) แต่ AS3 เป็นภาษาเพื่อการเขียนโปรแกรมอย่างเต็มรูปแบบ เราสามารถพัฒนาโปรแกรมได้ด้วยวิธีการใกล้เคียงกับการสร้างแอพลิเกชันด้วยภาษาจาวาและ C#

 

เครื่องมือสำหรับพัฒนาโปรแกรมหรือ IDE ที่แนะนำให้ใช้คือโปรแกรม Adobe Flex Builder 2 (ต่อไปจะเรียกย่อว่า AFB2) มีวิธีใช้งานคล้ายกับ IDE ที่เราคุ้นเคย (เช่นวิสชวลสตูดิโอและเน็ตบีนส์) ทำให้นักพัฒนาโปรแกรมมืออาชีพสามารถก้าวเข้าสู่โลกแห่งการสร้าง rich internet application (โปรแกรมประยุกต์ในอินเตอร์เน็ตที่มีลักษณะการใช้งานใกล้เคียงกับโปรแกรมในเดกส์ท็อป) ได้อย่างรวดเร็ว และที่สำคัญคือภาษา AS3 สนับสนุนหลักการ OOP เหมือนจาวาและ C# (ทุกอย่างเป็นออพเจ็กต์ ใช้คลาสเพื่อสืบคุณสมบัติ ไม่ได้ใช้โปรโตไทป์เหมือนอย่างเวอร์ชันก่อน) ช่วยให้การนำโค้ดกลับมาใช้ใหม่ทำได้อย่างมีประสิทธิภาพ

 

คลาสกับออพเจ็กต์

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

 



แม่ค้าขายขนมครกที่เก่ง OOP

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

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

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

 

คลาสสร้างภาพลูกศร

คลาสสร้างภาพลูกศรชื่อคลาส Arrow ทำหน้าที่วาดภาพลูกศรหนึ่งตัว ในภาษา ActionScript หรือในโลกของแฟลช ภาพทั้งหลายมีภาวะเป็น “สไปรท์” (Sprite) หรือภาพกราฟิกเล็กๆ ที่สามารถเคลื่อนไหวได้อย่างอิสระ ลูกศรที่เราจะสร้างก็เป็นสไปรท์ตัวหนึ่ง คลาส Arrow ของเราจึงจำเป็นต้อง “รับคุณสมบัติ” (inherit) ต่างๆ มาจากคลาส Sprite (Sprite เป็นคลาสที่อยู่ภายในคลาสไลบรารีของแฟลช)

 

โค้ดย่อแบบโครงสร้าง (outline) ของคลาส Arrow

 

โค้ดที่เห็นข้างบนคือ โค้ดย่อแบบโครงสร้าง (outline) ของคลาส Arrow จะเห็นว่าคลาส Arrow มีสมาชิกเพียงสองตัว เป็นเมธอดทั้งคู่ คำสั่งบรรทัดที่ 1 ประกาศแพคเกจ (package เหมือนแพคเกจในจาวาและเนมสเปสใน C# ทำหน้าที่เป็นแหล่งเก็บกลุ่มของคลาส เหมือนคลาสไลบรารี) ชื่อ LoyClass ไฟล์เก็บนิยามต่างๆ ของแพคเกจนี้จะต้องอยู่ในโฟลเดอร์ชื่อเดียวกันนี้

บรรทัดที่ 3 คำสั่ง import ทำหน้าที่จับรวมนิยามต่างๆ ในแพคเกจที่ระบุรวมเข้ามา ทำให้เราสามารถอ้างถึงนิยามเหล่านั้นได้โดยไม่ต้องระบุชื่อแบบยาว (fully qualified name)

บรรทัดที่ 5 ทำหน้าที่ประกาศส่วนหัวของคลาส จะเห็นว่าประกอบด้วยคำว่า public ทำหน้าที่กำหนดขอบเขตการเข้าถึงว่าให้เรียกได้จากทุกแห่ง (หากไม่กำหนดจะมีค่าโดยปริยายเป็น internal) คำว่า class เป็นคำสงวน บอกให้รู้ว่านี่คือการนิยามคลาส Arrow เป็นชื่อคลาสที่เราตั้งขึ้น คำว่า extends ทำหน้าที่บอกการ inherit (เหมือนภาษาจาวา และเหมือนเครื่องหมาย : ใน C#) Sprite คือชื่อคลาสที่เราต้องการสืบคุณสมบัติ

บรรทัดที่ 7 และ 11 คือนิยามเมธอด ที่จะอธิบายในหัวข้อถัดไป

 

สมาชิกแบบเมธอดของคลาส Arrow

สมาชิกแบบเมธอดของคลาส Arrow มีเพียงสองตัว ตัวแรกเป็นคอนสทรักเตอร์ (constructor) มีโค้ดดังนี้

 

บรรทัดแรกนิยามส่วนหัวของเมธอด โปรดสังเกตว่ามันมีตัวจำกัดการเข้าถึงเป็น public ไม่มีรีเทินไทป์ (return type ค่าส่งกลับ) และมีชื่อเดียวกับคลาส ซึ่งเป็นปรกติของคอนสทรักเตอร์ ผู้เขียนกำหนดให้คอนสทรักเตอร์ของคลาส Arrow มีพารามิเตอร์หนึ่งตัวชื่อ color ทำหน้าที่รับค่าสี ซึ่งเราจะนำไปกำหนดให้เป็นสีของลูกศร พารามิเตอร์นี้มีดาต้าไทป์เป็น unit (เลขจำนวนเต็มไม่มีเครื่องหมายขนาด 32 บิต)

ไส้ในของคอนสทรักเตอร์นี้มีเพียงบรรทัดเดียว ทำหน้าที่เรียกเมธอด DrawArrow ที่จะอธิบายในหัวข้อถัดไป

 

เมธอด DrawArrow

เมธอด DrawArrow ทำหน้าที่ลากเส้นวาดภาพลูกศร มีโค้ดดังนี้

 

บรรทัดแรกนิยามส่วนหัวของเมธอด คำว่า private จำกัดการเข้าถึงเมธอดนี้ ให้เข้าถึงได้จากโค้ดภายในคลาสนี้เท่านั้น คำว่า void ทางขวาสุดระบุว่าเมธอดนี้ไม่มีค่าส่งกลับ บรรทัดที่ 3 คำว่า graphics เป็นชื่อคลาสในแพคเกจ flash.Graphics ทำหน้าที่เกี่ยวข้องกับการวาดภาพที่เกิดจากการลากเส้น (vector shape) lineStyle คือชื่อเมธอด (ของ graphics) ทำหน้าที่กำหนดลักษณะของเส้น

บรรทัดที่ 14 beginFill คือเมธอดทำหน้าที่กำหนดสีที่จะระบายภายในสไปร์ท เราใช้พารามิเตอร์ color เป็นตัวกำหนด บรรทัดที่ 15 moveTo คือเมธอดทำหน้าที่กำหนดตำแหน่งที่จะวาด

บรรทัดที่ 16 ถึง 22 เรียกเมธอด lineTo เพื่อวาดภาพ อาร์กิวเมนต์ทางซ้ายคือค่าในตำแหน่งที่จะวาดในแนว x อาร์กิวเมนต์ทางขวาคือค่าในแนว y บรรทัดที่ 23 เมธอด endFill ทำหน้าที่ระบายสีที่กำหนดไว้แล้วด้วย beginFill

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

 

  << ภาพลูกศรที่เกิดจากเมธอดนี้

 

คลาสที่ทำให้ลูกศรหันตามเมาส์

คลาสซึ่งทำหน้าที่ให้ลูกศรเคลื่อนไหวได้คือคลาสชื่อ ArrowRotate มีโค้ดย่อแบบโครงสร้าง (outline) ดังนี้

 

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

บรรทัดที่ 3 ถึง 5 จับแพคเกจไลบรารีของแฟลช (ที่เราต้องการใช้) ผนวกเข้ามาด้วยคำสั่ง import บรรทัดที่ 7 คือนิยามส่วนหัวของคลาส ArrowRotate โปรดสังเกตว่าคลาสนี้ก็สืบสันดานจากคลาส Sprite เช่นเดียวกับคลาส Arrow เพราะในคลาสนี้เราจำเป็นต้องอ้างถึงคุณสมบัติบางอย่างของสไปรท์ด้วยเช่นกัน

บรรทัดที่ 9 ถึง 13 คือสมาชิกแบบดาต้าฟิลด์ ที่จะอธิบายรายละเอียดในหัวข้อถัดไป บรรทัดที่ 15 ถึง 17 คือสมาชิกแบบพร็อพเพอร์ตี ซึ่งจะอธิบายรายละเอียดในหัวข้อถัดจากดาต้าฟิลด์ และสุดท้าย บรรทัด 19 ถึง 33 เป็นสมาชิกแบบเมธอด ซึ่งจะอธิบายรายละเอียดในหัวข้อถัดจากพร็อพเพอร์ตี

 

สมาชิกแบบดาต้าฟิลด์ของคลาส ArrowRotate

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

สมาชิกแบบดาต้าฟิลด์ของคลาส ArrowRotate มีห้าตัวดังนี้

  • arrow : มีชนิดข้อมูลเป็น Arrow ทำหน้าเก็บค่าอ้างอิงออพเจ็กต์ลูกศร
  • bkg : มีชนิดข้อมูลเป็น Stage ทำหน้าที่เก็บค่าอ้างอิงฉากหลัง (background) หรือพื้นที่วาดภาพ
  • posX : มีชนิดข้อมูลเป็น int ทำหน้าที่กำหนดค่าตำแหน่งทางแนวนอนของลูกศร
  • posY : มีชนิดข้อมูลเป็น int ทำหน้าที่กำหนดค่าตำแหน่งทางแนวตั้งของลูกศร
  • color : มีชนิดข้อมูลเป็น uint ทำหน้าที่เก็บค่าสีของลูกศร

 

โปรดสังเกตว่าฟิลด์บางฟิลด์ (เช่น posX) เรากำหนดค่าเริ่มต้นไว้ในบรรทัดเดียวกับการประกาศเลย (เช่น posX:int = 0) ภาษา AC3 ยินยอมให้ทำเช่นนี้ได้ ซึ่งนับว่าสะดวกดี และทำให้โค้ดกะทัดรัดขึ้น

 

สมาชิกแบบพร็อพเพอร์ตีของคลาส ArrowRotate

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

  • PosX : ใช้เซตตำแหน่งทางแนวนอนของออพเจ็กต์ลูกศร
  • PosY : ใช้เซตตำแหน่งทางแนวตั้งของออพเจ็กต์ลูกศร
  • Color : ใช้เซตสีของออพเจ็กต์ลูกศร

 

โปรดสังเกตว่าพร็อพเพอร์ตีต้องมีตัวจำกัดการเข้าถึงเป็น public และตามปรกติจะมีไทป์ตรงกันกับฟิลด์ที่มันทำหน้าที่เซตค่า (ยกตัวอย่างเช่นฟิลด์ posX มีไทป์เป็น int พร็อพเพอร์ตี PosX ก็จะมีไทป์เป็น int ด้วย)

 

สมาชิกแบบเมธอดของคลาส ArrowRotate

เมธอดคือโค้ดส่วนกำหนดการทำงานหรือส่วนประมวลผลของออพเจ็กต์ คลาส ArrowRotate มีเมธอดสามตัว รายละเอียดของเมธอดแต่ละตัวเป็นดังนี้

 

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

 

โค้ดข้างบนคือเมธอดชื่อ Show ทำหน้าที่สร้าง กำหนดค่าเริ่มต้น และแสดงภาพลูกศร บรรทัดที่ 25 สร้างออพเจ็กต์ลูกศรโดยใช้สีที่ระบุไว้ในพร็อพเพอร์ตี color บรรทัดที่ 26 นำลูกศรไปใส่ในฉากหลัง ซึ่งเป็นพื้นที่วาดภาพที่รับค่าอ้างอิงมาจากโค้ดภายนอก บรรทัดที่ 27 และ 28 กำหนดตำแหน่งของลูกศร บรรทัดที่ 29 และ 30 กำหนดขนาดของลูกศร บรรทัดที่ 31 เรียกเมธอด addEventListener (เป็นเมธอดของคลาส EventDispatcher) ทำหน้าที่กำหนดเมธอดบริการอีเวนต์ (event handler method) ในโค้ดนี้กำหนดให้เมธอด onEnterFrame ทำงานทุกครั้งที่มีการอัพเดตเฟรม

 

โค้ดข้างบนคือเมธอดชื่อ onEnterFrame ทำหน้าที่เป็นเมธอดบริการอีเวนต์ จะทำงานทุกครั้งที่เกิดเหตุการณ์ enterframe (อีเวนต์นี้เกิดเมื่อมีการอัพเดตพื้นที่แสดงภาพ flash movie อัพเดตพื้นที่แสดงภาพโดยอัตโนมัติอย่างต่อเนื่องในความถี่ที่กำหนดไว้ตอนคอมไพล์ ค่าโดยปริยายคือ 24 ครั้งต่อวินาที) เมธอดนี้มีตัวจำกัดการเข้าถึงเป็น private เพราะเราต้องการใช้งานภายในคลาสนี้เท่านั้น มีรีเทินไทป์เป็น void เพราะเราไม่ต้องการส่งค่าอะไรกลับไปให้ผู้เรียก

คำสั่งบรรทัดที่ 35 ประกาศตัวแปรชื่อ dx คำว่า mouseX คือพร็อพเพอร์ตีของคลาส DisplayObject ทำหน้าที่ให้ค่ำตำแหน่งทางแกน x ของเมาส์ คำสั่งบรรทัดที่ 36 ประกาศตัวแปรชื่อ dy และพร็อพเพอร์ตี mouseY ให้ค่าตำแหน่งทางแกน y คำสั่งบรรทัดที่ 37 ประกาศตัวแปรชื่อ radians คำว่า Math.atan2 คือคลาสทำหน้าที่คำนวณหามุมของ y และ x บรรทัดที่ 38 นำค่าใน radians มาคำนวณหาค่าการหมุนของลูกศร

 

โปรแกรมทดสอบการทำงาน

เมื่อนิยามคลาสต่างๆ ที่จำเป็นครบแล้ว เราต้องเขียนโปรแกรมเพื่อทดสอบคลาสเหล่านั้นด้วย เราจะนิยามคลาสชื่อ test ซึ่งทำหน้าที่นำคลาส ArrowRotate มาสร้างออพเจ็กต์ลูกศรสองตัว ตัวหนึ่งสีเหลืออยู่ที่ตำแหน่ง 100,100 และอีกตัวสีแดง อยู่ที่ตำแหน่ง 200,100

คลาส test ประหลาดกว่าคลาส Arrow และคลาส ArrowRotate เพราะเราไม่ต้องนำคลาส test ไปสร้างออพเจ็กต์ก่อนจึงจะใช้งานได้ แต่รันทามน์ (run-time) ของแฟลชจะเรียกคลาส test ให้ทำงานโดยอัตโนมัติ ที่เป็นเช่นนั้นเพราะเราวางคลาสนี้ไว้ในระดับบนสุดของเส้นทางคลาส (class path) ทำให้มันมีภาวะเหมือนเมธอด Main ในภาษาจาวาและ C#

 

โปรแกรมทดสอบการทำงาน

 

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

 

  ทดลองรันโปรแกรมที่ระบุในบทความนี้แบบออนไลน์

ท่านสามารถดาวน์โหลดซอร์สโค้ดของบทความนี้ได้จากเว็บไซต์ laploy.com (เลือกหัวข้อดาวน์โหลด ไฟล์ชื่อ AS3002.zip ภายในเป็นโปรเจ็กต์ที่สร้างจาก AFB2)

 

ซอร์สโค้ด

โค้ดทั้งหมดในบทความนี้เป็นแฟ้มข้อมูลตัวอักษรธรรมดา (plain text file)สามารถป้อนพิมพ์ด้วยโปรแกรมแก้ไขแฟ้มข้อมูลตัวอักษร (text editor) อะไรก็ได้ (เช่นโปรแกรม Notepad ในวินโดวส์) แล้วจัดเก็บไฟล์ไว้เป็นนามสกุล .as แต่ถ้าใช้โปรแกรม AFB2 ให้สร้างโปรเจ็กต์โดยเลือกเมนู New/ActionScript Project แล้วให้ใส่ไฟล์ test.as ไว้ระดับนอกสุด (ที่รูทโฟลเดอร์ของโปรเจ็กต์)

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

ขณะป้อนพิมพ์โค้ดหากต้องการตรวจสอบข้อผิดพลาด ท่านไม่จำเป็นต้อง build หรือคอมไพล์โปรแกรมก่อน เพียงกดปุ่ม Save (ปุ่มรูปแผ่นดิสก์เก็ต) โปรแกรม AFB2 จะตรวจสอบและแจ้งความผิดพลาดขณะคอมไพล์ (compile-time error) ในหน้าต่าง Problems ให้โดยอัตโนมัติ เมื่อต้องการคอมไพล์ให้กดปุ่ม Run (ปุ่มกลมเขียวมีสามเหลี่ยมขาวภายใน) AFB2 จะคอมไพล์โปรแกรมและเก็บไฟล์ผลลัพธ์ไว้ในโฟลเดอร์ bin

 

หากท่านมีข้อสงสัยใดๆ โปรดโพสคำถามไว้ที่กระดานถาม-ตอบซึ่งอยู่ในเว็บไซต์เดียวกัน

 

เกี่ยวกับผู้เขียน
ลาภลอย วานิชอังกูร
ทำงานด้านคอมพิวเตอร์มานานกว่ายี่สิบปี เขียนโปรแกรมคล่องหลายภาษา เคยทำงานด้านคอมพิวเตอร์ที่ประเทศสหรัฐอเมริกา ประเทศเยอรมัน และประเทศสวิส เคยเป็นครูสอนวิชาคอมพิวเตอร์ เคยเป็นบรรณาธิการนิตยสารคอมพิวเตอร์ มีผลงานบทความ และตำราคอมพิวเตอร์จำนวนมาก ปัจจุบันทำหน้าที่เป็นผู้ให้คำปรึกษาด้าน .Net ให้แก่บริษัท Accenture ท่านสามารถติดต่อผู้เขียนได้ที่ กระดานบทความในเว็บไซต์ laploy.com และที่อีเมล laploy@gmail.com