วันพฤหัสบดีที่ 23 ธันวาคม พ.ศ. 2553

รวมภาษา C ที่ต้องรู้


***เขียนโปรแกรมด้วย Visual C++ 6.0


ขั้นที่ 1 ก่อนที่จะเขียนโปรแกรม Visual C++ 6.0 ผู้อ่านต้องทำการติดตั้งโปรแกรม Visual Studio 6.0
เอาไว้ภายในระบบคอมพิวเตอร์ของท่านเป็นลำดับแรก รายละเอียดการติดตั้ง Visual C++ ผู้เขียนจะไม่กล่าวถึง เพราะผู้เขียนอนุมานไว้ว่าระบบคอมพิวเตอร์ของท่านได้ติดตั้ง Visual C++ เรียบร้อยแล้ว โปรแกรม Visual C++ มาพร้อมกับชุดเต็มของ Visual Studio ซึ่งประกอบด้วย Visual C++ , Visual Basic และ InterDev


ขั้นที่ 2 เรียกโปรแกรม Visual C++ โดยการเลือก Start > Programs > Microsoft Visual Studio 6.0 ตามด้วย Microsoft Visual C++ 6.0 ดังภาพที่ปรากฎด้านล่างนี้



ขั้นที่ 3 เมื่อเข้าสู่โปรแกรมหลักของ Visual C++ จะแจ้ง Tip of the Day ให้ท่านทราบเกี่ยวกับเทคนิคต่าง ๆ เล็ก ๆ น้อย ๆ เกี่ยวกับการใช้งาน Visual C++ ถ้าท่านไม่ต้องการให้ไดอะล็อกดังกล่าว ปรากฎในทุกครั้งที่เปิดโปรแกรม Visual C++ ให้คลิ๊กเอาเครื่องถูกออกจากช่อง Show tips at startup



ขั้นที่ 4 ภาพด้านล่างนี้คือหน้าจอหลักของโปรแกรม Visual C++ ซึ่งประกอบด้วย เมนูต่าง ๆ และเครื่องมือต่าง ๆ มากมาย รายละเอียดดังกล่าวเกี่ยวกับเครื่องมือและเมนูต่าง ๆ จะพูดถึงในบทต่อ ๆ ไป



ขั้นที่ 5 เริ่มต้นสร้างโปรแกรมด้วยการคลิ๊กเลือก File > New หรือสามารถใช้ Ctrl + N ให้ผลลัพธ์เช่นเดียวกัน
การทำเช่นนี้หมายถึงการกำลังจะเริ่มต้นสร้างโค๊ดภาษาซีขึ้นมาใหม่ คล้ายกับการพิมพ์เอกสารใหม่ ด้วยโปรแกรมประยุกต์ทั่ว ๆ ไป



ขั้นที่ 6 เราสามารถสร้างแอพลิเคชั่นในแบบต่าง ๆ ได้มากมาย ซึ่ง Visual C++ สนับสนุนการพัฒนาซอฟต์แวร์ หลากหลาย ในขั้นตอนเบื้องต้นเราจะเลือกการเขียนโปรแกรมเพื่อทำงานที่ Dos Prompt ดังนั้นให้ผู้อ่านเลือก Win32 Console Application จากนั้นที่ช่อง Location: ให้ป้อนโฟล์เดอร์ที่ต้องการเก็บไฟล์โปรเจ็คของเรา ผู้เขียนเก็บไว้ที่ C:\VC ถัดมาในช่อง Project Name: ให้ป้อนชื่อโปรเจ็ค ตอนนี้ผู้เขียนให้โปรเจ็คนี้ชื่อว่า helloworld ดังนั้นป้อนคำว่า helloworld ลงไป เมื่อพร้อมแล้วคลิ๊กที่ปุ่ม OK



ขั้นที่ 7 ในลำดับถัดมาโปรแกรม Visual C++ จะให้เราเลือกชนิดของ Console ที่เราต้องการสร้าง ซึ่งมี 4 ชนิด คือ
- เป็นโปรแกรมว่างเปล่าที่ไม่มีซอร์สโค๊ดให้เราเลย
- โปรแกรมจะสร้างซอร์สโค๊ดง่าย ๆ ให้เรา
- โปรแกรมจะสร้างซอร์สโค๊ด Hello World แสดงข้อความง่าย ๆ ให้เรา
- โปรแกรมจะสนับสนุนการเขียนโปรแกรมด้วยชุดคำสั่ง MFC รายละเอียดส่วนนี้จะกล่าวถึงในส่วนต่อ ๆ ไป
ขอให้ผู้อ่านเลือก An empty project เพื่อสร้างโปรเจ็คเปล่า เมื่อพร้อมแล้วกดปุ่ม Finish



ขั้นที่ 8 ลำดับถัดมา Visual C++ จะแจ้งให้เราทราบรายละเอียดเกี่ยวกับโปรเจ็คของเรา ซึ่งโปรเจ็คของเราตั้งเก็บไว้ที่ ไดเร็คทอรี่ C:\vc\helloworld และสร้างโปรเจ็คชนิด Win32 Console กล่าวคือรันที่ Dos Prompt และมีชนิดเป็น Empty Console Application หรือโปรแกรมที่ไม่มีโค๊ดอะไรให้เรา เป็นโปรเจ็คเปล่า ๆ เอาไว้รันใน Dos เท่านั้น เมื่อรับทราบแล้วกดแป้น OK เพื่อเข้าสู่หน้าจอการเขียนโปรแกรมต่อไป



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



ขั้นที่ 10 เขียนโค๊ดแกรมภาษาซีที่นี่ในขั้นตอนนี้ผู้อ่าน เขียนโปรแกรมภาษาซีลงในวินโดวส์ชื่อ Text1 โดยพิมพ์ตามดังภาพด้านล่างนี้



ขั้นที่ 11 ในขั้นตอนถัดมาให้กดที่ปุ่ม Save (รูปแผ่น Disket) จากนั้นระบุชื่อไฟล์ว่า helloworld.c ดังภาพด้านล่างนี้ ขบวนการนี้เราเพียงกำลังบันทึกไฟล์เท่านั้น โดยเรากำหนดให้ซอร์สโค๊ดมีชื่อว่า helloworld.c



ขั้นที่ 12 เมื่อบันทึกเสร็จแล้วต่อไปเป็นการแทรกโค๊ดภาษาซีเพื่อให้เข้ามาเป็นส่วนหนึ่งของโปรเจ็ค โดยการคลิ๊กขวา แล้วเลือก Insert File into Project และเลือกชื่อไฟล์ ซึ่งตอนนี้คือคำว่า helloworld ขอให้ผู้อ่านพิจารณาจากภาพด้านล่างนี้



ขั้นที่ 13 ขั้นตอนการคอมไพล์ ขอให้ผู้อ่านใช้เมาส์คลิ๊กที่เมนู Build และเลือก Execute helloworld.exe หรือจะคอมไพล์โดยการใช้คีย์ลัด กล่าวคือกดแป้น Ctrl + F5 ซึ่งจะหมายถึงการคอมไพล์โค๊ดเช่นเดียวกัน (อย่าลืมว่ากด Ctrl ค้างไว้แล้วตามด้วยแป้น F5 ในขณะที่แป้น Ctrl ยังคงกดอยู่ จากนั้นปล่อยมือทั้งสองข้าง ออกมาจากคีย์บอร์ด)



ขั้นที่ 14 ในการคอมไพล์ทุกครั้ง Visual C++ จะสร้างไฟล์ .EXE ทุกครั้ง ในกรณีนี้ ไฟล์ดังกล่าวยังไม่ได้สร้างขึ้นมา ดังนั้น Visual C++ จะถามเพื่อแสดงการยืนยัน ที่จะคอมไพล์ด้วยข้อความดังภาพด้านล่างนี้



ขั้นที่ 15 เมื่อคอมไพล์เสร็จแล้วโปรแกรม Visual C++ จะทำการ Execute กล่าวคือสั่งให้ไฟล์ helloworld.exe ทำงานโดยอัตโนมัติและแสดงผลลัพธ์ดังปรากฎดังภาพด้านล่าง ในตัวอย่างนี้ข้อความที่ต่อจากคำว่า Hello World จะเป็นคำว่า Press any key to continue หมายความว่าโปรแกรม Visual C++ จะอนุญาติให้โปรแกรมเมอร์ ตรวจสอบผลลัพธ์ ก่อนทุกครั้ง เมื่อโปรแกรมเมอร์ ตรวจสอบผลลัพธ์เสร็จเรียบร้อยแล้วสามารถกดแป้นใด ๆ หนึ่งครั้งเพื่อปิดหน้าจอการ Execute ไปได้ เพื่อเข้าสู่การเขียนโปรแกรมต่อไป



ขั้นที่ 16 เมื่อเขียนโปรแกรมเสร็จเรียบร้อยแล้วและต้องการจบการทำงาน ผู้อ่านสามารถคลิ๊กที่เมนู File > Exit ซึ่งคล้ายกับการจบโปรแกรมทั่ว ๆ ไป



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


***เขียนโปรแกรมภาษาซีด้วย Turbo C


ขั้นที่ 1 ก่อนอื่นต้องดาวน์โหลดโปรแกรม TC เป็นลำดับแรก ผู้เขียนอนุมานว่าผู้อ่านไม่มีประสบการณ์ในการติดตั้ง TC ดังนั้นหากท่านสามารถติดตั้งได้เอง โปรดข้ามหัวข้อนี้ไป เพื่อเข้าสู่เนื้อหาที่ Advanced มากขึ้น เริ่มต้นโดยให้ผู้อ่านเปิดโปรแกรม Windows Explorer และคลิ๊กที่แถบ URL ด้านบน พิมพ์คำว่า http://www.sptc.ac.th/nprotech/articles/C0001/TC.zip ดังภาพต่อไปนี้



ขั้นที่ 2 เมื่อพิมพ์ URL ครบแล้วให้ท่านกด Enter หนึ่งครั้งเพื่อ Download File TC.zip ซึ่งจะปรากฎผลลัพธ์ดังนี้
- ถ้าท่านต้องการเปิดไฟล์ คลิ๊ก Open
- ถ้าต้องการบันทึกไฟล์ คลิ๊ก Save
- ถ้าต้องการยกเลิกการดาวน์โหลดคลิ๊ก Cancel
- ถ้าต้องการข้อมูลมากกว่านี้ คลิ๊ก More Info



ขั้นที่ 3 เลือก Save และคลิ๊กลูกศรชี้ลง ตลอดจนเลือก ไดวร์ C: ดังภาพต่อไปนี้
ผู้เขียนต้องการให้ท่านเลือกไดเร็คทอรี่เพื่อเก็บไฟล์เอาไว้ที่ C:\ เพราะว่าภายในโปรแกรมดังกล่าวนี้ ได้ทำการตั้งค่าพารามิเตอร์ต่าง ๆ เกี่ยวกับการคอมไพล์ไว้ในไดเร็คทอรี่ C:\TC ดังนั้น หากท่านขยายไฟล์ผิดตำแหน่ง จะทำให้ไม่สามารถคอมไพล์ได้ วิธีแก้ทำได้โดยการปรับเปลี่ยนที่เมนู Directory ให้ตรงกับไดเร็คทอรี่ที่ท่านได้เก็บไฟล์ไว้ยังตำแหน่งที่ท่านต้องการ แต่ถ้าท่าน ทำตามวิธีที่ผู้เขียนแนะนำ ท่านไม่ต้องทำการปรับแก้ค่าตัวเลือกใด ๆ ผู้เขียนจะกล่าวถึงรายละเอียดส่วนนี้ในบทต่อ ๆ ไป ตอนนี้ต้องการให้ผู้อ่านสามารถคอมไพล์โค๊ดภาษาซีได้เท่านั้น ดังนั้นท่านควรปฏิบัติตามแนวทาง ที่ได้แสดงเอาไว้ในบทความชุดนี้อย่างเคร่งครัด เว้นเสียแต่ท่านเข้าใจสิ่งที่ผู้เขียนกำลังอธิบายนี้แล้ว จึงสามารถดูผ่าน ๆ ได้อย่างรวดเร็ว



ขั้นที่ 4 เริ่มต้นการดาวน์โหลด ภาพด้านล่างนี้ แสดงการดาวน์โหลดไฟล์ ขณะนี้ เครื่องที่ผู้เขียนใช้งานอยู่บนระบบ LAN จึงสามารถโหลดไฟล์ดังกล่าวด้วยความเร็วสูงกว่าการโหลดด้วย Modem ธรรมดา สังเกตที่อัตราการ Transfer rate ที่ 31.0KB/Sec หากเป็นโมเดมธรรมดาจะอยู่ที่ประมาณ 5 KB/Sec



ขั้นที่ 5 เมื่อดาวน์โหลดเสร็จแล้วคลาย Zip ไฟล์ TC.zip ที่โหลดมาแล้วด้วยการคลิ๊กขวา ดังภาพต่อไปนี้
สังเกตว่าไฟล์ที่เราโหลดมานั้นมีชื่อว่า TC.zip ผู้เขียนต้องการให้ท่าน Save เอาไว้ที่ไดรว์ C:\ และคลาย Zip ออกไปไว้ที่โฟล์เดอร์ C:\TC



ขั้นที่ 6 ดับเบิ้ลคลิ๊กโฟลเดอร์ C:\TC ไฟล์ที่คลาย Zip เรียบร้อยแล้วจะเก็บไว้ที่โฟล์เดอร์ C:\TC และภายในไดเร็คทอรี่ดังกล่าวจะประกอบด้วยโฟล์เดอร์ C:\TC\INCLUDE และ C:\TC\LIB รายละเอียดส่วนนี้จะกล่าวถึงอีกครั้งในบทหลัง ๆ แต่ตอนนี้ให้ท่านเข้าใจเพียงว่า ภายในโฟล์เดอร์ ทั้งสองจะเก็บไฟล์ ที่มีนามสกุล .H และ .LIB เอาไว้ในโฟล์เดอร์ทั้งสองตามลำดับ



ขั้นที่ 7 เรียกให้ Turbo C ทำงานโดยคลิ๊กที่ไฟล์ TC ดังภาพต่อไปนี้ ความจริงในขั้นตอนนี้ผู้อ่านสามารถคลิ๊ก Start > Run และพิมพ์คำว่า C:\TC\TC.EXE จากนั้นกดแป้น Enter ซึ่งจะให้ผลเช่นเดียวกับขั้นตอนนี้ กล่าวคือเรียกให้ Turbo C ทำงานและพร้อมจะเขียนโปรแกรมและคอมไพล์ต่อไป



ขั้นที่ 8 เมื่อไฟล์ TC.EXE ถูกเรียกให้ทำงานจะปรากฎผลลัพธ์ดังนี้ ภาพด้านล่างนี้เป็นหน้าจอของโปรแกรม TC ถ้าผู้อ่านต้องการให้โปรแกรมแสดงผลเต็มจอ สามารถกดแป้น Alt + Enter (กด Alt ค้างไว้ แล้วตามด้วย Enter หนึ่งครั้ง) จะเป็นการสลับไปมาระหว่างโหมด Full Screen กับโหมด Windows และในทำนองเดียวกัน ถ้าต้องการสลับกลับมายังโหมดวินโดวส์ธรรมดา ให้กด Alt + Enter ได้เช่นเดียวกัน



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



ขั้นที่ 10 ทำการคอมไพล์ด้วยการกด Alt + R แล้วกด Enter หนึ่งครั้ง ขั้นตอนนี้อาจจะกด Ctrl + F9 จะปรากฎผลเช่นเดียวกัน ในขั้นตอนนี้เรายังไม่ได้บันทึกไฟล์เป็น Helloworld.c ดังนั้นผลลัพธ์ที่ได้จะสร้างไฟล์ชื่อว่า noname.exe ซึ่งก็จะให้ผลลัพธ์อันเดียวกัน ขั้นตอนต่อไปจะแสดงการบันทึกแฟ้มข้อมูล



ขั้นที่ 11 ออกจากโปรแกรม TC โดยการกด Alt + Q หรือกด Alt + F และเลื่อนลูกศรมาที่ Quit ให้ผลเช่นเดียวกัน เนื่องจากเรายังไม่ได้บันทึกแฟ้มข้อมูล เมื่อทำการออกจากโปรแกรม คอมไพล์เลอร์จะถามว่าต้องการบันทึกซอร์สโค๊ดหรือไม่ ให้ตอบตามความต้องการของท่าน ในกรณีตัวอย่างนี้เราจะบันทึกไฟล์เก็บไว้ในชื่อ helloworld.c



ขั้นที่ 12 ก่อนที่จะจบการทำงานโปรแกรมภาษาจะถามเราเกี่ยวกับการบันทึกไฟล์ ถ้าปรารถนาจะบันทึกให้กด Yes อย่างที่ได้กล่าวไปแล้วในขั้นตอนนี้ ผู้อ่านจะบันทึกหรือไม่บันทึกขึ้นอยู่กับตัวท่านเอง แต่บทความนี้สำหรับผู้เริ่มต้น เราจะบันทึกไฟล์ชื่อ helloworld.c ดังนั้นกด Y เพื่อบอกคอมไพล์เลอร์ว่า เราต้องการบันทึกซอรส์โค๊ด



ขั้นที่ 13 ตั้งชื่อไฟล์ว่า helloworld.c จากนั้นกดแป้น Enter หนึ่งครั้ง เนื่องจาก TurboC 2.0 สนับสนุนการตั้งชื่อไฟล์ระบบเก่า คือตั้งได้ 8 ตัว และนามสกุล 3 ตัว ดังนั้น จะเกิดการตัดคำอัตโนมัติให้เหลือเพียงคำว่า hellowor.c แทนที่จะเป็น helloworld.c



ขั้นที่ 14 ในขั้นตอนที่ผ่านมาเราได้คอมไพล์โค๊ดภาษาซีเสร็จแล้วต่อไปต้องการรันโค๊ดใน DOS Prompt ขอให้ท่านเลือก Start > Run ในขั้นตอนนี้ท่านผู้อ่านสามารถคลิ๊ก Start > Run และพิมพ์คำว่า C:\TC\noname.exe ซึ่งจะให้ผลเร็ว และจะปิดวินโดวส์ไปอย่างรวดเร็ว ดังนั้นเราจึงควรจะออกไปที่ DOS Prompt ด้วยการพิมพ์คำสั่ง Start > Run และพิมพ์ CMD ซึ่งคำสั่ง CMD จะมีสำหรับวินโดวส์ NT และ 2000 และ XP เท่านั้น ไม่สามารถใช้คำสั่ง CMD ในวินโดวส์ที่ต่ำกว่าที่กล่าวมาได้ ดังนั้นถ้าเป็นระบบปฏิบัติการตัวเก่า ท่านต้องเปลี่ยนมาพิมพ์คำว่า Command เต็ม ๆ แทนคำว่า CMD



ขั้นที่ 15 พิมพ์คำสั่ง cmd เพื่อไปยัง Dos Prompt ดังที่ได้กล่าวไปแล้วคำสั่ง CMD ใช้ได้เฉพาะใน NT, 2000 และ XP เท่านั้น ถ้าจะให้ทำงานได้ในระบบปฏิบัติการรุ่นเก่าต้องพิมพ์คำว่า Command แทน CMD



ขั้นที่ 16 ได้ผลลัพธ์ดังต่อไปนี้ คำสั่ง CMD จะเป็นโปรแกรมที่บอกให้ระบบปฏิบัติการรับคำสั่ง DOS เหมือนในระบบเดิม เพียงแต่ว่า CMD ต่างจาก Command ตรงที่เราสามารถใช้ลูกเล่นต่าง ๆ ได้ เช่นใช้คำสั่ง cd \win* ซึ่งจะหมายถึงเข้าไปในไดเร็คทอรี่อะไรก็ได้ที่ขึ้นต้นด้วยคำว่า win เป็นต้น ซึ่งแท้จริงเป็นการเพิ่มประสิทธิภาพของ Command ให้ดีขึ้นนั่นเอง นอกจากนั้น CMD ยังสามารถ ใช้เมาส์ลากตัวอักษรบริเวณที่เราต้องการแล้วคลิ๊กขวา เพื่อคัดลอกข้อความนั้นเอาไปยังคลิปบอร์ด ได้อีกด้วย หรือถ้าคลิ๊กลงบนพื้นที่ Console ก็จะหมายถึงการวางข้อความที่อยู่ในคลิปบอร์ดลงในพื้นที่ Console เป็นต้น รายละเอียดส่วนนี้ศึกษาได้จากคู่มือการใช้งานคำสั่ง CMD ใน Online Help ของวินโดวส์



ขั้นที่ 17 พิมพ์คำสั่ง cd \tc เพื่อเข้าไปยังไดเร็คทอรี่ TC จากนั้นพิมพ์คำว่า HELLOWOR.EXE เนื่องจาก TC2.0 สนับสนุนการตั้งชื่อไฟล์เพียง 8 ตัว ดังนั้นจะมีชื่อเพียง HELLOWOR เท่านั้น ผลลัพธ์ของการ Execute จะให้ผลคือคำว่า Hello World ปรากฎบนจอภาพคอมพิวเตอร์



ขั้นที่ 18 ผลลัพธ์ของการคอมไพล์จะปรากฎคำว่า Hello World ปรากฎบนจอภาพคอมพิวเตอร์ ขอให้ ท่านผู้อ่านระลึกไว้ว่า ขณะนี้เรากำลังเรียนรู้ตัวอย่างการคอมไพล์ด้วย Turbo Cในหัวข้อต่อไป เราจะศึกษาเกี่ยวกับการคอมไพล์ภาษาซีด้วยไมโครซอฟต์วิชวลซีพลัส ๆ (Visual C++)


***เขียนโปรแกรมภาษาซีในระบบ UNIX


ระบบ UNIX เป็นระบบปฏิบัติการแบบ Multi User คืออนุญาตให้ผู้ใช้หลายคน เชื่อมต่อเข้ามายังคอมพิวเตอร์แม่ข่ายและเรียกใช้งานโปรแกรมภายในระบบคอมพิวเตอร์ได้ การเชื่อมต่อของระบบ UNIX ผมจะไม่ขอกล่าวถึง แต่ในครั้งแรกที่เราเข้าสู่ระบบ UNIX จำเป็นต้องป้อนชื่อ Account และ Password ให้ถูกต้องตามลำดับ ปัจจุบันนี้ระบบปฏิบัติการ Windows NT , Window2000 และ XP สามารถเชื่อมต่อเข้ากับระบบ Unix ได้ด้วยโปรแกรม Telnet ซึ่งมีอยู่ในคอมพิวเตอร์เหล่านั้นอยู่แล้ว คอมพิวเตอร์ที่ผมทำงานอยู่นี้ต่อเชื่อมกับระบบเน็ตเวอร์ค ดังนั้นผมจะทดลองใช้คำสั่ง Telnet ไปยังเครื่องคอมพิวเตอร์ดังกล่าว ด้วยการใช้คำสั่งดังนี้


ขั้นที่ 1 ล็อกออนเข้าสู่เครื่องที่ใช้ UNIX
สมมติว่าเราต้องการเชื่อมต่อเข้ากับคอมพิวเตอร์ปลายทางหมายเลข 202.47.249.6 ซึ่งจากตัวอย่างนี้คอมพิวเตอร์เครื่องดังกล่าวตั้งอยู่ที่การสื่อสารแห่งประเทศไทย เขตไปรษณีย์กลางบางรัก กรุงเทพมหานคร ฯ และเครื่องที่ผมใช้งานขณะนี้ตั้งอยู่ที่มหาวิทยาลัยเทคโนโลยีพระจอมเกล้าธนบุรี ผมต้องการเชื่อมต่อเข้ากับระบบ Unix ที่ตั้งอยู่ไปรษณีย์กลางบางรัก และผมมี User และ Password สามารถทำได้โดยการเรียกใช้โปรแกรม Telnet ของไมโครซอฟต์ โดยคลิ๊กที่ Start > Run ดังภาพด้านล่าง



ขั้นที่ 2 เรียกใช้โปรแกรม Telnet
โปรแกรม Telnet ที่ใช้เป็นของบริษัทไมโครซอฟต์ เราสามารถเรียก Telnet ตามด้วยหมายเลข IP Address ของเครื่องแม่ข่ายปลายทางได้ ในกรณีนี้คอมพิวเตอร์แม่ข่ายที่เราต้องการเชื่อมโยงเข้าไป มีหมายเลข IP 202.47.249.6 ดังนั้น สามารถเรียกโปรแกรมให้ทำงานได้ดังนี้



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


Last login: Thu Jul 24 15:15:13 from 202.47.250.36
Sun Microsystem Inc. SunOS 5.8 Generic February 2000
$



ขั้นที่ 4 เริ่มต้นเขียนซอร์สโค๊ด
ในการเริ่มต้นเขียนซอร์สโค๊ดภาษาซี เราจะใช้คำสั่ง cat > filename เพื่อสร้างเท็กซ์ไฟล์ขึ้นมา คำสั่ง cat > เปรียบได้เหมือนกับคำสั่ง copy con ในดอส หากท่านไม่เข้าใจว่าคำสั่งดังกล่าวทำอะไร ขอให้ศึกษารายละเอียดเพิ่มเติม แต่ตอนนี้ขอให้ท่านจำไว้ก่อนว่า คำสั่ง cat > ใช้ในการสร้างเท็กซ์ไฟล์ได้


ขั้นตอนต่อไปคือพิมพ์ซอร์สโค๊ด ซึ่งประกอบด้วยรายละเอียดดังนี้



ให้ท่านพิมพ์ตามโค๊ดสีเขียวด้านบน และเมื่อต้องการขึ้นบรรทัดใหม่ให้กดแป้น Enter เสมอ ในขณะที่บรรทัดสุดท้ายเราจะต้องกดแป้น Ctrl + d (กดแป้น Ctrl ค้างไว้ แล้วตามด้วยการกดแป้น d หนึ่งครั้ง) เพียงเท่านี้เราสามารถสร้างไฟล์ชื่อ helloworld.c โดยมีรายละเอียดซอร์สโค๊ดตามตัวอย่างด้านบนได้แล้ว


ขั้นที่ 5 เริ่มต้นการคอมไพล์
การคอมไพล์จะใช้คำสั่ง gcc หรือ cc ก็ได้ โดยใช้คำสั่งดังนี้ gcc helloworld.c ถ้าคอมไพล์ไม่ผ่านตัวคอมไพล์เลอร์จะแจ้งข้อความผิดพลาดที่เกิดขึ้นภายในซอร์สโค๊ดของเรา เนื่องจากภาษาซีเป็นโปรแกรม Case Sensitive หมายถึงตัวอักขระเล็กหรือใหญ่ถือว่าเป็นคนละตัวกัน ดังนั้นผู้อ่านต้องระมัดระวังในรายละเอียดส่วนนี้ด้วย


ขั้นที่ 6 เริ่มต้นสั่งให้โปรแกรมของเราทำงาน
โปรแกรมที่คอมไพล์ผ่านแล้วจะมีชื่อว่า a.out ดังนั้นเราสามารถสั่งให้ไฟล์ a.out ทำงานได้โดยตรง แต่เนื่องจากการระบุถึงไฟล์ในไดเร็คทอรี่ปัจจุบันในระบบ unix ต้องอ้างด้วยเครื่องหมาย ./ (จุดตามด้วยสแลส) เสมอ ดังนั้นเมื่อเราจะสั่งให้ไฟล์ a.out ทำงานจึงต้องพิมพ์ให้เต็มด้วยคำว่า ./a.out โปรแกรมจึงจะทำงานได้อย่างถูกต้อง และให้ผลลัพธ์จะแสดงคำว่า Hello World ปรากฎบนจอภาพคอมพิวเตอร์


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


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


***ทดลองเขียนโปรแกรมสร้าง Thread (Visual C++)


ในการเขียนโปรแกรมเพื่อสร้าง Thread ให้ทำงานบางอย่าง ท่านสามารถทำได้กับโปรแกรมที่เป็น Dialog-based หรือ SDI/MDI ก็ได้ แต่ต้องเป็น MFC นะครับ เราจะมาดูตัวอย่างโค้ดที่เขียนโดยใช้โปรเจ็กต์แบบ Dialog-based กัน เพราะจะดูเข้าใจง่ายกว่าแบบ SDI (มีคลาสแค่ 2 คลาส) โดยตัวอย่างที่เราจะใช้กันนี้ เราตั้งชื่อโปรเจ็กต์ว่า ThreadMFC ซึ่งใน Project เราจะมีคลาสอยู่ด้วยกันทั้งหมด 2 คลาสคือ



  • 1. CThreadMFCApp สืบทอดจาก CWinApp โค้ดจะอยู่ในไฟล์ ThreadMFC.h และ ThreadMFC.cpp
  • 2. CThreadMFCDlg สืบทอดจาก CDialog โค้ดอยู่ในไฟล์ ThreadMFCDlg.h และ ThreadMFCDlg.cpp

เราจะแก้ไข Project นี้ ให้มีโครงสร้างการทำงานของ Thread เอาไว้ก่อน เมื่อท่านดูโครงสร้างเข้าใจแล้ว เราก็จะมาเขียนโค้ดให้ทำงานใน Thread นั้นกัน ดังนี้


ขั้นตอนที่ 1 ประกาศตัวแปรและฟังก์ชั่นต้นแบบที่จำเป็น


เราจะเปิดไฟล์ที่มีการประกาศคลาสไดอะล็อกขึ้นมา (ThreadMFCDlg.h) เขียนโค้ดประกาศโครงสร้างและตัวแปรต่างๆ ลงไป ดังนี้


#define WM_THREADCOMPLETE (WM_USER+1)


struct JOB
{
HWND mainwindow;
};


UINT ThreadProc(LPVOID pParam);


class CThreadMFCDlg : public CDialog
{
// Construction
public:
CThreadMFCDlg(CWnd* pParent = NULL);
void OnThreadComplete(WPARAM wParam, LPARAM lParam);

JOB myjob;
CWinThread *thread;


// Dialog Data
//{{AFX_DATA(CThreadMFCDlg)
enum { IDD = IDD_THREADMFC_DIALOG };
//}}AFX_DATA
………………….


จากโค้ด เราได้ประกาศค่าคงที่ WM_THREADCOMPLETE ให้มีค่าคงที่เป็น WM_USER+1 ซึ่งเป็นค่าคงที่ของสัญญาณที่เราจะให้ Thread ของเราตอบกลับมาเมื่อทำงานเสร็จแล้ว และเราก็ได้ประกาศโครงสร้าง JOB ซึ่งเป็นโครงสร้างที่เราจะส่งให้กับ Thread ในเวลาที่เราสร้าง Thread นั้นขึ้นมา เราจะเอาค่าของหน้าต่างหลัก (Handle of Main Window) ส่งไปให้กับ Thread พร้อมๆ กับค่าที่ต้องการให้ Thread ประมวลผล อันนี้เดี๋ยวเราจะมาเขียนเพิ่มเข้าไปภายหลัง


จากนั้นเราก็ได้ประกาศต้นแบบฟังก์ชั่น ThreadProc ซึ่งเป็นฟังก์ชั่นที่จะให้ Thread ของเราเข้าไปทำงานที่นี่.... สำหรับโค้ดในส่วนของคลาส เราก็ได้สร้างตัวแปรโครงสร้าง myjob และ object ของ CWinThread ที่เป็น Pointer ตั้งชื่อว่า thread และยังมีฟังก์ชั่น OnThreadComplete ซึ่งเป็นฟังก์ชั่นที่เราจะใช้ตอบรับเมสเสจ WM_THREADCOMPLETE ซึ่งเราจะต้องแมปเมสเสจตัวนี้กับฟังก์ชั่นนี้ในหัวข้อต่อไป


ขั้นตอนที่ 2 แมสเสจเสจ WM_THREADCOMPLETE


ให้ทำการแมปเมสเสจนี้กับฟังก์ชั่น OnThreadComplete ซึ่งจะเป็นฟังก์ชั่นที่ใช้ในการตอบรับเมื่อ Thread ทำงานเสร็จแล้ว เราจะต้องไปเขียนโค้ดเพื่อแมปเอาไว้ที่ไฟล์ ThreadMFCDlg.cpp ดังนี้


BEGIN_MESSAGE_MAP(CThreadMFCDlg, CDialog)
ON_MESSAGE(WM_THREADCOMPLETE,OnThreadComplete)
//{{AFX_MSG_MAP(CThreadMFCDlg)
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()


ขั้นตอนที่ 3 สร้างฟังก์ชั่น ThreadProc และ OnThreadComplete


ตอนแรก เราได้ประกาศต้นแบบฟังก์ชั่น ThreadProc เอาไว้ในไฟล์ .h แล้วใช่มั้ยครับ เราจะมาเขียนตัว body ของฟังก์ชั่นเอาไว้ในไฟล์ ThreadMFCDlg.cpp ดังนี้


UINT ThreadProc(LPVOID pParam)
{
JOB *jj=(JOB*)pParam;


// Processing your job


::PostMessage( jj->mainwindow , WM_THREADCOMPLETE,0,0);
return 0;
}


สำหรับฟังก์ชั่น OnThreadComplete ก็เขียนต่อไปได้เลย ดังนี้


void CThreadMFCDlg::OnThreadComplete(WPARAM wParam, LPARAM lParam)
{
TerminateThread(thread,0);
}


จากฟังก์ชั่น จะเห็นได้ว่าฟังก์ชั่นจะรับพารามิเตอร์ 1 ตัว ซึ่งก็คือ “ตัวงาน” นั่นเอง โดยเจ้าตัวงานนี้ เราจะส่งมาให้ในตอนที่เราสร้าง Thread ดังนั้น ฟังก์ชั่นนี้ จึงต้องเขียนรองรับเอาไว้ก่อน เพื่อเอางานไปใช้ โดยเราก็ได้สร้างโครงสร้างที่ชื่อ JOB ขึ้นมาในขั้นตอนที่ 1 และในโครงสร้าง JOB นี้ ก็มีตัวแปร mainwindow ซึ่งเป็น HWND นั่นก็คือ Handle ของหน้าต่าง เพราะเมื่อเวลาที่ฟังก์ชั่น ThreadProc จบการทำงานแล้ว เราจะต้องส่งสัญญาณตีกลับไปที่หน้าต่างหลัก ตรงนี้ล่ะครับ เราจึงต้องใช้ตัวแปร mainwindow ที่ส่งมาพร้อมกับ “งาน” อ้างถึงหน้าต่างหลักที่เป็นเจ้าของ Thread นี้ เพื่อบอกว่างานที่สั่งให้ทำนั้นสำเร็จลุล่วงด้วยดีแล้ว นั่นเอง โดยฟังก์ชั่น PostMessage เป็นฟังก์ชั่นที่ใช้ในการส่งสัญญาณเมสเสจตอบกลับไป มันจะส่งเมสเสจ WM_THREADCOMPLETE ไปให้หน้าต่าง jj->mainwindow พร้อมกับค่า LPARAM และ WPARAM เป็น 0 หมด เมื่อหน้าต่างหลักได้รับเมสเสจนี้ มันก็จะดูว่ามีการแมปเมสเสจนี้เอาไว้หรือเปล่า ถ้ามีมันก็จะเรียกฟังก์ชั่น OnThreadComplete ทันที และในฟังก์ชั่นนี้ก็จะทำการสิ้นสุดการทำงานของ Thread ไปเลย


ขั้นตอนที่ 4 เขียนโปรแกรมให้เริ่มการทำงานของ Thread


เราจะลองเขียนโปรแกรมให้เริ่มการทำงานของ Thread แบบง่ายๆ ดู โดยเราจะแก้ไขโครงสร้าง JOB ให้เป็นดังนี้


struct JOB
{
int number[1000];
int total;
HWND mainwindow;
};


จากนั้น ให้ท่านแก้ไขไดอะล็อกให้เป็นแบบนี้



ช่อง Edit Control ที่ท่านสร้าง ให้กำหนด ID เป็น IDC_SUM และสร้างตัวแปร DDX แบบ int ขึ้นมาตั้งชื่อว่า m_sum เอาไว้ จากนั้นให้ทำการแมปเมสเสจ BN_CLICKED ให้กับปุ่ม OK และเขียนโค้ดลงไปดังนี้


void CThreadMFCDlg::OnOK()
{
for (int i=0;i<1000;i++) mainwindow="m_hWnd;" total="0;

thread = AfxBeginThread(ThreadProc,&myjob);
}


จากโค้ด เราได้ทำให้ปุ่ม OK เป็นปุ่มที่เริ่มการทำงานของ Thread ดูให้ดีนะครับ มันจะชิ่งกันสนุกมาก ดูตามนะครับ.... เริ่มต้น เมื่อกด OK มันจะสุ่มค่าไปเก็บไว้ใน myjob.number ที่เราประกาศเอาไว้ โอเคนะครับ................
จากนั้นมันก็จะกำหนดค่า Handle ของหน้าต่างหลัก โดยใช้ตัวแปร m_hWnd ซึ่งเป็นตัวแปรที่ระบุถึงหน้าต่างหลักของโปรแกรมเรา เก็บค่านี้ไว้ใน myjob.mainwindow อันนี้ควรจะทำนะครับ จะไม่ทำก็ได้ แต่เราจะไม่มีทางรู้เลยว่าเมื่อใดที่ Thread ของเราทำงานเสร็จแล้ว เพราะมันไม่มีอะไรแจ้งกลับมาเลย ถูกมั้ยครับ.... ดังนั้น เราก็เรียกฟังก์ชั่น AfxBeginThread พร้อมกับกำหนด ThreadProc เพื่อบอกว่าฟังก์ชั่นอะไรเป็นฟังก์ชั่นที่จะให้ Thread ไปทำ และส่งค่า myjob ซึ่งส่งแบบ address ไปให้ เพื่อเป็นการให้ Thread มาใช้ข้อมูลที่อยู่ใน memory ตัวเดียวกันนั่นเอง เมื่อเป็นแบบนี้แล้ว ฟังก์ชั่นที่จะทำงานต่อไปก็คือฟังก์ชั่น ThreadProc .... ให้เขียนโค้ดลงไปในฟังก์ชั่นนี้ดังนี้


UINT ThreadProc(LPVOID pParam)
{
JOB *jj=(JOB*)pParam;


for (int i=0;i<1000;i++)>total+=jj->number[i];
}

PostMessage( jj->mainwindow , WM_THREADCOMPLETE,0,0);


return 0;
}


ในฟังก์ชั่นนี้ ดูให้ดีนะครับ จะเห็นว่าเราได้ประกาศ *jj ขึ้นมา และให้ jj นี้รับค่ามาจาก pParam ซึ่ง pParam นี้ล่ะ คือ &myjob ที่ส่งมาจาก AfxBeginThread นั่นเอง ตอนส่ง เราส่งมาเป็น &myjob ดังนั้น ตอนรับ เราจึงต้องเอา pointer มารับไงครับ......... และยังต้องรับโดยใช้บล็อกโครงสร้างเดียวกันด้วย เพราะ myjob ที่ส่งมานั้นเป็นโครงสร้าง JOB เวลารับ เราก็ต้องรับด้วยตัวแปรโครงสร้างที่เป็นแบบ JOB เหมือนกัน


ตัวแปรโครงสร้าง jj นี้ ไม่ใช่ตัวแปรใหม่นะครับ แต่มันจะเข้าไปอยู่ที่แอดเดรสเดียวกันกับ mydata ให้ท่านพิจารณาตรงนี้ให้ดีๆ พอยเตอร์จะเข้าไปสิงตัวแปรบริเวณนั้นและสามารถประมวลผลในแอดเดรสตรงนั้นได้เลย ซึ่งก็คือสิ่งที่ jj กำลังทำอยู่นั่นเอง เมื่อ jj เข้าไปอยู่ในตำแหน่งเดียวกับ mydata แล้ว มันก็จะทำการรวมค่าที่อยู่ในอาเรย์แต่ละช่อง number[0]… number[999] และเก็บเอาไว้ใน total เมื่อเสร็จกระบวนการนี้แล้ว มันก็จะทำการ PostMessage กลับไปให้กับหน้าต่างหลักประมาณว่า “นี่ๆ ๆ ๆ งานเสร็จแล้ว” โดยการส่งเมสเสจ WM_THREADCOMPLETE กลับไป โดยจะต้องระบุ Handle ของหน้าต่างหลักที่เป็นคนสั่งให้ Thread นี้ทำงาน นั่นก็คือ m_hWnd ซึ่งเราก็ได้ระบุลงไปแล้วไงครับ ในตัวแปร jj->mainwindow นั่นเอง ดังนั้น เราจึง PostMessage กลับไปได้ โดยเขียนโค้ดดังนี้


PostMessage( jj->mainwindow , WM_THREADCOMPLETE,0,0);


เจ้าตัวเลข 0,0 สองตัวข้างหลังนั้นก็คือ LPARAM กับ WPARAM ถ้าท่านต้องการส่งค่าอะไรกลับไปให้ทางนี้ด้วยก็ได้ครับ แต่ในกรณีนี้ เราต้องการเพียงแค่ “การสะกิด” ไปที่หน้าต่างหลักเท่านั้น การใช้ฟังก์ชั่น PostMessage สิ่งที่ต้องการก็คือ Handle ของหน้าต่างหลัก ฟังก์ชั่น PostMessage นี้เป็นฟังก์ชั่นของ Win32 API ที่ใช้ในการส่งเมสเสจ มีรูปแบบดังนี้


BOOL PostMessage(
HWND hWnd, // handle of destination window
UINT Msg, // message to post
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
);


ฟังก์ชั่นนี้จะต้องระบุว่าผู้รับเมสเสจ คือ หน้าต่างไหน เราก็บอกหน้าต่างที่เราเก็บเอาไว้ใน jj->mainwindow ไป ดังนั้น เมื่อเมสเสจนี้เกิดขึ้นที่โปรแกรมของเรา ฟังก์ชั่น OnThreadComplete ที่เราแมปเอาไว้ก็จะทำงาน เราก็จะเขียนโค้ดดักเอาไว้ดังนี้


void CThreadMFCDlg::OnThreadComplete(WPARAM wParam, LPARAM lParam)
{
m_sum=myjob.total;
UpdateData(FALSE);


TerminateThread(thread,0);
}


ดูนะครับ เมื่อฟังก์ชั่นนี้ถูกเรียกโดยแมสเสจ มันก็จะแสดงค่า myjob.total ออกมาที่ช่อง IDC_SUM นั่นเอง จากนั้นก็ปิดการทำงานของ Thread ไปเลย พอเรารันโปรแกรมก็จะได้ดังนี้



จากตัวอย่าง เรามาสรุปขั้นตอนกันนะครับ เมื่อกด OK แล้วจะเกิดอะไรขึ้น


1. เจ้า Thread จะถูกสร้าง


2. ฟังก์ชั่น ThreadProc ถูกเรียกให้ทำงาน โดยจะรับงานมาจาก mydata และทำการหาผลรวมของตัวเลข 1000 ตัว เก็บไว้ในตัวแปร mydata.total


3. เมื่องานเสร็จแล้ว มันก็จะส่งเมสเสจ WM_THEADCOMPLETE กลับไปให้หน้าต่างหลัก


4. ที่หน้าต่างหลัก มีการเขียนโค้ดดักเมสเสจ WM_THEADCOMPLETE นี้เอาไว้แล้ว ฟังก์ชั่น OnThreadComplete จึงถูกเรียก เพื่อแสดงค่าออกที่ไดอะล็อกและก็จบการทำงานของ Thread นั้นไป


***เทคนิคการสร้าง MessageBox ใน Visual C++ แบบกําหนด format ได้


เทคนิคนี้ ได้มาจากเว็บไซต์ต่างประเทศครับ ในบางครั้งเราต้องการแสดงค่าที่อยู่ในตัวแปรแบบ int , float หรือ char * ออกมา ซึ่งจะต้องใช้การ Debug เมื่อเวลารันโปรแกรม แต่วิธีการนี้ จะช่วยให้สามารถแสดงค่าออกมาได้โดยใช้การกําหนด format string


วิธีการก่อนหน้านั้น ใน Visual C++ จะใช้แบบนี้ครับ เวลาจะแสดงข้อมูลในตัวแปรออกมา โดยไม่ทําการ Debug


char buffer[256];
sprintf( buffer , "time = %d , value = %d ", time , value );
AfxMessageBox( buffer );


ก็ลําบากพอสมควร ก็เลยหาเทคนิคจาก codeguru.com มาใช้คือ MessageBox แบบกําหนด format ได้ครับ ดังนี้


int MsgBox(UINT nType, PSTR sz,...)
{
char ach[512];
va_list args;
va_start(args, sz);
wvsprintf (ach, sz, args);
int retval = AfxMessageBox (ach, nType == 0 ? MB_OKMB_ICONEXCLAMATION : nType);
return retval;
}


เวลาเรียกใช้ก็แบบนี้ครับ


MsgBox( "time = %d , value = %d ", time , value );


กําหนด format ในตัวเลยครับ... เทคนิคลักษณะนี้ก็นําไปใช้ในการดีบักโปรแกรมง่าย ๆ โดยไม่ต้องเข้าสู่โหมด Debug ครับผม


***เรื่องคลาสเบื้องต้นในภาษาซี++ เบื้องต้น


Class ใน C++คลาสคือกลุ่มหนึ่งๆที่มีการทำงาน (Procedure,Function) อยู่ และตัวแปร ต่างจาก struct ที่มีการใช้ Function Procedure แต่จะมีการเข้าถึง public private protected


รูปแบบของคลาส


class test : public first
{
public :
test();
~test();
};


การเข้าถึง
public: สามารถเข้าถึงได้เลย
private: ภายนอกคลาสเข้าถึงไม่ได้
protected: สำหรับคลาสที่สืบทอดและตัวเอง สามารถเข้าถึงได้

Contructor และ Destructor
Contructor เมื่อสร้างคลาสใหม่โดย new หรืออื่น จะต้องผ่านตัวนี้
ใช้โดย


ชื่อเดียวกับชื่อคลาส()
{

}



Destructor เมื่อคลาสได้ถูกทำลายโดย delete หรืออื่นๆ จะต้องผ่านตัวนี้ ใช้โดย


~ชื่อเดียวกับชื่อคลาส()
{

}



การสืบทอดคลาส
สืบทอดคลาส สามารถใช้คำสั่งที่อยู่ใน protected ได้เช่น


class first{
public:
void test()
{

}
}

class second : public first
{
void second()
{
test();
}
}


ช้างบนเป็นการใช้การสืบทอดตรง

ตัวหนา การสร้างคลาสใหม่
เวลาทำตัวแปรที่เป็นคลาสใหม่ทำได้ดังข้างล่าง


ชื่อคลาส ชื่อตัวแปร;


ถ้าเป็น Pointer ก็เป็นดังนี้


ชื่อคลาส *ชื่อตัวแปร;
เวลาจะใช้ก็ใช้ new กับ delete ได้เลย


***ประเภทของข้อมูลและตัวดำเนินการในภาษา c


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


ประเภทของข้อมูล

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


ตัวดำเนินการในภาษา C

เครื่องหมายดำเนินการในภาษา C แบ่งออกได้เป็น 3 ชนิด ใหญ่ๆ คือ

1. เครื่องหมายคณิตศาสตร์ (Arithmetic Operators)


2. เครื่องหมายเปรียบเทียบ (Relational and Logical Operators)


3. เครื่องหมายตรรก (Logical Operators)

เครื่องหมาย && (AND)


เครื่องหมาย (OR)


3. เครื่องหมาย ! (NOT)


ลำดับความสำคัญของตัวดำเนินการ


เป็นการเรียงลำดับการดำเนินการทางเครื่องหมายของภาษา C ว่าจะให้ความสำคัญกับเครื่องหมายใดก่อนหรือหลังในการดำเนินการทางคณิศาสตร์ โดยจะเรียงลำดับความสำคัญจากตารางต่อไปนี้


ลองมาดูตัวอย่างกันซักหน่อย



อธิบายโปรแกรม
จากตัวอย่างจะเห็นว่ามีการประกาศตัวแปร คือ x เป็นตัวแปรชนิดจำนวนเต็ม y และ z เป็นตัวแปรแบบทศนิยม x++ หมายถึง การนำค่า x มาบวกเพิ่มไปอีก 1 ส่วน z = (x+y)*2/3+1; เป็นการดำเนินการทางคณิตศาสตร์ซึ่งค่าที่ได้จะนำไปเก็บไว้ที่ตัวแปร z จากประโยค (x+y)*2/3+1 นี้ เราสามารถคำนวณโดยใช้วิธีลำดับความสำคัญของตัวดำเนินการได้ดังนี้


วงเล็บสำคัญสุด
( x+y) = 3+3.5 = 6.5 ----------> 6.5*2/3+1


เครื่องหมายคูณสำคัญสุด
6.5*2 = 13 ----------> 13/3+1


เครื่องหมายหารสำคัญสุด
13/3 = 4.333333 ----------> 4.333333+1


z = 5.333333


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


***.H คืออะไรกันแน่


อืม .H เรียกอีกอย่างว่า Header File หมายถึงไฟล์ที่อยู่ส่วนบนของประโยค main() ประกาศเอาไว้ เพื่อเรียกใช้คำสั่งที่ถูกจัดเก็บไว้ใน Header file นั้น ๆ


ภายในภาษา C มาตรฐานจะมี Header File มีทั้งหมด 15 ไฟล์ ดังต่อไปนี้
























assert.hctype.herrno.h
float.hlimits.hlocale.h
math.hsetjmp.hsignal.h
stdarg.hstddef.hstdio.h
stdlib.hstring.htime.h


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


1 assert.h ประกอบด้วยฟังก์ชั่นดังต่อไปนี้








assert()


2 ctype.h ประกอบด้วยฟังก์ชั่นดังต่อไปนี้
















isdigit()isupperislower
isalphaisprintisalnum
isspacetouppertolower


3 errno.h ประกอบด้วยมาร์โครและอ็อบเจ็คดังต่อไปนี้








EDOMERANGEerrno


4 float.h ประกอบด้วยรายละเอียดต่าง ๆ ดังนี้
































FLT_RADIXFLT_ROUNDSFLT_DIG
FLT_EPSILONFLT_MANT_DIGFLT_MAX
FLT_MAX_10_EXPFLT_MAX_EXPFLT_MIN
FLT_MIN_10_EXPFLT_MIN_EXPDBL_DIG
DBL_EPSILONDBL_MANT_DIGDBL_MAX
DBL_MAX_10_EXPDBL_MAX_EXPDBL_MIN
DBL_MIN_10_EXPDBL_MIN_EXP


5 limits.h ประกอบด้วยรายละเอียดต่าง ๆ ดังนี้




























CHAR_BITCHAR_MAXCHAR_MIN
INT_MAXINT_MINLONG_MAX
LONG_MINSCHAR_MAXSCHAR_MIN
SHRT_MAXSHRT_MINUCHAR_MAX
UCHAR_MINUINT_MAXULONG_MAX
USHRT_MAX


6 locale.h ประกอบด้วยฟังก์ชั่นดังต่อไปนี้








setlocalelocaleconv


7 math.h ประกอบด้วยฟังก์ชั่นดังต่อไปนี้




































acosasinatan
atan2coscosh
sinsinhtan
tanhexpfrexp
ldexploglog10
modfpowsqrt
ceilfabsfloor
fmod


8 setjmp.h ประกอบด้วยฟังก์ชั่นดังต่อไปนี้








setjmplongjmp


9 signal.h ประกอบด้วยฟังก์ชั่นดังต่อไปนี้








signalraise


10 stdarg.h ประกอบด้วยฟังก์ชั่นดังต่อไปนี้








va_startva_argva_end


11 stddef.h ประกอบด้วยรายละเอียดต่าง ๆ ดังนี้












ptrdiff_tsize_tNULL
offsetofwchar_t


12 stdio.h ประกอบด้วยฟังก์ชั่นดังต่อไปนี้




















































clearerrfclosefeof
ferrorfflushfgetpos
fopenfreadfreopen
fseekfsetposftell
fwriteremoverename
rewindsetbufsetvbuf
tmpfiletmpnamprintf
scanffgetcfgets
fputcfputsgetc
getchargetsputc
putcharputsungetc
perror


13 stdlib.h ประกอบด้วยฟังก์ชั่นดังต่อไปนี้












































atofatoiatol
strtodstrtolstrtoul
callocfreemalloc
reallocabortatexit
exitgetenvsystem
bsearchqsortabs
divlabsldiv
randsrandmblen
mbstowcsmbtowcwcstombs
wctomb


14 string.h ประกอบด้วยฟังก์ชั่นดังต่อไปนี้




































memchrmemcmpmemcpy
memmovememsetstrcat
strncatstrchrstrcmp
strncmpstrcollstrcpy
strncpystrcspnstrerror
strlenstrpbrkstrrchr
strspnstrstrstrtok
strxfrm


15 time.h ประกอบด้วยฟังก์ชั่นดังต่อไปนี้
















asctimeclockctime
difftimegmtimelocaltime
mktimestrftimetime


รายละเอียดของแต่ละฟังก์ชั่น ท่านสามารถศึกษาเพิ่มเติมได้จากคู่มืออ้างอิง


***โปรแกรมแรกของภาษา c


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


โครงสร้างของภาษา C


เรามาดูโครงสร้างของภาษา C อย่างละเอียดกันอีกครั้งนะครับ


บรรทัดที่ 1 คือ ประกาศส่วนหัวของโปรแกรมโดยการนำเอาไฟล์ stdio.h จาก library เข้ามาใช้งาน
บรรทัดที่ 2 คือ จุดเริ่มต้นของ mian โปรแกรม
บรรทัดที่ 3 คือ เครื่องหมายปีกกาเพื่อแสดงจุดเริ่มต้นของ main
บรรทัดที่ 4 คือ เนื้อหาภายใน main โปรแกรม
บรรทัดที่ 5 คือ เครื่องหมายปีกกาเพื่อแสดงจุดสิ้นสุดของ main


โปรแกรมแรกของภาษา C


เราจะมาลองเขียนโปรแกรมแรกของเรากันเลยนะครับ โดยผมจะสร้าง Project ชื่อว่า Hello และไฟล์ที่ชื่อว่า Hello.c นะครับ ใครยังสร้าง Project จาก Visual C++ ไม่เป็นให้ย้อนกลับไปดูบทความช่วงแรกๆ ด่วนเลยนะครับ ส่วนใครที่ไม่ได้ใช้โปรแกรม Visual C++ แต่ใช้ตัวคอมไพล์เลอร์ตัวอื่น เช่น Turbo c ก็ใช้เขียนโปรแกรมของบทความนี้ได้เหมือนกันครับเพียงแต่ท่านต้องใช้โปรแกรมของท่านเป็นอยู่แล้วนะครับ เพราะบทความของเราจะเน้นเฉพาะโปรแกรม Visual C++ ที่ส่วนใหญ่จะนิยมใช้กัน เมื่้อสร้าง Project เสร็จแล้วให้พิมพ์โค้ดลงไปตามนี้นะครับ



วิธีการ compile และ run โปรแแกรม


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


1. กดที่ปุ่มนี้จะเป็นการ compile เพื่อตรวจสอบความถูกต้องของโปรแกรม


ผลที่ได้จะรายงานออกมาที่ส่วนล่างสุดของหน้าต่างของโปรแกรม Visual C++



2. จากนั้นให้กดไปที่ปุ่ม build


ผลที่ได้จะรายงานออกมาที่ส่วนล่างสุดของหน้าต่างของโปรแกรม Visual C++ เช่นกัน



3. สุดท้ายให้เรากดที่ปุ่ม execute program เพื่อทำการรันผลลัพธ์ออกมา


ผลที่ได้จะแสดงข้อความ Hello webthaidd.com ออกสู่จอภาพที่เป็นหน้าต่าง Dos



จากขั้นตอนทั้ง 3 ดังกล่าวเราอาจจะกดปุ่ม execute program อย่างเดียวก็ได้ซึ่งจะเป็นการ compile ,build และก็ run โปรแกรมให้เราเสร็จในครั้งเดียวเลย เหมาะสำหรับคนใจร้อน ซึ่งในการเขียนโค้ดแต่ละครั้งถ้าเราไม่กดเซฟไว้เมื่อมาทำการ compile ,build หรือ run อย่างใดอย่างหนึ่งนั้น โปรแกรมจะทำการเซฟให้เราโดยอัตโนมัติทันที


***ฟังก์ชัน printf()และ scanf()


ในบทความนี้ผมจะมากล่าวถึงเรื่องคำสั่งในการรับและแสดงผลข้อมูล (I/O Function) คือ printf() และ scanf() ที่ใช้ในภาษา C กันนะครับ ซึ่งเวลาที่เราต้องการให้โปรแกรมของเรารับข้อมูลเข้าไปหรือแสดงผลการคำนวณออกมาทางหน้าจอ เราจำเป็นต้องใช้ฟังก์ชันทั้ง 2 มาใช้งานให้ถูกต้อง ลองมาดูกันเลยครับ


ฟังก์ชัน printf()

เป็นฟังก์ชันที่ใช้ในการแสดงผลข้อมูลออกทางจอภาพ มีรูปแบบดังนี้







printf(control, argument)



เช่น printf(“i = %d \n”,i); จะสังเกตว่า ภายใน “ “ จะมีเครื่องหมาย % อยู่ซึ่งเราจะเรียกว่า Format Code ซึ่งจะเป็นตัวกำหนดให้ข้อมูลที่อยู่ในตำแหน่งหลังเครื่องหมาย , แสดงออกมา โดยจะมีความหมายดังตาราง


ลองมาดูตัวอย่างจากโปรแกรมต่อไปนี้ครับ



อธิบายโปรแกรม
จาก โปรแกรมนี้เราจะกำหนดตัวแปรออกเป็นชนิดต่างๆ 4 ชนิด แล้วกำหนดค่าเริ่มต้นให้กับตัวแปรเหล่านั้นแล้วให้แสดงผลลัพธ์ที่ตัวแปร เหล่านั้นเก็บไว้ออกมาทางจอภาพโดยใช้ฟังก์ชัน printf() และจะต้องคำนึงถึง Format Code ด้วย


printf("a = %c\n",a); --------------> ใช้ %c เพราะ a เป็น char
printf("x = %d\n",x); --------------> ใช้ %d เพราะ x เป็น int
printf("y = %f\n",y); --------------> ใช้ %f เพราะ y เป็น float (ทศนิยม)
printf("z = %f\n",z); --------------> ใช้ %f เพราะ z เป็น double (ทศนิยม)


นอกจากนั้นการแสดงผลลัพธ์ที่เป็นจุดทศนิยมเราสามารถกำหนดได้ว่าจะให้มีทศนิยมกี่ตำแหน่งโดยการกำหนดที่ Format Code ดังตัวอย่างต่อไปนี้


printf("y = %.2f\n",y); --------------> ใส่ค่า .2 หมายถึง แสดงทศนิยม 2 ตำแหน่ง
printf("z = %.3f\n",z); --------------> ใส่ค่า .3 หมายถึง แสดงทศนิยม 3 ตำแหน่ง


ฟังก์ชัน scanf()

เป็นฟังก์ชันที่ใช้ในการแสดงผลข้อมูลออกทางจอภาพ มีรูปแบบดังนี้







scanf(control, argument)


ฟังก์ชัน scanf จะมีลักษณะคล้ายกับ printf โดยเราจะต้องใส่ Format Code ไว้ในเครื่องหมาย " " และระบุตัวแปรที่จะมารับข้อมูลจากผู้ใช้ที่ป้อนเข้ามา โดยจะต้องมี & นำหน้าตัวแปรที่เราต้องการใส่ค่าเสมอ ยกเว้นตัวแปรที่เป็นอะเรย์ ลองมาดูตัวอย่างจากโปรแกรมต่อไปนี้ครับ


อธิบายโปรแกรม
จากตัวอย่างมีการประกาศตัวแปร คือ a เป็นตัวแปรชนิด int ถัดมาเป็นการแสดงคำพูด Enter number : ที่หน้าจอ จากนั้นฟังก์ชัน scanf() จะทำงานโดยการรอรับข้อมูลจากผู้ใช้ให้เราพิมพ์ตัวเลขจำนวนเต็มใส่ลงไป ตัวเลขที่เราพิมพ์ลงไปนั้นจะถูกเก็บไว้ที่ตัวแปร a แล้วจึงแสดงผลลัพธ์ของตัวเลขนั้นอีกครั้งที่จอภาพ


scanf("%d" ,&a); --------------> %d เป็นการระบุรูปแบบของตัวแปรที่จะมารองรับค่า, &a คือ ตัวแปรที่จะมารับค่า


สำหรับฟังก์ชัน printf() และ scanf() นั้นจะเป็นฟังก์ชันพื้นฐานที่จะใช้กันบ่อยๆ ในภาษา C เราควรฝึกใช้งานให้คล่องนะครับ ส่วนใน C++ ฟังก์ชันทั้ง 2 นี้จะถูกเปลี่ยนแปลงไปและการใช้งานก็ต่างกันนิดหน่อยซึ่งผมจะยังไม่กล่าวถึงในตอนนี้นะครับ


***ฟังก์ชั่นคืออะไร


เมื่อเราพูดถึงคำว่า ฟังก์ชั่น จะหมายถึง ความรับผิดชอบต่อหน้าที่ของตนเอง ยกตัวอย่างเช่น


add() เป็นฟังก์ชั่น ทำการบวก
subtract() เป็นฟังก์ชั่น ทำการลบ
multiply() เป็นฟังก์ชั่น ทำการคูณ
devision() เป็นฟังก์ชั่น ทำการหาร
printf() เป็นฟังก์ชั่นแสดงผลบนจอภาพคอมพิวเตอร์
scanf() เป็นฟังก์ชั่นรับข้อความจากแป้นคีย์บอร์ด


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


ก่อนที่เราจะศึกษารายละเอียดในส่วนต่อไป ผมอยากทำความเข้าใจกับผู้เรียนเสียก่อนว่า ในยุคแรก ๆ ระบบคอมพิวเตอร์ ใช้รหัสฐานสองในการเขียนโปรแกรม ต่อมาจึงได้มีการพัฒนาภาษา Assembly ซึ่งเป็นภาษาระดับต่ำ ในเวลาต่อมา เมื่อโปรแกรมคอมพิวเตอร์ มีความสลับซับซ้อนมากขึ้น จึงได้พัฒนาโปรแกรมโดยใช้หลักการของ Structure ซึ่งภาษาที่สนับสนุนหลักการดังกล่าวได้แก่ C, Pascal, Basic และอื่น ๆ ในระยะนั้น การพัฒนาโปรแกรมดูเหมือนว่า จะไม่มีปัญหาอะไรเพราะสามารถสร้างโปรแกรมได้ทุกรูปแบบดีอยู่แล้ว แต่ในความเป็นจริงปัญหาที่เกิดขึ้นคือ การเขียนโปรแกรม ที่มีความสลับซับซ้อนสูง ๆ ไม่สามารถทำได้ดีนักด้วยภาษาที่ใช้หลักการ Structure จึงเป็นเหตุผลที่ต้องมีการพัฒนาแนวคิดใหม่ขึ้น นั่นคือหลักการที่ชื่อว่า Object Oriented โดยใช้แนวคิด คือรวมแนวคิดแบบ Structure เข้ากับการมองปัญหาเป็นวัตถุ หรือ Object ซึ่งโปรแกรมที่สนับสนุนแนวคิดดังกล่าวนี้คือ C++, Java, Python และอื่น ๆ นอกจากนั้นในยุคปัจจุบันได้มี .Net ของบริษัทไมโครซอฟต์ซึ่งได้แก่ Visual C++ .NET และ Visual Basic .NET โดยสนับสนับสนุนแนวคิดแบบ Object Oriented


ก่อนจะจบบทความนี้ ผมอยากจะสรุปความแตกต่างระหว่าง C และ C++ ให้ผู้อ่านทราบพอเป็นสังเขปดังต่อไปนี้
1. ภาษาซี มีจุดเด่นสูงสุดคือคำสั่ง struct ย่อมาจาก structure หมายถึงภาษาโครงสร้าง
2. ภาษา C++ มีจุดเด่นสูงสุดคือคำสั่ง Class ซึ่งมองปัญหาต่าง ๆ ออกเป็นส่วน ๆ เป็นกลุ่มก้อนหรือเป็นคลาส
3. ภาษา C และ C++ มีชนิดข้อมูลอันเดียวกัน เช่น มีตัวแปรเลขจำนวนเต็ม, ตัวแปรทศนิยม, ตัวแปร double และชนิดอื่น ๆ เหมือนกัน
4. ภาษา C และ C++ มีคำสั่งในการวนลูปทั้งหลาย เช่น for loop และ do while loop ที่มีรูปแบบการใช้งานเหมือนกัน 100 %
5. ภาษา C รับและแสดงผลข้อมูลโดยใช้ Header file ชื่อ stdio.h โดยใช้คำสั่ง printf() เพื่อแสดงผลข้อมูลให้ปรากฎลนจอภาพคอมพิวเตอร์ และคำสั่ง scanf() เพื่อรับข้อมูลจากแป้นคีย์บอร์ด


ภาษา C++ รับและแสดงผลข้อมูลจาก Header file ชื่อ iostream.h โดยใช้คำสั่ง cout เพื่อแสดงผลข้อมูลให้ปรากฎบนจอภาพคอมพิวเตอร์ และคำสั่ง cin เพื่อรับข้อมูลจากแป้นคีย์บอร์ด


***การเขียน โปรแกรมสร้าง Link List ด้วยภาษา C


Link List เป็นการจัดการกับ ข้อมูล ไม่ว่าจะเพื่อ เก็บใว้ใน memory ชั่วคราว หรือเพื่อ เตรียมข้อมูล เพื่อเก็บลง text file


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


ขั้นแรก เราต้องสร้าง structure เพื่อความสะดวก ในการใช้ pointer เรียก ข้อมูลขึ้นมาใช้


struct node{



int data;
struct node *next;
//pointer next เป็นตัวบอกว่า node ถัดไป อยู่ที่ address ไหน


}datanode;


กำหนดค่าเริ่มต้นของ pointer


struct node *first;
struct node *TempNode;
first = (struct node *)
calloc(sizeof(datanode),1);
// ให้ first เป็นตำแหน่งเริ่มต้นของ Link list
TempNode=first;


ทำการสร้าง Link List โดยในที่นี้ จะให้ ตัวแปรชื่อ datainput เป็นตัวแปรที่รับข้อมูลเข้ามา ไม่ว่าจะ input จาก keyboard หรือ แหล่งอื่นตามที่คุณต้องการ


if (TempNode==first) // เป็นข้อมูล แรก ใน Link List
{



TempNode->data=datainput;
nodetmp=(struct node *) calloc(sizeof(datanode),1);
TempNode->next=nodetmp;
TempNode=nodetmp;


}else if (TempNode!=first) // ถ้าไม่ได้เป็นข้อมูลแรกใน Link List
{



TempNode->data=datainput;
nodetmp = (struct node *) calloc(sizeof(datanode),1);
TempNode->next=nodetmp;


}


การท่องไปใน Link List ( Link List traversal)


nodetmp=first;
while (nodetmp!=NULL) {



printf ("%dn",nodetmp->data);
// จะ print หรือว่า นำ data ไปใช้ทำอะไร ก็ตามสะดวกเลยครับ
nodetmp=nodetmp->next;


}


การลบ node ก็ไม่มีอะไรมากเลย ครับ แค่เปลี่ย pointer ของ node ก่อนที่จะลบ ไปชี้ node->next ของตัวที่จะลบ ถ้าไม่เข้าใจ ดูจากตัวอย่างดีกว่าครับ


pre->next=nodedel->next;


ผมสมมุติให้ pointer pre คือ node ก่อน ตัวที่ต้องการจะลบ ส่วน nodedel คือ node ที่เราต้องการจะลบ ส่วนการ insert หรือการ แทรก ใน Link List ขั้นแรก เราก็ต้องหา node ที่เราจะทำการ แทรก คล้ายๆ กับ การลบ แหละครับ ผมก็จะสมมุติ ว่า pointer pre เป็น node ที่ เราจะแทรกข้อมูลไป ต่อจาก node นี้ โดยที่มี new เป็น address ของ ข้อมูลใหม่ที่เราต้องการทำไปแทรกใน Link List


new = (struct node *) calloc(sizeof(datanode),1);
new->data=datainput;
new->next=pre->next;
pre->next=new;


***การ Convert ระหว่าง char* กับ int ใน C


บทความนี้ จะมาแนะนําการใช้ฟังก์ชั่น 2 ตัวใน C กัน มันถูกประกาศอยู่ใน stdlib.h เป็นฟังก์ชั่นครับ ไม่ใช่ฟังก์ชั่นตัวใหม่อะไรในภาษา C++ นะครับ มันยังอยู่ในขอบเขตของการศึกษา C ได้.... มันเป็นฟังก์ชั่นในการแปลงจาก char* เป็น int และแปลงจาก int เป็น char *


กาลครั้งหนึ่ง สมาชิกท่านนึงได้ยิงถามมาว่า เวลารับค่าในเกมเนี่ย เราสร้าง GUI ที่ใช้ Text Box เวลารับค่าตัวเลขเข้ามา มันจะเป็น char * คือ เอา char num[30]; เข้ามาเก็บค่าตัวเลข แต่เมื่อเราจะเอาค่าตัวเลขนี้ไปใช้ประมวลผล ไปคํานวณ นั่นล่ะครับ จะทําอย่างไร เราจะต้อง convert จาก char[] ให้เป็น int ซึ่งจะใช้ฟังก์ชั่นที่ชื่อว่า อะต๊อย (atoi) แต่ถ้าจะเปลี่ยนจาก int เป็น char[] ให้ใช้ อิเต๊า (itoa) ทั้งสองฟังก์ชั่นมีรายละเอียดดังนี้ครับ (จาก MSDN)


char *_itoa( int value, char *string, int radix );


int atoi( const char *string );


จากข้างต้น itoa เป็นการแปลงจาก int -> char* แต่ถ้า atoi จะแปลงจาก char* -> int แต่ก็ยังมีอีกตัว ชื่อว่า


double atof( const char *string );


อันนี้เป็นการแปลงให้เป็น float ครับ (char[] -> float)


เราจะใช้ก็ต่อเมื่อ..... เรามีตัวเลขอยู่ใน char[] และเราต้องการเอามันมาประมวลผล นั่นล่ะครับ เรียกใช้มันซะ ลองดูตัวอย่าง code ต่อไปนี้


ตัวอย่างการใช้ atoi แปลงข้อความ 1234 ให้เป็น int


int num=atoi("1234");
num++;
printf("Num = %d",num);


ตัวอย่างการใช้ itoa แปลงตัวเลข 590 ให้เป็น char และแสดงผลออกมาโดยหาขนาดของ string มาด้วยล่ะ


int n=590;
char buff[50];
itoa(n,buff,10);
printf("data=%s (%d)\n",buff,strlen(buff));


คําสั่ง itoa นั้น พารามิเตอร์ตัวสุดท้ายก็คือฐานครับ ว่าจะเป็นเลขฐาน 10 ฐาน 2 หรือฐาน 16 ก็ใส่ลงไปครับ


***ส่วนประกอบของโปรแกรมและการใช้ภาษาไทย


โปรแกรมแรกของภาษาซี


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


วิธีเปิด Project ที่มีไฟล์ Source อยู่มีดังนี้นะครับ
1. ไปที่เมนู File แล้วคลิ๊กที่ open Workspace เพื่อเปิด Project ขึ้นมาครับ


2. จะปรากฏหน้าต่าง Dialog Box Open Workspace มาให้ ให้คุณคลิ๊กที่ Look in ครับ ตามลูกศรเลย


3. การเปิด Project งาน
3.1 เมื่อคลิ๊กตามข้อ 2. แล้วนะครับ จะมีลักษณะเป็น List ให้คุณเลือก Directory ที่เก็บไฟล์ Project ไว้ที่เราสร้างไว้ครั้งก่อน อย่างของผมนี้จะเป็น Drive E: นะครับ ถ้าคุณ เก็บไว้ไดร์ฟไหนก็เลือกไดร์ฟนั้นครับ
3.2 เสร็จแล้ว ดับเบิ้ลคลิ๊ก (หรือกด Open) ที่ Program Files (ตรงนี้ขอละไว้ ณ ครับ เมื่อเลือก Drive แล้วจะมี Directory ในไดร์ฟนั้นๆ ขึ้นมาครับ)
3.3 ก็จะปรากฏ Directory ใน Program Files ให้ดับเบิ้ลคลิ๊ก(หรือกด Open) ที่ Microsoft Visual Studio
3.4 จะปรากฏ Directory ใน Microsoft Visual Studio ขึ้นมา ให้ดับเบิ้ลคลิ๊ก(หรือกด Open) ที่ MyProject ครับ


4. ภายใน Directory MyProjects นะครับจะมี Project ที่เราได้สร้างขึ้นก่อนหน้านี้ ชื่อว่า First ครับ ให้คุณดับเบิ้ลคลิ๊ก (หรือกด Open) เพื่อเข้าไปใน Directory


5. จะมี Folder Debug และก็ไฟล์ First.dsw ซึ่งเป็น ไฟล์ Workspace ให้เปิดขึ้นมาครับ


6. เปิด Project ขึ้นมาเรียบร้อยแล้ว


ต่อมาจะมาดูส่วนประกอบคร่าวๆ ของโปรแกรมกันก่อนนะครับ

1. ส่วนของ Menu Bar จะมีคำสั่งหลักๆ ที่ใช้ในโปรแกรม
2. ส่วนของ Standard Toolbar หรือทูลบาร์มาตรฐานจะมีลักษณะเป็นภาพสัญลักษณ์ใช้แทนคำสั่งจากเมนูบาร์ที่เรามักใช้บ่อยๆ เช่น New Text File, Open, Save, Copy และ Paste เป็นต้น
3. หน้าต่าง Workspace
4. หน้าต่าง Source หรือ Editor เป็นหน้าต่างที่ใช้แก้ไขไฟล์ Source ต่างๆ
5. หน้าต่าง Output เป็นหน้าต่างแสดงผลลัพธ์ (แถบนี้อาจจะยังไม่ปรากฏนะครับ แต่ถ้าคุณ Compile แล้วแถบนี้จะปรากฏขึ้นมาอัตโนมัติ)
6. Status Bar หรือ แถบแสดงสถานะว่าโปรแกรมนั้นกำลังทำคำสั่งใดอยู่


การปรับแต่งให้สามารถใช้ภาษาไทยใน Source หรือ Editor
ปกติจะพิมพ์ได้เป็นภาษาอังกฤษนะครับ แม้คุณจะกดตัวหนอน (~) เพื่อเปลี่ยนภาษาแล้วก็ตาม เพราะฉะนั้น ต้องเซ็ต Font ที่สามารถรองรับภาษาไทยได้ครับ ขั้นตอนมีดังนี้
1. ไปที่เมนู Tools แล้วคลิ๊กที่ Options


2. คลิ๊กที่ลูกศรชี้ในภาพด้านล่าง จนเลื่อนมาสุด


3. จนเจอ Tab Format ให้คลิ๊กครับ


4. คลิ๊กที่ Source Windows ใน Category แล้วเลือก Font ครับ จะเลือก Font ไหนก็ได้ครับที่รองรับ ภาษาไทย (ส่วนมากจะมี UPC ตามหลัง อาทิเช่น AngsanaUPC, CordiaUPC เป็นต้น อีกทั้งคุณยังสามารถปรับเลือกขนาดได้ครับ ในกรณีนี้เป็นการปรับหน้าต่าง Source (Source Windows) ที่ไว้สำหรับปรับ ในส่วนที่ Code โปรแกรมนะครับ ถ้าต้องการปรับส่วนอื่น ก็ใช้วิธีการเดียวกันครับ


บทความจากเว็บไซต์ webthaidd.com

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

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