Recommended
More Related Content
What's hot
What's hot (20)
Viewers also liked
Viewers also liked (18)
Similar to โปรแกรม ภาษาซี
Similar to โปรแกรม ภาษาซี (20)
โปรแกรม ภาษาซี
- 2. 2 ภาษา BCPL ภาษา B ภาษา C 1. ประวัติความ เป็นมา 1. ประวัติความ เป็นมา บนเครื่อง PDP-7 (UNIX) พ.ศ. 2513 พ.ศ. 2515 โดย เดนนิช ริทชี่ Basic Combined Programming Language
- 3. 3 # header ส่วนที่ 1 main( ) { /* เริ่มโปรแกรม */ declaration ส่วนที่ 2 ……… คำาสั่งต่าง ๆ ส่วนที่ 3 } 2. โครงสร้างพื้นฐาน ของภาษาซี 2. โครงสร้างพื้นฐาน ของภาษาซี
- 4. 4 ป็นส่วนที่ระบุให้ซีคอมไพเลอร์เตรียมการทำางานที่ก นส่วนนี้ไว้ โดยหน้าคำาสั่งจะมีเครื่องหมาย # เช่น # include <stdio.h> ป็นการระบุให้นำาไฟล์ stdio.h มารวมกับไฟล์นี้ เพ สามารถใช้คำาสั่งที่อยู่ในไฟล์นี้มาใช้งานได้ # define START 0 ป็นการกำาหนดค่าคงที่ให้กับตัวแปร START โดยให้มีค่าเป็น 0 # define temp 37 ป็นการกำาหนดให้ตัวแปร temp มีค่าเท่ากับ 37
- 5. 5 ส่วนที่ 2 declaration เป็นการกำาหนดชนิด ข้อมูลที่จะใช้ใน โปรแกรมซึ่งตัวแปรหรือข้อมูลต่าง ๆ นั้นจะต้องถูก ประกาศ(declare) ในส่วนนี้ก่อน จึง จะสามารถนำาไปใช้ ในโปรแกรมได้ เช่น int stdno; เป็นการกำาหนดว่าตัวแปร stdno เป็น ข้อมูลชนิดจำานวนเต็ม หรือ interger ซึ่งอาจได้แก่ค่า 0,4,- 1,-3,…. เป็นต้น
- 6. 6 ody คือส่วนของตัวโปรแกรม โดยจะต้องเริ่มต้นด้ว main ( ) แล้วใส่เครื่องหมายกำาหนดขอบเขตเริ่มต้นข ปรแกรมคือ { หลังจากนั้นใส่คำาสั่งหรือฟังก์ชันต่าง ะคำาสั่งหรือฟังก์ชันนั้น ๆ จะต้องปิดด้วยเครื่องหมาย มื่อต้องการจบโปรแกรมให้ใส่เครื่องหมาย } ปิดท้าย main ( ) { /* เริ่มต้นโปรแกรม */ คำาสั่งต่าง ๆ ; ฟังก์ชัน; …………… …………... } /* จบโปรแกรม */
- 7. 7 เครื่องหมายต่าง ๆ { } - เป็นตัวกำาหนดขอบเขตหรือบล็อก ของฟังก์ชัน ( ) - เป็นการระบุตัวผ่านค่าหรือ อาร์กิวเมนต์ให้กับฟังก์ชัน ถ้าภายในวงเล็บไม่มีข้อความใด ๆ แสดงว่าไม่มีตัวผ่าน ค่าที่ต้องการระบุสำาหรับฟังก์ชัน นั้น ๆ /* */ - เป็นการกำาหนด comment หรือ
- 8. 8 # include <stdio.h> int main (void ) { printf(“Hello, Good morning. n”); } ตัวอย่างโปรแกรม โปรแกรมที่ 1 เป็นโปรแกรมสั่งพิมพ์ข้อความ Hello, Good morning
- 9. 9 โปรแกรมที่ 2 # include <stdio.h> main ( ) { float point; printf("nnPut your score inn"); scanf("%f", &point); printf("Your score is %f pointnn", point); } เป็นโปรแกรมรับคะแนนและเก็บค่าที่ตัวแปร poi หลังจากนั้นสั่งให้มีการพิมพ์คะแนนออกมา
- 10. 10 นิดของข้อมูลและตัวแปรในภาษาซีนิดของข้อมูลและตัวแปรในภาษาซี การกำาหนดชื่อตัวแปร หลักการมีดังนี้ 1. ต้องขึ้นต้นด้วยตัวอักษร 2. ห้ามใช้เครื่องหมายทาง คณิตศาสตร์ในชื่อตัวแปร 3. สามารถใช้เครื่องหมาย underline ‘_’ ได้ 4. ห้ามใช้ reserved words เช่น int, float, etc. Note: คอมไพเลอร์ในภาษาซีสามารถเห็น ความแตกต่างของชื่อตัวแปรได้ยาวไม่เกิน 8
- 11. 11 แบบข้อมูลหรือชนิดของตัวแปรต่าง ๆ ที่ กำาหนดไว้ในภาษาซี char ชนิดของตัวอักษรหรือ อักขระ int ชนิดจำานวนเต็มปกติ short ชนิดจำานวนเต็มปกติ long ชนิดจำานวนเต็มที่มีความ ยาวเป็น 2 เท่า unsigned ชนิดของเลขที่ไม่คิด เครื่องหมาย float ชนิดเลขมีจุดทศนิยม แบบข้อมูลและขนาด
- 12. 12 ชนิดข้อมูล ( )เนื้อที่สำาหรับเก็บไบต์ ค่าตัวเลขที่เก็บ Char 1 เก็บตัวอักษรASCII 1 0 255ได้ ตัวหรือจำานวนเต็มระหว่าง ถึง Int 2 –32768 32767ค่าตัวเลขระหว่าง ถึง Short 2 –32768 32767ค่าตัวเลขระหว่าง ถึง Long 4 ค่าตัวเลขประมาณ±2000ล้าน Unsigned Unsignedshort=2 Unsignedlong=4 0 65535ค่าตัวเลขระหว่าง ถึง 0 4000ค่าตัวเลขระหว่าง ถึง ล้าน Float 4 10ได้ค่าตัวเลขยกกำาลัง x โดยx –37 +38มีค่าระหว่าง ถึง Double 8 ความถูกต้องของตัวเลขจะมีค่าสูงขึ้น เนื้อที่ในหน่วยความจำาและค่าตัวเลขที่เก็บของข้อม
- 14. 14 ข้อมูลและตัวแปรชนิดอักขระ ขระแทนด้วย char ‘ ’โดยอยู่ภายในเครื่องหมาย เ # include <stdio.h> main ( ) { char reply; reply = ‘y’; ………………… }
- 15. 15 การให้ค่าอักขระที่เป็นรหัสพิเศษหรือ รหัสควบคุม อักขระเหล่านี้ไม่สามารถให้ค่าโดยตรง แต่จะทำาได้โดยการให้ค่าเป็นรหัส ASCII ซึ่ง จะเขียนในรูปของเลขฐานแปด โดยใช้ ‘เครื่องหมาย ’ นำาหน้า หรือใช้ตัวอักขระที่ กำาหนดให้กับรหัสนั้น ๆ เขียนตาม ‘เครื่องหมาย ’ สำาหรับรหัสบางตัว เช่น รหัส BELL แทนด้วย ASCII 007 ซึ่ง กำาหนดได้ดังนี้ beep = ‘007’;
- 16. 16 ตัวอย่างโปรแกรม # include <stdio.h> main ( ) { char newline; newline = ‘n’; printf(“Hello, Good morning. %c”,newline); printf(“Hello, Good morning.n”); }
- 17. 17 อมูลและตัวแปรชนิดจำานวนเต็ม จำานวนเต็มในภาษาซีสามารถใช้แทนได้ 4 รูปแบบคือ int, short, long และ unsigned สำาหรับการกำาหนดตัวแปรแบบ unsigned คือจำานวนเต็มที่ไม่คิดเครื่องหมายนั้นจะต้อง ใช้ควบคู่กับรูปแบบข้อมูลจำานวนเต็มชนิดอื่น ๆ คือ int หรือ short หรือ long ตัวอย่าง เช่น unsigned int plusnum; unsigned long width; unsigned short absno; /*
- 18. 18 อมูลและตัวแปรชนิดเลขมีจุดทศนิยม รับเลขมีจุดทศนิยมนั้นแทนได้ 2 แบบคือ float และ ดย double เก็บค่าได้เป็น 2 เท่าของ float นทางวิทยาศาสตร์ที่ต้องการความละเอียดในการเก เก็บในรูปแบบนี้ คือเก็บแบบเอ็กโพเนนซ์ ดังตัวอย ข แสดงแบบวิทยาศาสตร์ แบบเอ็ก 0,000 9.0*109 9.0e9 0 3.45*105 3.45e5 3 6.3*10-4 6.3e-4 924 9.24*10-6 9.24e-6
- 19. 19 ข้อมูลและตัวแปรแบบสตริง งหมายถึงตัวอักขระหลาย ๆ ตัวมาประกอบกันเป็นข ำาตัวแปรหลาย ๆ ตัวมาเก็บรวมกันในภาษาซีนี้เรียก ดังนั้นข้อมูลแบบสตริงคือ อะเรย์ของตัวอักขระ นั่นเอ งหมายของอะเรย์คือ [ ] รูปแบบการกำาหนดสตริง งนี้ char name[30]; ตัวแปร name เป็นชนิด char ที่มีความยาว 30 ตัวอ ป็น อะเรย์ การเก็บนั้นจะเก็บเรียงกันทีละไบต์ และไ null คือ 0 ดังนั้นจะเก็บได้จริงเพียง 29 ตัวอักษร
- 20. 20 าหนดค่าให้ตัวแปรและการส่งผลลัพธ์ ารกำาหนดค่าให้ตัวแปรอาจทำาได้โดยกำาหนดในโป าหนดในขณะที่มีการกำาหนดชนิดก็ได้ เช่น ( ) age = 18; at height; ight = 172.5; ntf(“Mr. Surasak is %d years old”,age); ntf(“ and tall %f cms.n”,height);
- 21. 21 ตัวอย่างของโปรแกรมในการกำาหนดค่า และส่งค่าผลลัพธ์ # include <stdio.h> main ( ) { int sum,valuea; int count = 1; valuea = 4; sum = count + valuea; printf(“Total value is %d.n”,sum); } ผลลัพธ์จะปรากฏข้อความ : Total
- 22. 22 ฟังก์ชัน printf( ) และ scanf( ) รูปแบบของ printf ( ) printf( ส่วนควบคุมการพิมพ์, อาร์กิวเมนต์, อาร์กิวเมนต์,...) ส่วนควบคุมการพิมพ์ เป็นสตริงที่มี ข้อความและรูปแบบของการพิมพ์โดยอยู่ “ ”ในเครื่องหมาย อาร์กิวเมนต์ เป็นส่วนที่จะนำาข้อมูลมา พิมพ์ ตามรูปแบบที่กำาหนดมาในส่วน
- 23. 23 แบบที่ใช้สำาหรับกำาหนดการพิมพ์ในฟังก์ชัน printf %d พิมพ์ด้วยเลขฐานสิบ %o ” ” เลขฐานแปด %x ” ” เลขฐานสิบหก %u ” ” เลขฐานสิบแบบไม่คิดเครื่องหมาย %e ” ” ตัวเลขแบบวิทยาศาสตร์ เช่น 2.13e4 %f ” ” ตัวเลขมีจุดทศนิยม %g ” ” รูปแบบ %e หรือ %f โดยเลือกแบบ ที่สั้นที่สุด หรับสตริงมีรูปแบบการพิมพ์ดังนี้ %c พิมพ์ด้วยตัวอักษรตัวเดียว %s ” ”ข้อความ
- 24. 24 มายสำาหรับปรับเปลี่ยนรูปแบบของข้อมูล องหมายลบ ให้พิมพ์ข้อมูลชิดขอบซ้าย (ปกติข้อมูลทั้งหมดจะพิมพ์ชิดขวา) ิงตัวเลข ระบุความกว้างของฟิลด์ ทศนิยม เป็นการกำาหนดความกว้างของจุดทศน ารปรับเปลี่ยนรูปแบบของข้อมูลนี้ทำาได้โดย การใส่ ครื่องหมายเหล่านี้ระหว่างเครื่องหมาย % และเครื่อง กำาหนดรูปแบบการพิมพ์
- 25. 25 รูปแบบของ scanf ( ) scanf( ส่วนควบคุมข้อมูล, อาร์กิวเมนต์, อาร์กิวเมนต์,...) ส่วนควบคุมข้อมูล เป็นการกำาหนดรูปแบบข้อมูลใน “ ”เครื่องหมาย อาร์กิวเมนต์ เป็นส่วนที่จะนำาข้อมูลมาเก็บ(ใน ตัวแปร) ซึ่งชนิดของข้อมูลต้องตรงตามรูปแบบที่ กำาหนดในส่วนควบคุมข้อมูล การกำาหนดลักษณะอาร์กิวเมนต์มีได้ 2 แบบดังนี้ ถ้าข้อมูลนั้นอาจจะนำาไปใช้ในการคำานวณ - จะใส่เครื่องหมาย & หน้าตัวแปร ถ้าข้อมูลนั้นเป็นข้อความที่จะนำาไปเก็บไว้ใน
- 26. 26 โอเปอเรเตอร์และ นิพจน์ โอเปอเรเตอร์และ นิพจน์ การแทนโอเปอเรเตอร์ทางคณิตศาสตร์สำาหรับภาษา + การบวก - การลบ * การคูณ / การหาร % การหารเอาเศษ (โมดูลัส)
- 27. 27 การเปลี่ยนชนิดของข้อมูล ทำาได้โดยระบุชนิดที่ต้องการเปลี่ยน ภายในเครื่องหมาย ( ) แล้ววางหน้าตัวแปรหรือข้อมูลที่ต้องการ เปลี่ยนแปลงชนิด float money; ต้องการเปลี่ยนตัวแปร float ไปเป็น integer ทำาได้ดังนี้ (int) money; int cost;
- 28. 28 การเพิ่มค่าและลดค่าตัวแปร ++n เพิ่มค่า n อีก 1 - -n ลดค่า n ลง 1 ความแตกต่างระหว่าง count++ และ + +count เช่น count = 5; x = count++; จะได้ค่า x เท่ากับ 5 แล้วค่า count เท่ากับ 6
- 29. 29 นิพจน์กำาหนดค่า (Assignment expression) เครื่องหมายที่ใช้กำาหนดค่าคือ = โดยเป็นการกำาหนดค่าทางขวาของ เครื่องหมาย ให้กับตัวแปรที่อยู่ ทางซ้าย เช่น j = 7+2 หรือ k = k+4 3.4.6 เครื่องหมายและนิพจน์เปรียบเทียบ > หรือ >= มากกว่า หรือ มากกว่าเท่ากับ < หรือ <= น้อยกว่า หรือ
- 30. 30 กต่างของเครื่องหมาย = และ == ครื่องหมาย = เป็นตัวกำาหนดค่า เครื่องหมาย == เป็นเครื่องหมายเปรียบเทียบ ตัวอย 44; ง เป็นการกำาหนดค่าให้กับตัวแปร point ให้มีค่าเท = 44; ง เป็นการตรวจสอบว่าค่า point มีค่าเท่ากับ 44 หรือ
- 31. 31 หมายและนิพจน์เปรียบเทียบแบบตรรกศ && และ (and) | | หรือ (or) ! ไม่ (not) นิพจน์เปรียบเทียบเชิงตรรก ที่ 1 && นิพจน์ที่ 2 เป็นจริง เมื่อนิพจน์ทั้งสองเป็น ที่ 1 | | นิพจน์ที่ 2 เป็นจริง เมื่อนิพจน์ใดนิพจน์ห เป็นจริงหรือ ทั้งสองนิพจน์นั้นเป็นจริง น์เปรียบเทียบ เป็นจริง เมื่อนิพจน์เปรียบเทียบ
- 32. 32 คำาสั่ง if รูปแบบของคำาสั่ง if (เงื่อนไข) คำาสั่งที่ต้องทำา ถ้า เงื่อนไขนั้นเป็นจริง; ตัวอย่างเช่น if (score >= 80) grade = ‘A’; /* simple statement */ หรือ if (math >= 60 && eng >= 55) { grade = ‘S’; /* compound statement */
- 33. 33 สั่ง if ….. else ….. รูปแบบของคำาสั่ง if (คำาสั่งหรือนิพจน์เงื่อนไข) คำาสั่งที่ต้องทำาเมื่อเงื่อนไขนั้นเป็นจ else คำาสั่งที่ต้องทำาเมื่อเงื่อนไขนั้นไม่เป็น งเช่น if (value1 > value2) min = value2; else min = value1;
- 34. 34 หมายพิเศษที่ใช้ในการเปรียบเทียบเงื่อน รูปแบบทั่วไปของคำาสั่งเปรียบเทียบเงื่อนไข ? : มีด นิพจน์ที่ 1 ? นิพจน์ที่ 2 : นิพจน์ที่ 3 มหมายคือ if นิพจน์ที่ 1 เป็นจริง ทำาตามคำาสั่งในนิพจน์ที่ 2 else ทำาตามคำาสั่งในนิพจน์ที่ 3 x = (y< 0) ? -y : y;
- 35. 35 คำาสั่งตรวจสอบเงื่อนไขหลาย ๆ ทาง : switch และ break รูปแบบคำาสั่ง switch (นิพจน์) { case label1 : statement1; case label2 : statement2; …………….. ……………..
- 36. 36 ตัวอย่าง switch (ch) { case ‘1’ : printf(“Redn”); case ‘2’ : printf(“Bluen”); case ‘3’ : printf(“Yellown”); default : printf(“Whiten”); }
- 37. 37 ตัวอย่าง switch (ch) { case ‘1’ : printf(“Redn”); break; case ‘2’ : printf(“Bluen”); break; case ‘3’ : printf(“Yellown”); break; default : printf(“Whiten”); }
- 38. 38 คำาสั่ง loop หรือคำาสั่ง วนซำ้า คำาสั่ง loop หรือคำาสั่ง วนซำ้า while แบบ while (นิพจน์เงื่อนไข) { คำาสั่งที่วนลูป; ………… compound sta …………. }
- 39. 39 คำาสั่งลูป for รูปแบบ for ( นิพจน์ที่ 1 ; นิพจน์ที่ 2 ; นิพจน์ที่ 3 ) { คำาสั่งวนรอบ; ……. } เป็นคำาสั่งที่ใช้ในการควบคุมให้มีการวน รอบคำาสั่งหลาย ๆ รอบ โดยนิพจน์ที่ 1 คือการกำาหนดค่าเริ่มต้นให้กับ ตัวแปรที่ใช้ในการวนรอบ นิพจน์ที่ 2 เป็นการเปรียบเทียบ ก่อนที่จะวน
- 40. 40 วนรอบแบบที่ตรวจสอบเงื่อนไขทีหลัง : do wh แบบ do statement; while (นิพจน์เงื่อนไข); num = 2; do { num++; printf(“Now no is %dn”,num); } while (num == 10)
- 41. 41 คำาสั่งควบคุมอื่น ๆ break, continue, goto และ labelsคำาสั่งควบคุมอื่น ๆ break, continue, goto และ labels reak อต้องการให้การทำางานสามารถหลุดออกจากลูปแล งที่อยู่นอกลูปทันที โดยไม่ต้องตรวจสอบเงื่อนไขใ ontinue มื่อต้องการให้การทำางานนั้น ย้อนกลับไปวนรอบให ณะที่ตรงข้ามกับคำาสั่ง break
- 42. 42 oto และ labels o ประกอบด้วย 2 ส่วน คือ goto เป็นคำาสั่งให้กระโดดไปยังตำาแหน่งที่กำาหนด าหนดเป็นชื่อ เรียกว่า label name el name) เป็นตัวกำาหนดตำาแหน่งที่คำาสั่งจะกระโดด น ง ! คำาสั่งนี้ถือเป็นคำาสั่งที่ควรหลีกเลี่ยงในการเขียน นหรือหลีกเลี่ยงไม่ได้เท่านั้น จึงจะใช้คำาสั่งนี้
- 43. 43 างโปรแกรมที่ใช้คำาสั่ง goto #include<stdio.h> main() int sum,n; for(n=1;n<10;n++) if (n==5) goto part1; else printf(“%dn”,n); part1 : printf(“Interrupt with no. 5n”);
- 45. 45 ฟังก์ชันฟังก์ชัน (Functions)(Functions) การออกแบบโปรแกรมในภาษาซี จะอยู่บนพื้นฐานของการออกแบบ โมดูล (Module Design) โดยการแบ่ง โปรแกรมออกเป็นงานย่อย ๆ (หรือ โมดูล) แต่ละงานย่อยจะทำางานอย่าง ใดอย่างหนึ่งเท่านั้น และไม่ควรจะมี ขนาดใหญ่จนเกินไป งานย่อยเหล่านี้ เมื่อนำาไปเขียนโปรแกรมในภาษาซีจะ เป็นการเขียนในลักษณะของฟังก์ชัน
- 46. 46 รับข้อมูล 2 จำำนวน จำกผู้ใช้บวกเลข 2 จำำนวนแล้ว เก็บผลลัพธ์แสดงผลลัพธ์ของ กำรทำำงำน โปรแกรมเพื่อบวกเลขสอง จำำนวนที่รับจำกผู้ใช้ และแสดง ผลกำรคำำนวณ ตัวอ ย่ำง สำมำรถแบ่งกำรทำำงำนเป็นงำนย่อยได้ด
- 49. 49 4.1 รูปแบบของ ฟังก์ชัน ชนิดข้อมูลที่คืนค่ำ ชื่อฟังก์ชัน ( กำรประกำศตัวแปร ) { กำรประกำศตัวแปร ภำยในฟังก์ชัน; คำำสั่ง; return (ค่ำข้อมูลที่ int , char , float , double ฯลฯ แบบที่ 1
- 50. 50 รูปแบบของ ฟังก์ชัน (ต่อ) void ชื่อฟังก์ชัน ( กำรประกำศ ตัวแปร ) { กำรประกำศตัวแปรภำยใน ฟังก์ชัน; คำำสั่ง; } แบบที่ 2
- 51. 51 ตัวอย่ำง 4.1 แสดงกำรทำำงำนของ โปรแกรมกำรบวก เลขจำำนวนจริง 2 จำำนวน ที่รับจำกผู้ใช้#include <stdio.h> double InputDouble ( ) { double x; printf ( “nInput real value : “ ); scanf ( “%.2f ”, &x ); return ( x ); }
- 52. 52 ตัวอย่ำง 4.1 (ต่อ) double SumDouble ( double x, double y ) { return ( x + y ); } void PrintOut ( double x ) { printf ( “n Result of sum is : %.2f”, x );
- 53. 53 ตัวอย่ำง 4.1 (ต่อ) void main ( ) { double a1, a2, sumVal; a1 = InputDouble( ); a2 = InputDouble( ); sumVal = SumDouble ( a1, a2 );
- 55. 55 จำกตัวอย่ำงที่ 4.1 จะเห็นว่ำ ฟังก์ชัน main ( ) จะอยู่ใต้ฟังก์ชัน อื่น ๆ ที่มีกำรเรียกใช้ เป็นลักษณะ ที่ต้องประกำศฟังก์ชันที่ต้องกำร เรียกใช้ก่อนจำกเรียกใช้ฟังก์ชัน นั้น แต่หำกต้องกำรย้ำยฟังก์ชัน main ( ) ขึ้นไปไว้ด้ำนบน จะต้องมี กำรประกำศโปรโตไทป์ของฟังก์ชัน ที่ต้องกำรเรียกใช้ก่อนเสมอ
- 56. 56 #include <stdio.h> double InputDouble ( ); double SumDouble ( double , double ); void PrintOut ( double ); ตัวอย่ำง 4.2 แสดงกำรทำำงำนของ โปรแกรมกำรบวก เลขจำำนวนจริง 2 จำำนวน ที่รับจำกผู้ใช้ ในลักษณะ ที่มีกำรประกำศโปรโต ไทป์
- 57. 57 void main ( ) { double a1, a2, sumVal; a1 = InputDouble( ); a2 = InputDouble( ); sumVal = SumDouble ( a1, a2 ); PrintOut ( sumVal ); } ตัวอย่ำง 4.2 (ต่อ)
- 58. 58 จะเห็นว่ำในโปรโตไทป์ไม่มี กำรประกำศชื่อตัวแปร มีแต่กำร เขียนประเภทของตัวแปรไว้ภำยใน เป็นกำรช่วยให้คอมไพเลอร์ สำมำรถตรวจสอบจำำนวนของ ตัวแปร ประเภทของตัวแปร ประเภทของกำรคืนค่ำ ภำยใน โปรแกรมว่ำมีกำรเรียกใช้งำนสิ่ง ต่ำง ๆ เกี่ยวกับฟังก์ชันนั้นถูกต้อง
- 59. 59 4.3 กำรเรียกใช้ ฟังก์ชัน กำรเรียกใช้ฟังก์ชันที่มีกำร คืนค่ำ จะใช้รูปแบบดังต่อไปนี้ ค่ำที่รับ = ฟังก์ชัน (อำร์กิวเมนต์)
- 60. 60 a1 =a1 = InputDouble ( );InputDouble ( ); ใช้คู่กับโปรโต ไทป์ doubledouble InputDouble ( );InputDouble ( ); ตัวอ ย่ำงa1 ต้องมีชนิดเป็น double เนื่องจำกค่ำที่จ คืนกลับมำจำกฟังก์ชันมีชนิดเป็น doub
- 61. 61 sumVal =sumVal = SumDouble (a1,a2 );SumDouble (a1,a2 ); ใช้คู่กับโปรโตไทป์ double InputDoubledouble InputDouble ( );( ); ตัวอ ย่ำง a1 และ a2 ต้องมีชนิดเป็น double เพื่อให้ตรงกับชนิดตัวแปรของอำร์กิวเม ที่ประกำศในโปรโตไทป์
- 62. 62 PrintOut( sumVal )PrintOut( sumVal ) ;; ใช้คู่กับโปรโต ไทป์ void PrintOutvoid PrintOut ( double );( double ); ตัวอ ย่ำง ประกำศให้รู้ว่ำฟังก์ชันนี้ไม่มีกำรคืนค่ำ
- 63. 63 4.4 ขอบเขต ( Scope) กำรทำำงำนของโปรแกรม ภำษำซีจะทำำงำนที่ฟังก์ชัน main ( ) ก่อนเสมอ เมื่อฟังก์ชัน main ( ) เรียกใช้งำนฟังก์ชันอื่น ก็จะมีกำร ส่งคอนโทรล (Control) ที่ควบคุม กำรทำำงำนไปยังฟังก์ชันนั้น ๆ จนกว่ำจะจบฟังก์ชัน หรือพบคำำสั่ง return
- 65. 65 a1 a2 sum Val mai n ( ) xInputDou ble ( ) a1 =a1 = InputDouble( );InputDouble( ); ตัวอ ย่ำง step1step1 จำกตัวอย่ำง 4.1 และ 4.2 สำมำรถแสดงขอบเขต กำรทำำงำนได้ดังนี้
- 66. 66 a1 a2 sum Val mai n ( ) xInputDou ble ( ) a2 =a2 = InputDouble( );InputDouble( ); ตัวอย่ำ ง (ต่อ) step2step2
- 67. 67 a1 a2 sum Val mai n ( ) xsumDou ble ( ) sumVal=SumDouble(a1,a2)sumVal=SumDouble(a1,a2) ตัวอย่ำ ง (ต่อ) Step3Step3 y
- 68. 68 a1 a2 sum Val mai n ( ) xPrintSum ( ) PrintSum(sumVal);PrintSum(sumVal); ตัวอย่ำ ง (ต่อ) step4step4
- 69. 69 จะเห็นว่ำตัวแปร x ที่ประกำศใน แต่ละขั้นตอนจะทำำงำนอยู่ภำยใน ฟังก์ชันที่มีกำรประกำศค่ำเท่ำนั้น และ ใช้พื้นที่ในกำรเก็บข้อมูลคนละส่วนกัน ขอบเขตกำรทำำงำนของตัวแปร แต่ละตัวจะกำำหนดอยู่ภำยบล็อกของคำำ สั่งภำยในเครื่องหมำยปีกกำ ( { } ) หรือกำรประกำศในช่วงของกำร ประกำศฟังก์ชัน เรียกตัวแปรเหล่ำนี้ว่ำ
- 70. 70 นอกจำกนี้สำมำรถประกำศตัวแปร ไว้ที่ภำยนอกฟังก์ชันบริเวณส่วน เริ่มของโปรแกรมจะเรียกว่ำ ตัวแปรโกลบอลตัวแปรโกลบอล (Global Variable)(Global Variable) ซึ่งเป็นตัวแปรที่สำมำรถเรียกใช้ที่ ตำำแหน่งใด ๆ ในโปรแกรมก็ได้ ยกเว้นในกรณีที่มีกำรประกำศ ตัวแปรที่มีชื่อเดียวกันตัวแปร โกลบอลภำยในบล็อกหรือฟังก์ชัน
- 71. 71 #include <stdio.h> int x; void func1 ( ) { x = x + 10; printf ( “func1 -> x : %dn”, x ); } ตัวอย่ำง 4.3 แสดงกำรทำำงำนของ โปรแกรมในลักษณะที่มี ตัวแปรโกลบอล แสดง ขอบเขตกำรใช้งำนของ ตัวแปรภำยในโปรแกรม
- 72. 72 void func2 ( int x ) { x = x + 10; printf ( “func2 -> x : %dn”, x ); } void func3 ( ) { int x=0; x = x + 10; printf ( “func3 -> x : %dn”, x ); ตัวอย่ำง 4.3 (ต่อ)
- 73. 73 void main ( ) { x = 10; printf ( “main (start) -> x : %dn”, x ); func1 ( ); printf ( “main (after func1) -> x : %dn”, x ); func2 ( x ); printf ( “main (after func2) -> x : %dn”, x); func3 ( ); printf ( “main (after func3) -> ตัวอย่ำง 4.3 (ต่อ)
- 74. 74 main (start) -> x : 10 func1 -> x : 20 main (after func1) -> x : 20 func2 -> x : 30 main (after func2) -> x : 20 func3 -> x : 10 main (after func3) -> x : 20 ตัวอย่ำง 4.3 (ต่อ) ผลกำรทำำงำน
- 76. 76 5.1 ควำมรู้ทั่วไปเกี่ยวกับโครงสร้ำง (0,0 ) (4,3) หำกต้องกำรเก็บข้อมูลจุดบนแกนโคออดิเนท จะประกอบไปข้อมูลแกน x และ y เป็น ข้อมูลจำำนวนเต็มประเภท int ประเภทข้อมูล ที่ใช้ได้แก่ประเภทข้อมูลแบบโครงสร้ำง สำมำรถประกำศประเภท ข้อมูลที่ใช้ดังนี้
- 77. 77 struct point { int x; int y; }; กำรประกำศ ประเภทข้อมูลประเภทข้อมูล แบบโครงสร้ำง Mem ber หมำยเหตุ กำรประกำศชื่อสมำชิกภำยใน struct จะใช้ชื่อใดก็ได้อำจจะซำ้ำกับชื่อ ตัวแปรที่อยู่ภำยนอก struct แต่ชื่อที่อยู่ ภำยใน struct เดียวกันห้ำมประกำศชื่อซำ้ำ
- 78. 78 struct point { int x; int y; } x, y , z; กำรประกำศ ตัวแปรข้อมูลตัวแปรข้อมูล แบบโครงสร้ำง หมำยเหตุ จะเห็นว่ำชื่อของ struct จะ ประกำศหรือไม่ก็ได้ หำกไม่มีกำร ประกำศจะไม่สำมำรถนำำ struct นั้นกลับ แบบที่ 1
- 79. 79 struct point { int x; int y; }; struct point x,y,z แบบที่ 2 กำร ประกำ ศแบบ ข้อมูล โครงส ร้ำงกำร ประกำ ศ ตัวแปร ข้อมูล
- 80. 80 struct point pt = {320,200}; กำรกำำหนดค่ำเริ่มต้นให้กับตัวแปร ข้อมูลแบบโครงสร้ำง struct_name.membe r กำรอ้ำงถึงสมำชิกภำยในตัวแปร ข้อมูลแบบโครงสร้ำง
- 81. 81 เมื่อต้องกำรอ้ำงถึงสมำชิกภำยใน struct ว่ำอยู่ตรงกับจุดใดบนแกนโคออดิ เนทจะใช้ printf ( “%d, %d”, pt.x, pt.y ); หรือหำกต้องกำรคำำนวณระยะทำง จะว่ำห่ำงจำกจุดเริ่มต้น (0, 0) ตัวอย่ ำง
- 82. 82 หมำยเหตุ สมำชิกของข้อมูล ประเภท struct อำจจะเป็นตัวแปร ประเภทใดก็ได้ ทั้งข้อมูลพื้นฐำน และประเภทข้อมูลอื่น ๆ เช่น อำเรย์ และยังประกำศ ตัวแปรของ ข้อมูลประเภท struct ได้อีกด้วยตัวอย่ ำง pt 2pt 1 หำกต้องกำร เก็บข้อมูลของ สี่เหลี่ยมดังรูป สำมำรถทำำกำร ประกำศ
- 83. 83 struct point pt1; struct point pt2; }; struct rect screen; int co_x; co_x = กำร ประกำศ แบบ ข้อมูล โครงสร้ ำง กำร ประกำศ ตัวแปร ข้อมูล แบบ โครงสร้ำ ง กำรอ้ำง ถึงสมำชิก
- 84. 84 5.2 กำรเก็บข้อมูลแบบโครงสร้ำง กำรเก็บข้อมูลแบบโครงสร้ำง ภำยในหน่วยควำมจำำจะเก็บตำม ลำำดับที่มีกำรประกำศสมำชิกของ ข้อมูลนั้น โดยทั่วไปข้อมูลแบบ โครงสร้ำงจะประกอบขึ้นจำกข้อมูล หลำย ๆ ชนิด และข้อมูลแต่ละ ชนิดมักจะมีกำรจองพื้นที่ใช้งำนแต่ ต่ำงกัน เนื่องจำกกำรจองพื้นที่ หน่วยควำมจำำในระบบส่วนใหญ่จะ
- 85. 85 struct alignment { int num1; char ch; int num2; ตัวอ ย่ำง nu m1 c h nu m2 mem ber 0 2 3 4 Byte Offset จะเห็นว่ำ num2 จะไม่สำมำรถใช้พื้นที่ที่ติดกับ ch ได้ เนื่องจำก num2 เป็นข้อมูลประเภทเลขจำำนวนต้อง ใช้พื้นที่ที่มี แอดเดรสหำรด้วย 2 หรือ 4 ลงตัว ทำำให้เกิดที่ว่ำงที่ ไม่สำมำรถ
- 86. 86 5.3 กำรใช้ข้อมูลแบบโครงสร้ำงกับ ฟังก์ชัน กำรทำำงำนของตัวแปรที่เป็นประเภท โครงสร้ำงสำมำรถทำำงำนต่ำง ๆ ได้ เช่นเดียวกับตัวแปรอื่น ๆ ยกเว้นกำร เปรียบเทียบตัวแปร struct กับตัวแปร struct เนื่องจำกข้อมูลของตัวแปร struct จะเก็บอยู่ในตัวแปรที่เป็นสมำชิก ของ struct กำรเปรียบเทียบจึงต้องทำำ ผ่ำนตัวแปรที่เป็นสมำชิกของ struct เท่ำนั้น กำรใช้งำนตัวแปร struct กับ
- 87. 87 ตัวอย่ำ ง 5.1 ฟังก์ชันใช้ในกำรกำำหนดค่ำให้ กับตัวแปร struct struct point makepoint ( int x, int y ) { struct point temp; temp.x = x; temp.y = y; return temp; } หมำยเหตุ ตัวอย่ำงนี้แสดงฟังก์ชันที่ทำำกำรส่งค่ำ กลับเป็นรูปแบบโครงสร้ำง
- 88. 88 กำรเรียกใช้งำนฟังก์ชัน struct rect screen; struct point middle; struct point makepoint ( int, int ); screen.pt1 = makepoint ( 0, 0 ); screen.pt2 = makepoint ( XMAX, YMAX ); middle = makepoint ((screen.pt1.x + screen.pt2.x) / 2, (screen.pt1.y + screen.pt2.y) / 2 );
- 89. 89 ตัวอย่ำ ง 5.2 ฟังก์ชันกำรบวก x และ y ของ จุด 2 จุด และคืนค่ำผลของกำร บวกเป็น struct struct point addpoint(struct point p1, struct point p2) { p1.x += p2.x; p1.y += p2.y; return p1; } หมำยเหตุ ตัวอย่ำงนี้แสดงกำรส่งอำร์กิวเมนท์ แบบ struct ให้กับฟังก์ชัน
- 90. 90 ตัวอย่ำ ง 5.3 ฟังก์ชันกำรหำว่ำจุดอยู่ในพื้นที่ สี่เหลี่ยมหรือไม่ int pinrect ( struct point p, struct rect r ) { return p.x >= r.pt1.x && p.x < r.pt2.x && p.y >= r.pt1.y && p.y < r.pt2.y; } หมำยเหตุ ตัวอย่ำงนี้เป็นกำรหำว่ำจุดที่ระบุ อยู่ในพื้นที่สี่เหลี่ยมหรือไม่ โดยส่งค่ำจุด และพื้นที่สี่เหลี่ยมเป็นอำกิวเมนท์ให้กับ ฟังก์ชัน หำกจุดอยู่ในพื้นที่สี่เหลี่ยมจะคืน ค่ำ1 แต่หำกจุดอยู่นอกพื้นที่สี่เหลี่ยมจะคืน
- 92. 92 รูปที่ 6.1 การแทนข้อมูลในหน่วยความจำา ของตัวแปรประเภทพื้นฐาน int i; i 40 040 240 4 i = 10; i 40 040 240 4 1 0 int i; i = 10; 6.1 ตัวชี้กับแอดเดรส (Pointers and Address)
- 94. 94 6.2 การประกาศตัวแปรประเภทตัวชี้ การประกาศตัวแปรประเภทพอยน์เตอร์ จะใช้ Unary Operator ** ซึ่งมีชื่อ เรียกว่า Indirection หรือ Dereferencing Operator โดยจะต้อง ประกาศประเภทของตัวแปรพอยน์เตอร์ ให้สอดคล้องกับประเภทของตัวแปรที่ เราต้องการ (ยกเว้นตัวแปรพอยน์เตอร์ ประเภท void ที่สามารถชี้ไปยังตัวแปร ประเภทใดก็ได้)
- 95. 95 int *ip; เป็นการประกาศตัวแปร ip ให้เป็น ตัวแปรพอยน์เตอร์ที่ชี้ไปยังตัวแปร ประเภท int double *dp, atof(char *); เป็นการประกาศตัวแปร dp เป็นตัว แปรพอยน์เตอร์ที่ชี้ไปยังตัวแปร ตัวอย่ าง
- 96. 96 6.3 การกำาหนดค่าและการอ่านค่าตัว แปรประเภทตัวชี้ การกำาหนดค่าให้กับตัวแปรพอยน์ เตอร์จะเป็นการกำาหนดแอดเดรส ของตัวแปรที่มีประเภทสอดคล้อง กับประเภทของตัวแปรพอยน์เตอร์ เท่านั้น โดยการใช้ Unary Operator && เป็นโอเปอเรเตอร์ที่ อ้างถึงแอดเดรสของออปเจ็ค (Object) ใด ๆ
- 97. 97 int x = 1, y = 2; int *ip, *iq; ip = &x; y = *ip; *ip = 0; y = 5; ip = &y; *ip = 3; iq = ip; รูปที่ 6.3 การกำาหนดค่าและการอ่าน ค่าตัวแปรตัวชี้
- 98. 98 400 500 402 502 x ip y iq 1 2 int x = 1, y = 2; int *ip, *iq;
- 105. 105 x ip 400 500 y 402 402 502iq 0 3 402 iq = ip;
- 106. 106 6.4 ตัวชี้และอาร์กิวเมนท์ของ ฟังก์ชัน (Pointer and Function Arguments) เนื่องจากภาษาซีมีการส่งอากิวเมนต์ ให้กับฟังก์ชันแบบ By Value และ ฟังก์ชันสามารถคืนค่า (return) ค่า ได้เพียงหนึ่งค่า หากต้องการให้ ฟังก์ชันมีการเปลี่ยนแปลงค่าและคืน ค่ากลับมายังฟังก์ชันที่เรียกใช้ มากกว่าหนึ่งค่าจะต้องนำาพอยน์ เตอร์เข้ามาช่วย
- 107. 107 ตัวอย่างเช่น หากต้องการเขียน ฟังก์ชันเพื่อสลับค่าของตัวแปร 2 ตัว ผลลัพธ์ที่ต้องการได้จากฟังก์ชันนี้จะ มี 2 ค่าของตัวแปรที่ทำาการสลับค่า หากอาร์กิวเมนต์เป็นตัวแปรธรรมดา จะไม่สามารถแก้ปัญหานี้ได้ จึงต้อง ใช้พอยน์เตอร์เข้ามาช่วย โดยการ ส่งค่าแอดเดรสของตัวแปรทั้ง 2 ให้ กับฟังก์ชันที่จะสลับค่าของตัวแปรทั้ง 2 ผ่านทางตัวแปรพอยน์เตอร์ที่เป็น
- 108. 108 ตัวอย่าง 6.1 โปรแกรมตัวอย่างการสลับ ค่าตัวแปร 2 ตัว โดยผ่านฟังก์ชัน จะแสดง การส่ง อาร์กิวเมนต์ในเป็นพอยน์ เตอร์ #include <stdio.h> void swap (int *, int *);
- 109. 109 void main ( ) { int x = 5, y = 10; printf(“Before swap : x = %d”, x, “, y = %dn”, y); swap ( &x, &y); printf(“After swap : x = %d”, x, “, y = %dn”, y); } ตัวอย่าง 6.1 (ต่อ)
- 110. 110 void swap (int *px, int *py) { int temp; temp = *px; *px = *py; *py = temp; } ตัวอย่าง 6.1 (ต่อ)
- 111. 111 อาร์กิวเมนท์ที่เป็นประเภท พอยน์เตอร์จะช่วยให้ฟังก์ชัน สามารถเปลี่ยนค่าให้กับตัวแปรที่ ส่งเข้ามาได้ เนื่องจากอาร์กิวเม นท์นั้นจะเก็บแอดเดรสของ ตัวแปรที่ส่งเข้ามา เมื่อมีการ เปลี่ยนแปลงค่าของอาร์กิวเมนท์ ผ่าน Dereferencing Operator ( * ) ค่าของตัวแปรที่ส่งเข้ามาจะ
- 112. 112 รูปที่ 6.4 แสดงความสัมพันธ์ของการส่งอาร์กิวเมนท์ แบบพอยน์เตอร์กับฟังก์ชัน x y in main ( ) p xp y in swap ( )
- 113. 113 6.5 ตัวชี้กับอาร์เรย์ (Pointer and Arrays) อาร์เรย์เป็นประเภทข้อมูลที่เก็บ ชุดของข้อมูลประเภทเดียวกัน มักใช้กับการทำางานที่ต้องทำางาน กับตัวแปรชนิดเดียวกันหลายตัวที่ มีการทำางานเหมือนกัน เช่น คะแนนของนักศึกษาภายในห้อง 20 คน เป็นต้น อาร์เรย์ในภาษาซี จะนำาหลักการของพอยน์เตอร์เข้า มาใช้ การทำางานใด ๆ ของ
- 114. 114 int table[10]; เป็นการกำาหนดอาร์เรย์ชื่อ table เป็นอาร์เรย์ประเภท int ที่มีสมาชิก ทั้งหมด 10 ตัว ตั้งแต่ table[0], table[1], table[2], ... , table[9] สมาชิกภายในอาร์เรย์จะเริ่มที่ 0 เสมอ และสมาชิกตัวสุดท้ายจะอยู่ที่ ตำาแหน่งของขนาดที่ประกาศไว้ลบ การประกาศการประกาศ อาร์เรย์อาร์เรย์
- 115. 115 รูปที่ 6.5 แสดงภาพจำาลองของ อาร์เรย์ขนาดสมาชิก 10 ตัว tabl e[0] tabl e[1] tabl e[2] tabl e[9] tab le
- 116. 116 จะใช้ระบบดัชนีโดยผ่าน เครื่องหมาย [ ] เช่น อ้างถึงสมาชิกตัวที่ 3 ของอาร์เรย์ ด้วย table[2] เป็นต้น การใช้งาน สมาชิกของอาร์เรย์สามารถใช้งาน ได้เหมือนตัวแปรพื้นฐานทั่วไป การอ้างถึงสมาชิกในการอ้างถึงสมาชิกใน อาร์เรย์อาร์เรย์
- 117. 117 sumThird = table[0] + table[1] + table[2]; table[0] = 5; if ( a[0] > a[9] ) printf (“First is greater than lastn” ); ตัวอ ย่าง
- 119. 119 สมมติให้ i, j, k เป็นตัวแปรประเภท int for (int k = 0; k < 9; k++) printf (“Value at %d = %dn”, k+1, table[k]); table[i + j] = 0; table[7 – table[j]] = j; ตัวอ ย่าง
- 120. 120 ในภาษาซีจะไม่มีการกำาหนด ให้ตรวจสอบขอบเขตของอาร์เรย์ โปรแกรมเมอร์จะต้องพยายาม เขียนโปรแกรมที่เกี่ยวข้องกับ สมาชิกของอาร์เรย์ภายในขอบเขต ที่ประกาศอาร์เรย์ไว้ หากมีการ อ้างอิงถึงสมาชิกอาร์เรย์นอก ขอบเขตที่ได้ระบุไว้ เช่น table[12] สิ่งที่ต้องระวัง
- 121. 121 ตัวอย่าง 6.2 ให้อ่านค่าของจำานวนเต็ม 5 จำานวนจากคีย์บอร์ด และแสดงผลในลำาดับที่ กลับกัน # include <stdio.h> #define SIZE 5 main ( ) { int k; int table[SIZE]; for (k = 0; k < SIZE; k++) scanf (“%d”, &table[k]); for (k = SIZE-1; k >= 0; k--) printf (“%dn”, table[k]); }
- 122. 122 สมาชิกของอาร์เรย์อาจเป็น ประเภทข้อมูลพื้นฐานใด ๆ ก็ได้ หรืออาจเป็นข้อมูลประเภท Enumeration เช่น #define TSIZE 10 #define NAMESIZE 20 #define ADDRSIZE 30 enum month { JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG,
- 123. 123 typedef enum month Month; int age[TSIZE]; float size[TSIZE+1]; Month date[8]; char name[NAMESIZE], address[ADDRSIZE];
- 124. 124 6.6 การใช้ตัวชี้กับอาร์เรย์ การทำางานใด ๆ ของอาร์เรย์สามารถ ใช้พอยน์เตอร์เข้ามาช่วย ซึ่งจะ ทำาให้มีความเร็วในการทำางานสูงขึ้น สมมติว่ามีอาร์เรย์ a และพอยน์เตอร์ pa ดังนี้ int a[10]; int *pa; กำาหนดให้พอยน์เตอร์ pa ชี้ไปยัง อาร์เรย์ a ด้วยคำาสั่ง pa = &a[0]; /* หรือใช้คำา
- 125. 125 รูปที่ 6.6 แสดงตัวชี้ชี้ไปยัง แอดเดรสเริ่มต้นของอาร์เรย์ a[0] a[1] a[2] a[9] a p a
- 126. 126 การนำาไปใช้งานจะสามารถ อ่านค่าอาร์เรย์ผ่านพอยน์เตอร์ได้ ดังนี้ x = *pa; จะเป็นการกำาหนดค่าให้ x มีค่า เท่ากับ a[0] การเลื่อนไปอ่านค่า สมาชิกตำาแหน่งต่าง ๆ ของ อาร์เรย์ผ่านทางพอยน์เตอร์ สามารถทำาได้โดยการเพิ่มค่า พอยน์เตอร์ขึ้น 1 เพื่อเลื่อนไปยัง
- 127. 127 กรณีที่ pa ชี้อยู่ที่ a[0] คำา สั่ง pa+1; จะเป็นการอ้างถึงแอดเดรส ของ a[1] หากเป็น pa+i เป็นการอ้างถึงแอดเดรส a[i] หากต้องการอ้างถึงข้อมูล ภายในของสมาชิกของ
- 128. 128 รูปที่ 6.7 แสดงการอ้างถึงตำาแหน่ง ในอาร์เรย์ผ่านตัวชี้ a[0 ] a[1 ] a[2 ] a[9 ] a p a pa +1 pa +2
- 129. 129 การสั่งให้บวก 1 หรือบวก i หรือ ลบ i เป็นเหมือนการเลื่อนไปยังสมาชิก ของอาร์เรย์ตำาแหน่งที่ต้องการ เนื่องจากประเภทของข้อมูลแต่ละ ประเภทของอาร์เรย์ เช่น int, float, double และอื่น ๆ มีขนาดของข้อมูลที่ ต่างกัน ทำาให้ขนาดของสมาชิก ภายในอาร์เรย์แต่ละประเภทมีขนาด แตกต่างกันด้วย การสั่งให้บวกหรือลบ ด้วยจำานวนที่ต้องการนั้นจะมีกลไกที่ทำา
- 130. 130 นอกจากนี้ยังสามารถใช้พอยน์ เตอร์แทนอาร์เรย์ การอ้างโดยใช้ a[i] สามารถใช้ *(a+i) เนื่องจาก ทุกครั้งที่อ้างถึง a[i] ภาษาซีจะทำา หน้าที่แปลงเป็น *(a+i) เพราะ ฉะนั้นการเขียนในรูปแบบใดก็ให้ ผลลัพธ์ในการทำางานเช่นเดียวกัน และการอ้างถึงแอดเดรส เช่น &a[i] จะมีผลเท่ากับการใช้ a+i
- 131. 131 ในลักษณะเดียวกันการใช้งา นพอยน์เตอร์ก็สามารถใช้คำาสั่งใน ลักษณะอาร์เรย์ก็ได้ เช่น การอ้างถึง *(pa+i) สามารถเขียนด้วย pa[i] ก็ได้ ผลเช่นเดียวกัน สิ่งที่แตกต่างกันของอาร์เรย์และ พอยน์เตอร์ คือ พอยน์เตอร์เป็นตัวแปร แต่อาร์เรย์ไม่ใช่ตัวแปร สมมติให้ a เป็นอาร์เรย์และ pa เป็นพอยน์เตอร์ การอ้างถึง pa = a หรือ pa++ จะ
- 133. 133 ตัวอย่าง 6.3 ฟังก์ชันที่รับพารามิเตอร์ เป็นพอยน์เตอร์ โด ยอาร์กิวเมนท์ที่ส่งมาเป็น อาร์เรย์ int strlen (char *s) { int n; for ( n = 0; *s != ‘0’; s++ ) n++; return n; }
- 134. 134 จะเห็นว่า s เป็นพอยน์เตอร์ ใน ฟังก์ชันจะมีการตรวจสอบข้อมูลว่ามี ‘ค่าเท่ากับ 0’ หรือไม่ และมีการเลื่อน ตำาแหน่งทีละ 1 ค่า (นับว่าข้อมูลมี ความยาวเพิ่มขึ้นทีละ1) โดยใช้ s++ การเรียกใช้ฟังก์ชัน strlen สามารถ ทำาได้หลายลักษณะ strlen (“hello world”); /* string constant */ strlen (array); /*
- 135. 135 นอกจากนี้ยังอาจจะประกาศ พารามิเตอร์ภายในฟังก์ชัน strlen ได้ใน 2 ลักษณะ คือ char *schar *s แบบ ในตัวอย่าง หรืออาจจะใช้ charchar s[ ]s[ ] ก็ได้ โดยทั่วไปจะใช้ใน ลักษณะแรก เพราะช่วยในรู้ได้ ทันทีว่า s เป็นตัวแปรพอยน์เตอร์ และยังสามารถส่งส่วนใดส่วนของ อาร์เรย์ให้แก่ฟังก์ชันก็ได้ โดยไม่
- 136. 136 f (&a[2]) หรือ f (a+2) เป็นการส่งแอดเดรสของ สมาชิก a[2] ให้กับฟังก์ชัน f การประกาศฟังก์ชัน f สามารถ ทำาได้โดยการประกาศ f (int arr[ ]) { ......... } ตัวอ ย่าง
- 137. 137 6.7 การคำานวณกับแอดเดรส ให้ p เป็นพอยน์เตอร์ชี้ไปยัง อาร์เรย์ใด ๆ คำาสั่ง p++ เป็นการ เลื่อน p ไปยังสมาชิกถัดไป และคำา สั่ง p += i เป็นการเลื่อนพอยน์ เตอร์ไป i ตำาแหน่งจากตำาแหน่ง ปัจจุบัน นอกจากนี้ยังสามารถใช้ เครื่องหมายความสัมพันธ์ (Relational Operator) เช่น ==, !
- 138. 138 p < q จะเป็นจริงเมื่อ p ชี้ไปที่สมาชิกที่ อยู่ก่อนหน้าสมาชิกที่ q ชี้อยู่ การ เปรียบเทียบในลักษณะจะใช้ได้ ต่อเมื่อ p และ q ชี้ไปที่อาร์เรย์ เดียวกันเท่านั้น นอกจากนี้ยังสามารถใช้การ ลบหรือการบวกกับพอยน์เตอร์ได้ เช่นเดียวกัน แต่สิ่งที่ควรระวังคือ
- 139. 139 ตัวอย่าง 6.3 ฟังก์ชัน strlen( ) ปรับปรุง ให้กระชับขึ้น int strlen (char *s) { char *p = s; while (*p != ‘0’) p++; return p-s; }
- 140. 140 เนื่องจาก s ชี้อยู่ที่ ตำาแหน่งเริ่มต้น โดยมี p ชี้ไปที่ s เช่นเดียวกัน แต่จะมีการ เลื่อน p ไปทีละหนึ่งตำาแหน่ง จนกว่าค่าที่ตำาแหน่งที่ p ชี้อยู่ ‘จะเท่ากับ 0’ เมื่อนำา p ค่า สุดท้ายมาลบกับ s ที่ตำาแหน่ง เริ่มต้นก็จะได้ความยาวของ
- 141. 141 6.8 ตัวชี้ตัวอักษรและฟังก์ชัน (Character Pointer and Function) การทำางานกับข้อความหรือ ที่เรียกว่า สตริง (String) เป็นการใช้ข้อมูลตัวอักษรหลาย ๆ ตัว หรืออาร์เรย์ของข้อมูล ประเภท char หรืออาจจะใช้ พอยน์เตอร์ชี้ไปยังข้อมูล ประเภท char การทำางานกับค่า
- 142. 142 “I am a string” เมื่อมีการใช้ค่าคงที่สตริงจะมีการ พื้นที่ในหน่วยความจำาเท่ากับความ ยาวของค่าคงที่สตริงบวกด้วย 1 เนื่องจากลักษณะการเก็บข้อมูล ประเภทข้อความในหน่วยความจำา จะมีการปะตัวอักษร null ‘หรือ 0’ ต่อท้ายเสมอเพื่อให้รู้ว่าเป็นจุดสิ้น สุดของข้อมูล การจองพื้นที่ดังกล่าว ตัวอย่ าง
- 143. 143 รูปที่ 6.8 แสดงแบบจำาลองการเก็บ ข้อมูลประเภท สตริงในหน่วย ความจำา I a m a s t r i n g 0
- 144. 144 ค่าคงที่สตริงที่พบเห็นได้ เสมอได้แก่ข้อความที่ใช้ใน ฟังก์ชัน printf ( ) เช่น printf ( “Hello, worldn” ); ฟังก์ชัน printf ( ) จะรับ พารามิเตอร์เป็นพอยน์เตอร์ชี้ไป ยังแอดเดรสของข้อมูลที่ตำาแหน่ง
- 145. 145 ในการเขียนโปรแกรมจะ สามารถใช้พอยน์เตอร์ชี้ไปค่า คงที่สตริงใด ๆ ก็ได้ เช่น char *pmessage = “Hello, world”; pmessage จะเป็นพอยน์ เตอร์ประเภท char ชี้ไปที่ อาร์เรย์ของตัวอักษร จะแตก
- 146. 146 ลักษณะของอาร์เรย์เช่น amessage จะมีการจองพื้นที่ใช้ กับอาร์เรย์ขนาด 13 ตัวอักษร รวมทั้ง null ส่วนลักษณะของ พอยน์เตอร์ที่ชี้ไปยังค่าคงที่ สตริง จะมีการจองพื้นที่ให้กับ ค่าคงที่สตริงขนาด 13 ตัวอักษร เช่นเดียวกัน แต่จะมีการจอง
- 147. 147 รูปที่ 6.9 การจองพื้นที่ให้กับอาร์เรย์และตัวชี้ ชี้ไปยังค่าคงที่สตริง H e l l o , w o r l d 0 H e l l o , w o r l d 0amessage pmessage
- 148. 148 void strcpy ( char *s, char *t ) { int i=0; while ( ( s[i] = t[i] ) != ‘0’ ) i++; ตัวอย่า ง 6.5 ฟังก์ชัน strcpy ( ) ทำา หน้าที่สำาเนาข้อความ จากตัวแปรหนึ่งไปยังอีก ตัวแปรหนึ่งเขียนใน ลักษณะอาร์เรย์
- 149. 149 void strcpy ( char *s, char *t ) { while ( ( *s = *t ) != ‘0’ ) { s++; t++; ตัวอย่า ง 6.6 ฟังก์ชัน strcpy ( ) เขียนในลักษณะ พอยน์เตอร์
- 150. 150 void strcpy ( char *s, char *t ) { while ( ( *s++ = *t++ ) != ‘0’ ) ; } ตัวอย่า ง 6.7 ฟังก์ชัน strcpy ( ) เขียนในลักษณะ พอยน์เตอร์แบบสั้น
- 151. 151 การประกาศตัวแปรชี้ (pointer) ชี้ไปยัง structกรณีการส่งอากิวเมนท์เป็นตัวแปร struct จะ ไม่เหมาะกับ struct ที่มีขนาดใหญ่ เนื่องจากทุกครั้งที่ส่งตัวแปร struct จะเป็นการสำาเนา ตัวแปรตัวใหม่ขึ้นมาในฟังก์ชัน ซึ่งจะทำาให้ ช้าและเปลืองพื้นที่หน่วย ความจำา เราจะใช้พอยน์เตอร์เข้ามาช่วยแก้ ปัญหานี้ โดยส่งแอดเดรสของตัวแปร struct มายัง ฟังก์ชันซึ่งรับอากิวเมนท์ เป็นพอยน์เตอร์ อากิวเมนท์จะชี้ไปยังแอดเดรสเริ่มต้นของ
- 152. 152 ตัวอย่ าง struct point origin, *pp; pp = &original; printf ( “origin is (%d, %d)n”, (*pp).x, (*pp).y ); จะได้ตัวแปร pp ชี้ไปยังข้อมูลแบบ โครงสร้างชื่อ struct point การ เขียน *pp จะเป็นการอ้างถึง โครงสร้าง การอ้างถึงสมาชิกสามารถการอ้างถึงสมาชิกสามารถ
- 153. 153 หมายเหตุ สิ่งที่ต้องระวังคือ (*pp).x จะไม่เหมือนกับ *pp.x เนื่องจากเครื่องหมาย . จะมีลำาดับความสำาคัญสูง กว่า * ทำาจะการแปลความ หมาย *pp.x จะเหมือนกับ การอ้าง *(pp.x) ซึ่งจะทำาให้ เกิดความผิดพลาดขึ้น
- 154. 154 การอ้างถึงสมาชิกอาจเขียนอีก ลักษณะหนึ่งโดยใช้เครื่องหมาย -> สมมติ p เป็นพอยน์เตอร์ รูป แบบการใช้เป็นดังนี้ p->member-of- structure จะสามารถแปลงประโยคการ ใช้พอยน์เตอร์อ้างสมาชิกของ struct จากตัวอย่างข้างบนได้ว่า
- 155. 155 หากมีพอยน์เตอร์ชี้ไปยัง struct rect ดังนี้ struct rect r, *rp = r; การอ้างถึงสมาชิกต่อไปนี้จะมีผล เท่ากับการอ้างถึงสมาชิกตัว เดียวกัน r.pt1.x rp->pt1.x (r.pt1).x ตัวอย่ าง
- 156. 156 6.9 ตัวชี้ (pointer) ชี้ไปยัง โครงสร้าง (pointer to structures) พอยน์เตอร์เป็นตัวแปรที่เก็บ แอดเดรสของตัวแปรอื่น สามารถใช้ชี้ไปยังข้อมูล ประเภทใด ๆ การใช้พอยน์ เตอร์ชี้ไปยังโครงสร้างสามารถ ทำาได้ดังนี้
- 158. 158 struct date { int day; int month; int year; } *ptrdate; แบบที่ 2
- 159. 159 int day; int month; int year; } Date; typedef Date *PtrDate; การ ประกาศ แบบ ข้อมูล โครงสร้ าง การประกาศ ประเภท ตัวแปร pointer ชี้ไป ยัง โครงสร้าง การ ประกาศ ตัวแปร แบบที่ 3
- 160. 160 การประกาศตัวแปร ptrdate ทั้ง 3 ลักษณะจะ สามารถใช้งานได้เหมือนกัน ทั้งหมด หากต้องการให้ ptrdate ชี้ ไปยังตัวแปรโครงสร้างสามารถ ทำาได้ดังนี้ ptrdate = &today;
- 161. 161 การอ้างถึงสมาชิกของโครงสร้างผ่านตัว แปรพอยน์เตอร์ ptrdate->day = 7; if ( ptrdate->day == 31 && ptrdate- >month == 12 ) ..... scanf ( “%d”, &ptrdate->year ); การอ้างถึงสมาชิกโครงสร้างโดยใช้ เครื่องหมาย -> (*ptrdate).day = 7;
- 162. 162 #include <stdio.h> struct date { /*date template */ int day; int month; int year; }; typedef struct date Date; typedef Date *PtrDate; ตัวอย่าง 6.8 โปรแกรมตัวอย่างการใช้ตัว ชี้ (pointer) ชี้ไปยัง โครงสร้าง
- 163. 163 main ( ) { Date today; PtrDate ptrdate; ptrdate = &today; ptrdate->day = 27; ptrdate->month = 9; ptrdate->year = 1985; printf ( “Today’s date is %2d/%2d/%4dn”, ptrdate->day, ptrdate- ตัวอย่าง 6.8 (ต่อ)
- 164. 164 นอกจากนี้ยังสามารถทำาการ กำาหนดค่าเริ่มต้นให้กับตัวแปรแบบ โครงสร้าง เช่น Date xmas = { 25, 12, 1986 }; และหากมีการกำาหนดค่าเริ่มต้น ให้กับสมาชิกของโครงสร้างไม่ครบ ทุกตัว หากตัวแปรนั้นเป็น external หรือ static ค่าของสมาชิกที่ขาดไป จะถูกกำาหนดให้เป็น 0 แต่หากเป็น
- 165. 165 6.10 อาร์เรย์ของโครงสร้าง การใช้งานโครงสร้างนอกจากใช้ใน ลักษณะของตัวแปรแล้ว ยังสมารถใช้ งานในลักษณะของอาเรย์ได้อีกด้วย เช่น การเก็บข้อมูลประวัติของ พนักงาน จะมีโครงสร้างที่ใช้เก็บ ข้อมูลของพนักงานแต่ละคน หากใช้ ในลักษณะของตัวแปรปกติจะสามารถ เก็บข้อมูลของพนักงานได้เพียง 1 คน ซึ่งพนักงานทั้งบริษัทอาจจะมีหลายสิบ หรือหลายร้อยคน การเก็บข้อมูลใน
- 166. 166 การอ้างโดยใช้คำาสั่งต่าง ๆ staff อ้างถึงอาเรย์ของ โครงสร้าง staff[i] อ้างถึงสมาชิกที่ i ในอา เรย์ staff[i].forename อ้างถึงชื่อหน้า ของสมาชิกที่ I ของอาเรย์ staff[i].surname[j] อ้างถึงตัว อักษรตัวที่ j ในนามสกุล ของสมาชิกที่ i ของอาเรย์
- 167. 167 การใช้ข้อมูลสมาชิกแต่ละตัวจะ อ้างถึงโดยการอ้างผ่านระบบดัชนี เหมือนอาร์เรย์ทั่วไป เช่น ฟังก์ชันที่ใช้ในการพิมพ์ชื่อ สมาชิกคนที่ระบุ จะเรียกใช้โดย print_person ( staff[k] ); การเรียกใช้งานสมาชิกบางตัว ในอาร์เรย์ของโครงสร้างผ่าน ฟังก์ชัน
- 168. 168 หากต้องการเรียกใช้งานฟังก์ชันที่ ทำางานกับทั้งอาร์เรย์ เช่น การ เรียกใช้งานฟังก์ชันที่ทำาการเรียง ลำาดับอาร์เรย์ตามชื่อหน้า จะต้อง ส่งอาร์เรย์และขนาดของอาร์เรย์ไป ยังฟังก์ชันนั้น เช่น sort_forename ( staff, STAFFSIZE ); การเรียกใช้งานสมาชิกทุกตัว ในอาร์เรย์ของโครงสร้างผ่าน ฟังก์ชัน
- 169. 169 การกำาหนดค่าเริ่มต้นให้กับอาร์เรย์ของ โครงสร้างสามารถทำาได้โดย Person staff[ ] = { { “Bloggs”, “Joe”, MALE, 21 }, { “Smith”, “John”, MALE, 30 }, { “Black”, “Mary”, FEMALE, 25 } }; การกำาหนดค่าเริ่มต้นให้กับ อาร์เรย์ของโครงสร้าง
- 170. 170 6.11 อาร์เรย์แบบหลายมิติ (Multi-dimensional Arrays) จากพื้นฐานที่ผ่านมาเรื่อง อาร์เรย์จะเป็นลักษณะของอาร์เรย์ มิติเดียว แต่อาร์เรย์อาจจะมี มากกว่า 1 มิติก็ได้ เช่น ข้อมูล คะแนนสอบของนักศึกษาแต่ละคน ภายในชั้นซึ่งแบ่งเป็นคะแนนเก็บ หลายส่วน จะพบว่าหากต้องการ เก็บข้อมูลคะแนนสอบของนักศึกษา
- 171. 171 #define NUMBER_OF_PAPERS 5 int student [ NUMBER_OF_PAPERS ]; /* int student[5]; */ 5.6 8.5 12.6 24.1 16.0 student[0]student[1]student[2]student[3]student[4]
- 172. 172 แต่หากเพิ่มเติมว่าให้เก็บ ข้อมูลคะแนนสอบของ นักศึกษาทุกคน จะต้องใช้ อาร์เรย์หลายมิติเข้ามา เกี่ยวข้อง ตัวอย่างเช่นการ เก็บข้อมูลคะแนนสอบของ นักศึกษา 2 คนโดยมีคะแนน สอบของการสอบทั้งสิ้น 5 ครั้ง
- 173. 173 รูปที่ 6.10 แสดงตัวอย่างการเก็บข้อมูล คะแนนของ นักศึกษา ครั้งที่ 1 2 3 4 5 นาย ก นาย ข 5.6 8.512.624.116.0 6.0 7.215.025.018.0
- 174. 174 อ้างอิงถึงข้อมูลในอาร์เรย์ 2 มิติ ะมองอาร์เรย์ 2 มิติในลักษณะที่ประกอบด w) และคอลัมน์(column) โดยข้อมูลที่อ้าง ยถึง แถว และข้อมูลถัดมาคือ คอลัมน์ marks[row][column] row column marks[0] [0] marks[0] [1] marks[0] [2] marks[0] [8] marks[1] [0] marks[1] [8] marks[2] [0] marks[2] [8]
- 175. 175 จากลักษณะความต้องการเก็บ ข้อมูลดังกล่าวจะต้องเตรียมอาร์เรย์ เพื่อเก็บข้อมูลในลักษณะ 2 มิติ สามารถประกาศอาร์เรย์ดังนี้ #define NUMBER_OF_PAPERS 5 #define NUMBER_OF_STUDENTS 50 int
- 176. 176 แกรมการรับค่าอาร์เรย์ 2 มิติ ude<stdio.h> () oat score[10][3]; t i,j; intf(“Please put scoren”); r(i=0;i<10;i++) or(j=0;j<3;j++) scanf(“%f”,&score[i][j]); score[0][0]score[0][1]score[0][2] score[1][0]score[1][1]score[1][2] score[9][0]score[9][1]score[9][2]
- 177. 177 score[0][0]score[0][1]score[0][2] score[1][0]score[1][1]score[1][2] score[9][0]score[9][1]score[9][2] score[2][0]score[2][1]score[2][2] ลักษณะข้อมูล หน่วยความจำา 200 202204 206 208 210 210 212214 216 218 220 220 222224 226 228 230 [0][0][0][1][0][2][1][0][1][1][1][2] [2][0][2][1][2][2][3][0][3][1][3][2] [4][0][4][1][4][2][5][0][5][1][5][2]