เข้าสู่ระบบ จำนวนคนออนไลน์ 2119 คน
ศิริพร
บล็อกสำหรับเก็บความรู้
 
หัวข้อล่าสุด
 
 
  • ขั้นตอนการพัฒนาโปรแกรม (0)
    [มากกว่า 6 เดือน]
  • ประวัติความเป็นมาของภาษาc (0)
    [มากกว่า 6 เดือน]
  • ความรู้เบื้องต้นเกียวกับภาษาc (0)
    [มากกว่า 6 เดือน]
  • การทำไก่ผัดตะไคร้ (0)
    [มากกว่า 6 เดือน]
  • การทำแกงส้มกุ้ง (0)
    [มากกว่า 6 เดือน]
  • การทำแกงเขียวหวานไก่ (0)
    [มากกว่า 6 เดือน]
  • การทำข้าวเหนียวมะม่วง (0)
    [มากกว่า 6 เดือน]
  • การขยายพันธ์ดอกกุหลาบ (0)
    [มากกว่า 6 เดือน]
  • วิธีทำเค้ก (0)
    [มากกว่า 6 เดือน]
  • การขยายพันธ์มะละกอ (2)
    [มากกว่า 6 เดือน]
  • ความรู้เกี่ยวกับสุขภาพ (0)
    [มากกว่า 6 เดือน]
  • ขนมสอดไส้ (0)
    [มากกว่า 6 เดือน]
  • ปั่นขลิบ (0)
    [มากกว่า 6 เดือน]
  • ความรู้เกี่ยวกับการบัญชี (0)
    [มากกว่า 6 เดือน]
  • ประวัติอำเภออุทุมพรพิสัย (0)
    [มากกว่า 6 เดือน]
  • อาหารสมุนไพร (0)
    [มากกว่า 6 เดือน]
  • อาหารเพื่อสุขภาพ (1)
    [มากกว่า 6 เดือน]
  • อาหารไทย (0)
    [มากกว่า 6 เดือน]
  • การขยายพันธุ์กล้วยไม้ (0)
    [มากกว่า 6 เดือน]
  • ประวัติจังหวัดศรีสระเกษ (0)
    [มากกว่า 6 เดือน]
  • โปรแกรมพิมดีด (0)
    [มากกว่า 6 เดือน]
  • ดูเนื้อหาทั้งหมด

     
         
     
    ปฎิทิน
     
     

    <ตุลาคม 2557>
     
    40293012345
    416789101112
    4213141516171819
    4320212223242526
    44272829303112
    453456789
     
         
     
    สถิติบลอกนี้
     
     
    • คนเข้าบลอกนี้ทั้งหมด 26550
    • เฉพาะวันนี้ 17
    • ความคิดเห็น 3
    • จำนวนเรื่อง 23
    ให้คะแนนบลอกนี้
    แจ้งเนื้อหาบลอกไม่เหมาะสม
     
         
    ขั้นตอนการพัฒนาโปรแกรม
    9 สิงหาคม 2554 - 12:02:00

    ขั้นตอนการพัฒนาโปรแกรมภาษาซี

    Last Updated On: 20 มิถุนายน 2554 - 16:00:00

     

    1.ขั้นตอนการพัฒนาโปรแกรมภาษา  C

                การพัฒนาโปรแกรมภาษา  C  มีขั้นตอนดังนี้
                1) เขียนโปรแกรมต้นฉบับ  (source  program)  ด้วยภาษา  C
                            ใช้โปรแกรม  Turbo  C/ C++ เพื่อเขียนโปรแกรมต้นฉบับด้วยภาษา  C  จากนั้นบันทึกโปรแกรมพร้อมกับตั้งชื่อแฟ้มไว้ แฟ้มที่ได้จะมีนามสกุล  *.c  หรือ  *.cpp  เช่น  simple.c  หรือ  simple.cpp  เป็นต้น  นอกจากนี้ยังสามารถใช้โปรแกรม  Turbo C/C++  เขียนโปรแกรมภาษา  C++  ได้อีกด้วย
                2) แปลโปรแกรมภาษา  C  ไปเป็นโปรแกรมภาษาเครื่อง  (object  program)
                            ใช้คำสั่ง  compile  เพื่อแปลโปรแกรมภาษา  C  ไปเป็นโปรแกรมภาษาเครื่อง แฟ้มที่ได้จะมีนามสกุล  *.obj  ซึ่งในขั้นตอนนี้โปรแกรมต้นฉบับอาจเกิดความผิดพลาดทางไวยกรณ์ภาษา  (syntax  error)  ขึ้นได้  จึงต้องย้อนกลับไปแก้ไขโปรแกรมต้นฉบับในข้อ  1.  ให้ถูกต้องเสียก่อน
                3) เชื่อมโยง  (link)  โปรแกรมภาษาเครื่องเข้ากับ  library  function  ของภาษา  C  จะได้เป็น  execute  program  โดยใช้คำสั่ง  link  แฟ้มที่ได้จะมีนามสกุล  *.exe
                4) สั่งให้  execute  program   แสดงผลลัพธ์ออกมา โดยใช้คำสั่ง  run

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

    หมายเหตุ  ในทางปฏิบัติ  การ  compile/  link/ run  ในโปรแกรม  Turbo  C/C++  สามารถทำให้พร้อมกันทั้ง  3  ขั้นตอน  คือใช้คำสั่ง  Ctrl + F9  (กดปุ่ม  Ctrl  และปุ่ม  F9  พร้อมกัน)
                โดยสรุปเราสามารถเขียนผังงานแสดงขั้นตอนการพัฒนาโปรแกรมภาษา  C  ได้ดังนี้






     การพัฒนาโปรแกรม

     

     ขั้นตอนการพัฒนาโปรแกรม

    ขั้นตอนการพัฒนาโปรแกรมประกอบด้วย

    1. การวิเคราะห์ปัญหา

    2. การออกแบบโปรแกรม

    3. การเขียนโปรแกรมด้วยภาษาคอมพิวเตอร์

    4. การทดสอบและแก้ไขโปรแกรม

    5. การทำเอกสารประกอบโปรแกรม

    6. การบำรุงรักษาโปรแกรม

    1.1การวิเคราะห์ปัญหา

    การวิเคราะห์ปัญหา ประกอบด้วยขั้นตอนต่างๆ ดังนี้

    1. กำหนดวัตถุประสงค์ของงาน เพื่อพิจารณาว่าโปรแกรมต้องทำการประมวลผลอะไรบ้าง

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

    3. พิจารณาการประมวลผล เพื่อให้ทราบว่าโปรแกรมมีขั้นตอนการประมวลผลอย่างไรและมีเงื่อนไปการประมวลผลอะไรบ้าง

    4. พิจารณาข้อสนเทศนำออก เพื่อให้ทราบว่ามีข้อสนเทศอะไรที่จะแสดง ตลอดจนรูปแบบและสื่อที่จะใช้ในการแสดงผล

    การออกแบบโปรแกรม

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

    การเขียนโปรแกรมด้วยภาษาคอมพิวเตอร์

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

    การทดสอบและแก้ไขโปรแกรม

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

    1. สร้างแฟ้มเก็บโปรแกรมซึ่งส่วนใหญ่นิยมนำโปรแกรมเข้าผ่านทางแป้นพิมพ์โดยใช้โปรแกรมประมวลคำ

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

    3. ตรวจสอบความถูกต้องของการประมวลผลของโปรแกรม โปรแกรมที่ถูกต้องตามรูปแบบและกฎเกณฑ์ของภาษา แต่อาจให้ผลลัพธ์ของการประมวลผลไม่ถูกต้องก็ได้ ดังนั้นผู้เขียนโปรแกรมจำเป็นต้องตรวจสอบว่าโปรแกรมประมวลผลถูกต้องตามต้องการหรือไม่ วิธีการหนึ่งก็คือ สมมติข้อมูลตัวแทนจากข้อมูลจริงนำไปให้โปรแกรมประมวลผลแล้วตรวจสอบผลลัพธ์ว่าถูกต้องหรือไม่ ถ้าพบว่าไม่ถูกต้องก็ต้องดำเนินการแก้ไขโปรแกรมต่อไป การสมมติข้อมูลตัวแทนเพื่อการทดสอบเป็นสิ่งที่มีความสำคัญเป็นอย่างมาก ลักษณะของข้อมูลตัวแทนที่ดีควรจะสมมติทั้งข้อมูลที่ถูกต้องและข้อมูลที่ผิดพลาด เพื่อทดสอบว่าโปรแกรมที่พัฒนาขึ้นสามารถครอบคลุมการปฏิบัติงานในเงื่อนไขต่างๆ ได้ครบถ้วน นอกจากนี้อาจตรวจสอบการทำงานของโปรแกรมด้วยการสมมติตัวเองเป็นคอมพิวเตอร์ทีจะประมวลผล แล้วทำตามคำสั่งทีละคำสั่งของโปรแกรมนั้นๆ วิธีการนี้อาจทำได้ยากถ้าโปรแกรมมีขนาดใหญ่ หรือมีการประมวลผลที่ซับซ้อน

    การทำเอกสารประกอบโปรแกรม

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

    1. วัตถุประสงค์

    2. ประเภทและชนิดของคอมพิวเตอร์และอุปกรณ์ที่ใช้ในโปรแกรม

    3. วิธีการใช้โปรแกรม

    4. แนวคิดเกี่ยวกับการออกแบบโปรแกรม

    5. รายละเอียดโปรแกรม

    6. ข้อมูลตัวแทนที่ใช้ทดสอบ

    7. ผลลัพธ์ของการทดสอบ

    การบำรุงรักษาโปรแกรม

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

    http://61.19.202.164/resource/courseware/problem/k02-02.html
    ความรู้เบื้องต้นเกี่ยวกับโปรแกรมภาษา  C

         ภาษา  C  ถูกสร้างขึ้นครั้งแรก  โดย  Dennis  M.Ritchie  ซึ่งทำงานอยู่ที่  Bell  Telephone  Laboratories, Inc.  (ปัจจุบันนี้คือ  AT&T  Bell  Laboratories)  ประมาณปี  ค.ศ.1970  โดย  Ritchie  พัฒนาภาษา  C  มาจากภาษา  BCPL  และภาษา  B  ซึ่งในระยะแรกนี้ภาษา  C  ถูกนำมาใช้ภายใน  Bell  Laboratories  เท่านั้น  จนกระทั่งปี  ค.ศ.1978  Brian  W.Kerninghan  และ  Dennis  M. Ritchie  ได้กำหนดนิยาม  ลักษณะ  และรายละเอียดของภาษา  C  ขึ้น  โดยเขียนหนังสือชื่อว่า  “The  C  Programming  Language”  (สำนักพิมพ์  Prentice  Hall) ออกมาเป็นเล่มแรกต่อมาบริษัทคอมพิวเตอร์ต่าง ๆ ได้เริ่มสนใจ  และค้นคว้าพัฒนาภาษา  C  โดยอ้างอิงภาษา  C  ของ  Kernighan  และ  Ritchie  ทำให้มีการพัฒนา  C  compiler  และ  C  interpreter  ขึ้นมาเพื่อให้สามารถใช้กับเครื่องคอมพิวเตอร์ได้หลาย ๆ ชนิด  และสามารถใช้กับโปรแกรมต่าง ๆ ที่บริษัทผลิตขึ้นเป็นการค้า  จนกระทั่งปี  ค.ศ.1985  ภาษา  C  ก็ได้รับความนิยมแพร่หลายไปทั่วโลก  ซึ่งในช่วงนั้นภาษา  C  ที่ใช้กันอยู่มีมากมายหลายชนิด  แล้วแต่บริษัทต่าง ๆ จะสร้างขึ้นซึ่งยังขาดมาตรฐานร่วมกัน  ดังนั้นในปี  ค.ศ.1988  Kernighan  และ  Ritchie  จึงได้ร่วมกับสถาบัน  ANSI (American  National  Standards  Institute)  ได้กำหนดนิยาม  ลักษณะและกฎเกณฑ์ของภาษา  C  ที่เป็นมาตรฐานขึ้นเรียกว่า  “ANSI  C”  ซึ่งปัจจุบันนี้บริษัทที่ผลิตภาษา  C  ไม่ว่าจะเป็นบริษัท  Microsoft  และบริษัท  Borland  ต่างก็ใช้มาตรฐานของ ANSI  C  เพื่อผลิตภาษา  C  รุ่นต่าง ๆ ต่อไป

     


    http://e-learning.snru.ac.th/els/program1/lesson2/page2_1.htm

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

    ภาษา C เป็นภาษาคอมพิวเตอร์ที่ถูกค้นคิดขึ้นโดย Denis Ritchie ในปี ค.ศ. 1970
    โดยใช้ระบบปฏิบัติการของยูนิกซ์ (UNIX) นับจากนั้นมาก็ได้รับความนิยมเพิ่มขั้นจนถึงปัจจุบัน ภาษา C สามารถติดต่อในระดับฮาร์ดแวร์ได้ดีกว่าภาษาระดับสูงอื่น ๆ ไม่ว่าจะเป็นภาษาเบสิกฟอร์แทน ขณะเดียวกันก็มีคุณสมบัติของภาษาระดับสูงอยู่ด้วย ด้วยเหตุผลดังกล่าวจึงจัดได้ว่าภาษา C เป็นภาษาระดับกลาง (Middle –lever language)
    ภาษา C เป็นภาษาคอมพิวเตอร์ชนิดคอมไพล์ (compiled Language) ซึ่งมีคอมไพลเลอร์ (Compiler) ทำหน้าที่ในการคอมไพล์ (Compile) หรือแปลงคำสั่งทั้งหมดในโปรแกรมให้เป็นภาษาเครื่อง (Machine Language) เพื่อให้เครื่องคอมพิวเตอร์นำคำสั่งเหล่านั้นไปทำงานต่อไป

    โครงสร้างของภาษา C
    ทุกโปรแกรมของภาษา C มีโครงสร้างเป็นลักษณะดังรูป

     

          Int main (void)
    {

    เฮดเดอร์ไฟล์ (Header Files)
    เป็นส่วนที่เก็บไลบรารี่มาตรฐานของภาษา C ซึ่งจะถูกดึงเข้ามารวมกับโปรแกรมในขณะที่กำลังทำการคอมไพล์ โดยใช้คำสั่ง
    #include<ชื่อเฮดเดอร์ไฟล์> หรือ
    #include  “ชื่อเฮดเดอร์ไฟล์”
    ตัวอย่าง
    #include<stdio.h>

                    เฮดเดอร์ไฟล์นี้จะมีส่วนขยายเป็น .h เสมอ และเฮดเดอร์ไฟล์เป็นส่วนที่จำเป็นต้องมีอย่างน้อย 1 เฮดเดอร์ไฟล์ ก็คือ เฮดเดอร์ไฟล์ stdio.h ซึ่งจะเป็นที่เก็บไลบรารี่มาตรฐานที่จัดการเกี่ยวกับอินพุตและเอาท์พุต

    ส่วนตัวแปรแบบ Global (Global Variables)
    เป็นส่วนที่ใช้ประกาศตัวแปรหรือค่าต่าง ๆ ที่ให้ใช้ได้ทั้งโปรแกรม ซึ่งใช้ได้ทั้งโปรแกรม  ซึ่งในส่วนไม่จำเป็นต้องมีก็ได้
    ฟังก์ชัน (Functions)
    เป็นส่วนที่เก็บคำสั่งต่าง ๆ ไว้ ซึ่งในภาษา C จะบังคับให้มีฟังก์ชันอย่างน้อย 1 ฟังก์ชั่นนั่นคือ ฟังก์ชั่น Main() และในโปรแกรม 1 โปรแกรมสามารถมีฟังก์ชันได้มากกว่า 1 ฟังก์ชั่น

    ส่วนตัวแปรแบบ Local (Local Variables)
    เป็นส่วนที่ใช้สำหรับประกาศตัวแปรที่จะใช้ในเฉพาะฟังก์ชันของตนเอง ฟังก์ชั่นอื่นไม่สามารถเข้าถึงหรือใช้ได้ ซึ่งจะต้องทำการประกาศตัวแปรก่อนการใช้งานเสมอ  และจะต้องประกาศไว้ในส่วนนี้เท่านั้น
    ตัวแปรโปรแกรม (Statements)
    เป็นส่วนที่อยู่ถัดลงมาจากส่วนตัวแปรภายใน ซึ่งประกอบไปด้วยคำสั่งต่าง ๆ ของภาษา C และคำสั่งต่าง ๆ จะใช้เครื่องหมาย ; เพื่อเป็นการบอกให้รู้ว่าจบคำสั่งหนึ่ง ๆ แล้ว ส่วนใหญ่ คำสั่งต่าง ๆ ของภาษา C เขียนด้วยตัวพิมพ์เล็ก เนื่องจากภาษา C จะแยกความแตกต่างชองตัวพิมพ์เล็กและพิมพ์ใหญ่หรือ Case Sensitive นั่นเอง ยกตัวอย่างใช้ Test, test หรือจะถือว่าเป็นตัวแปรคนละตัวกัน นอกจากนี้ภาษา C ยังไม่สนใจกับการขึ้นบรรทัดใหม่ เพราะฉะนั้นผู้ใช้สามารถพิมพ์คำสั่งหลายคำสั่งในบรรทัดเดียวกันได้ โดยไม่เครื่องหมาย ; เป็นตัวจบคำสั่ง

     

    ค่าส่งกลับ (Return Value)
    เป็นส่วนที่บอกให้รู้ว่า ฟังก์ชันนี้จะส่งค่าอะไรกลับไปให้กับฟังก์ชั่นที่เรียกฟังก์ชั่น ซึ่งเรื่องนี้ผู้เขียนจะยกไปกล่าวในเรื่องฟังก์ชั่นอย่างละเอียดอีกทีหนึ่ง

    หมายเหตุ (Comment)
           เป็นส่วนที่ใช้สำหรับแสดงข้อความเพื่ออธิบายสิ่งที่ต้องการในโปรแกรม ซึ่งจะใช้เครื่องหมาย /*และ */ ปิดหัวและปิดท้ายของข้อความที่ต้องการ

     

      

    รูปที่ 2-2 แสดงการเขียนหมายเหตุหรือ Comment ในลักษณะต่าง ๆ

    โปรแกรมที่ 2 – 1 โปรแกรมแรกสำหรับคุณ
     

    การตั้งชื่อ
    การตั้งชื่อ (Identifier) ให้กับตัวแปร ฟังก์ชันหรืออื่น ๆ มีกฎเกณฑ์ในการตั้งชื่อ ดังนี้
    1.  ตัวแรกของชื่อจะต้องขึ้นต้องด้วยตัวอักษรหรือเครื่องหมาย _ เท่านั้น
    2.  ตัวอักษรตั้งแต่ตัวที่ 2 สามารถเป็นตัวเลข หรือเครื่องหมาย_ก็ได้
    3.  จะต้องไม่มีการเว้นวรรคภายในชื่อ แต่สามารถใช้เครื่อง_คั่นได้
    4.  สามารถตั้งชื่อได้ยาไม่จำกัด แต่จะใช้ตัวอักษรแค่ 31 ตัวแรกในการอ้างอิง
    5.  ชื่อที่ตั้งด้วยตัวอักษรพิมพ์ใหญ่และพิมพ์เล็ก จะถือว่าเป็นคนละตัวกัน
    6.  ห้ามตั้งชื่อซ้ำกับคำสงวนของภาษา C

    ตัวอย่างการตั้งที่ถูกและผิด


    แบบที่ถูก

    แบบที่ผิด

    A

    $sum

    Student_name

    Student Name

    _SystemName

    2names

    A1

    int

    ชนิดข้อมูล
    ในการเขียนโปรแกรมภาษา C นั้น ผู้ใช้จะต้องกำหนดชนิดให้กับตัวแปรนั้นก่อนที่จะนำไปใช้งาน โดยผู้ใช้จะต้องรู้ว่าในภาษา C นั้นมีชนิดข้อมูลอะไรบ้าง เพื่อจะเลือกใช้ได้อย่างถูก
    ต้องและเหมาะสม ในภาษา C จะมี 4 ชนิดข้อมูลมาตรฐาน ดังนี้

    ชนิดข้อมูลแบบไม่มีค่า หรือ Void Type (Void)
    ข้อมูลชนิดนี้ จะไม่มีค่าและจะไม่ใช้ในการกำหนดชนิดตัวแปร แต่ส่วนใหญ่จะใช้เกี่ยวกับฟังก์ชั่น ซึ่งจะขอยกไปอธิบายในเรื่องฟังก์ชั่น

     ชนิดข้อมูลมูลแบบจำนวนเต็ม หรือ Integer Type (int)
    เป็นชนิดข้อมูลที่เป็นตัวเลขจำนวนเต็ม ไม่มีทศนิยม ซึ่งภาษา C จะแบ่งข้อมูลชนิดนี้ออกได้เป็น 3 ระดับ คือ short int,int และ long int ซึ่งแต่ละระดับนั้นจะมีขอบเขตการใช้งานที่แตกต่างกัน ดังแสดงในตารางที่ 2-1


    ชนิดข้อมูล

    คิดเครื่อง
    หมาย

    ขนาด(ไบต์)

    จำนวนบิต

    ค่าน้อยที่สุด

    ค่ามากที่สุด

    Short int

    คิด
    ไม่คิด

    2

    16

    -32,768
    0

    32,768
    65,535

    Int
    (16 บิต)

    คิด
    ไม่คิด

    2

    16

    -32,768
    0

    32,768
    65,535

    Int
    (32 บิต)

    คิด
    ไม่คิด

    4

    32

    -2,147,486,643
    0

    2,147,486,643
    4,294,967,295

    Long int

    คิด
    ไม่คิด

    4

    32

    -2,147,486,643
    0

    2,147,486,643
    4,294,967,295

    ชนิดข้อมูลแบบอักษร หรือ Character Type (char)
    ข้อมูลชนิดนี้ก็คือ ตัวอักษรตั้งแต่ A-Z เลข 0-9 และสัญลักษณ์ต่าง ๆ ตามมาตรฐาน ACSII (American Standard Code Information Interchange) ซึ่งเมื่อกำหนดให้กับตัวแปรแล้วตัวแปรนั้นจะรับค่าได้เพียง 1 ตัวอักษรเท่านั้น และสามารถรับข้อมูลจำนวนเต็มตั้งแต่ถึง 127 จะใช้ขนาดหน่วยความจำ 1ไบต์หรือ 8 บิต

    ชนิดข้อมูลแบบทศนิยม หรือ Floating Point Type (flat)
    เป็นข้อมูลชนิดตัวเลขที่มีจุดทศนิยม ซึ่งสามารถแบ่งออกเป็น 3 ระดับ คือ float, double และ long double แต่ละระดับนั้นจะมีขอบเขตที่แตกต่างกันในการใช้งาน ดังแสดงในตารางที่ 2-2

     ตารางที่ 2-2 แสดงรายละเอียดของชนิดข้อมูลแบบทศนิยม

    ชนิดข้อมูล

    ขนาด(ไบต์)

    จำนวนบิต

    ค่าที่น้อยที่สุด

    float

    4

    32

          -38                38
    3.4-10    ถึง 3.4-10

    double

    8

    64

          -308                308
    1.7*10    ถึง 1.7*10

    long double

    10

    80

          -4932             4932
    3.4*10    ถึง 1.1*10

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

    การประกาศตัวแปร
    การประกาศตัวแปรในภาษา C นั้นสามรถทำได้ 2 ลักษณะ คือ การประกาศตัวแปรแบบเอกภาพ หรือการประกาศตัวแปรแบบ Global คือ ตัวแปรที่จะสามารถเรียกใช้ได้ทั้งโปรแกรม และแบบที่สองการประกาศตัวแปรแบบภายใน หรือการประกาศตัวแปรแบบ Local ซึ่งตัวแปรแระเภทนี้จะใช้ได้ในเฉพาะฟังก์ชั่นของตัวเองเท่านั้น

    #include<stdio.h>
    int total; /*การประกาศตัวแปรแบบ Global */
    main()
    {
    int price,money; /*การประกาศตัวแปรแบบ Local*/

    }

      

    รูปที่ 2-3 แสดงการประกาศตัวแปรแบบต่าง ๆ

    การกำหนดค่าให้กับตัวแปร
    การกำหนดค่าให้กับตัวแปรนั้น จะสามารถกำหนดได้ตั้งแต่ตอนที่ประกาศตัวแปรเลยหรือจะกำหนดให้ภายในโปรแกรมก็ได้ ซึ่งการกำหนดค่าจะใช้เครื่องหมาย = กั้นตรงกลาง
    int total = 0;
    ถ้ามีตัวแปรข้อมูลชนิดเดียวกัน ก็สามารถทำแบบนี้ได้
    int total =0,sum
    หรือ
    int total =0,sum=0;
    ถ้าเป็นการกำหนดภายในโปรแกรม ซึ่งตัวแปรนั้นได้ประกาศไว้แล้วสามารถทำแบบนี้
    total = 50;
    หรือ
    total = total+sum
    หรือกำหนดค่าจาการพิมพ์ข้อมูลเข้าทางคีย์บอร์ด
    scanf(“%d”,&total);

    โปรแกรมที่ 2-2 การประกาศและใช้ตัวแปร
    #include<stdio.h>
    /*การประกาศตัวแปร Global*/
    int sum = 0;
    int main(void)
    {
    /*การประกาศตัวแปรแบบ Local */
    int a;
    int b;
    int c;

    /*คำสั่ง */
    printf(“\nWelcome. This Program adds\n”);
    printf(“threenumbers.Enter three numbers\n”);
    printf(“in the form: nnn nnn nnn <retur>\n”);
    scanf(“%d %d %d”,&a,&b,&c);
    /* ทำการบวกค่าระหว่าง a,b และ c เข้าด้วยกันแล้วกำหนดค่าให้ sum*/
    sum=a+b+c;
    printf(“The total is: %d\n”,sum);
    printf(“Thant you. Have a good day.\n”);
    return 0;
    }
    ผลการทำงาน:
    Welcome. This Program adds
    Three numbers. Enter three number
    In the form: nnn nnn nnn <return>
    11 22 23
    The total is: 56
    Thank you. Have a good day.

     

    การกำหนดชนิดข้อมูลแบบชั่วคราว
    เมื่อผู้ใช้ได้กำหนดชนิดข้อมูลให้กับตัวแปรใด ๆ ไปแล้ว ตัวแปรตัวนั้นจะมีชนิดข้อมูลเป็นแบบที่กำหนดให้ตลอดไป บางครั้งการเขียนโปรแกรมอาจจะต้องมีความจำเป็นต้องเปลี่ยนชนิดข้อมูลของตัวแปรตัวนั้น ซึ่งภาษาซี ก็มีความสามารถที่จะทำเช่นนั้นได้
    รูปแบบ
    ([ชนิดข้อมูล])[ตัวแปร]
    ตัวอย่าง
    (float)a
    (int)a
    โปรแกรมที่ 2-3 แสดงการใช้ตัวแปรแบบชั่วคราว
    #include<stdio.h>
    int main(void)
    {
    float a= 25.3658;
    printf(“Value of a : %\n”,a);
    printf(“Value of a when set is integer : %d\n”,(int)a);
    return 0;
    }
    ผลการทำงาน :
    Value of a : 25.365801
    Value of a when change is integer : 25

    ชนิดข้อมูลแบบค่าคงที่ (Constants)
    ชนิดข้อมูลประเภทนี้ ชื่อก็บอกอยู่ว่าเป็นชนิดข้อมูลแบบค่าคงที่ ซึ่งก็คือข้อมูลตัวแปรประเภทที่เป็น Constants ผู้ใช้จะไม่สามารถเปลี่ยนแปลงค่าของตัวแปรตัวนั้น ในขณะที่โปรแกรมทำงานอยู่
    รูปแบบ
    Const[ชนิดข้อมูล][ตัวแปร]=[ค่าหรือ นิพจน์]
    ตัวอย่าง
    const folat a = 5.23;
    const int b = a%2;

    โปรแกรมที่ 2-4 การใช้ตัวแปรชนิดข้อแบบค่าคงที่
    #include<stdio.h>
    imt main(void)
    {
    const float pi = 3.14159;
    float radius;
    radius = 3;
    printf(“Value of pi  : %f\n”,pi);
    printf(“Value of area : %f\n”,pi*(radius*radius));
    return 0;
    }
    ผลการทำงาน:
    Value of pi : 3.141590
    Value of area : 28.274311

    constant นั้นสามารถแบ่งออกได้ ดังนี้
    Integer Constants เป็นค่าคงที่ชนิดข้อมูลแบบตัวเลขจำนวนเต็มไม่มีจุดทศนิยม
    const int a = 5;

    Floating-Point Constants เป็นค่าคงที่ชนิดข้อมูลแบบตัวเลขที่มีจุดทศนิยม
    const float b = 5.6394;

    Character Constants เป็นค่าคงที่ชนิดตัวอักษร ซึ่งจะต้องอยู่ภายในเครื่องหมาย ‘’เท่านั้น
    const char b = ‘t’;

    String Constants เป็นค่าคงที่เป็นข้อความ ซึ่งจะต้องอยู่ภายใต้เครื่องหมาย “”เท่านั้น
    “”
    “h”
    “Hello world\n”
    “HOW ARE YOU”
    “Good Morning!”
    โปรแกรมที่ 2-5 การใช้ตัวแปรชนิดข้อมูลแบบค่าคงที่แบบต่าง ๆ
    #includ<stdio.h>
    int main(void)
    {
    const int a = 3; /*Integer Constats*/
    const flat b = 3.14159; /*Floating – Point Constants*/
    const cahr c = ‘P’; /*Character Constants*/
    printf(“Value of a: %d\n”,a);
    printf(“Value of b: %d\n”,b);
    printf(“Value of c: %d\n”,c);
    printf(“Good Bye”); /*String Constants*/
    return 0;
    }
    ผลการทำงาน
    Value of  a : 3
    Value of  b : 3.141590
    Value of  c : P
    Good Bye

    Statements
                        statements ในภาษา c คือ คำสั่งต่าง ไ ที่ประกอบขึ้นจนเป็นตัวโปรแกรม ซึ่งในภาษา c นั้นได้แบ่งออกเป็น 6 แบบ คือ Expression Statement และ Compound Statement ณ.ที่นี้จะมีด้วยกัน 2 แบบ

    1. Expression Statement  หรือเรียกอีกอย่างหนึ่งว่า Single Statement ซึ่ง Statement  แบบนั้นจะต้องมีเครื่องหมาย; หลังจาก statement เมื่อภาษา C พบเครื่องหมาย ; จะทำให้มันรู้ว่าจบชุดคำสั่งแล้ว แล้วจึงข้ามไปทำ Statement ชุดต่อไป

           a = 2;
    หรือ
    printf(“x contains %d, y contains %d\n”,x,y);

    Compound Statement คือ ชุดคำสั่งที่มีคำสั่งต่าง ๆ รวมอยู่ด้านใน Block ซึ่งจะใช้เครื่องหมาย {เป็นการเปิดชุดคำสั่ง และใช้} เป็นตัวปิดชุดคำสั่ง ตัวอย่างที่เห็นได้ชัดเจนสำหรับ Statement แบบนี้ คือ ตัวฟังก์ชั่น Main โดยทั่ว ๆ ไปในภาษา C Compound Statement จะเป็นตัวฟังชั่น

    ผังงาน
             ผังงาน (Flowchart)  มีไว้เพื่อให้ผู้ใช้ออกแบบขั้นตอนการทำงนของโปรแกรมก่อนที่จะลงมือเขียนโปรแกรม ซึ่งจะช่วยให้ผู้ใช้เขียนโปรแกรมได้ง่ายขึ้นและไม่สับสนซึ่งผังงานที่นิยมใช้มีมาตรฐานมากมายหลายแบบ  โดยมีสัญลักษณ์ของผังงานดังนี้
    1. 

                        Terminator
    สัญลักษณ์แทนจุดเริ่มต้นและจุดสิ้นสุด
            2.

                        Process                                                                         
    สัญลักษณ์กระบวนการต่าง ๆ เช่น การประกาศตัวแปร การบวก เป็นต้น
            3.

               
    Decision
    สัญลักษณ์เงื่อนไข
            4. 

               
    Data
    สัญลักษณ์ติดต่อกับผู้ใช้โดยการรับข้อมูลหรือแสดงข้อมูล

    5.                                                    
    Manual Input
    สัญลักษณ์การรับข้อมูลจากผู้ใช้
    6.

    Display
    สัญลักษณ์การแสดงผลออกทางจอภาพ
            7. 

                       
    Predefined Process
                     สัญลักษณ์ระบุการทำงานย่อยหรือฟังก์ชั่นย่อย
    8.                  
    Connect
    สัญลักษณ์จุดเชื่อม
            9.                               

                         Arrow
    สัญลักษณ์เส้นทางการดำเนินงาน

          โดยการออกแบบผังงาน จะมี 3 แบบ ดังนี้
    1.  แบบเรียงลำดับ จะเป็นลักษณะการทำงานที่เรียงกันไปเรื่อย ๆ โดยไม่มีการวนซ้ำ ดังรูป
     

                                                 

    2.  แบบทางเลือก จะเป็นลักษณะการทำงานที่มีทางเลือก ซึ่งจะพบในเรื่องคำสั่งเงื่อนไข เช่น คำสั่ง if…else ดังรูป
                   

                                                                                                               

    3.  แบบการทำงานซ้ำ จะเป็นลักษณะการทำงานที่วนการทำงานแบบเดิม จนครบตามจำนวนที่ต้องการ ซึ้งจะพบในเรื่องคำสั่ง วนลูป เช่น คำสั่ง do….while ดังรูป

     

     

    โครงสร้างของโปรแกรมภาษาซีแบ่งออกเป็น 3 ส่วน

     

    1. ส่วนหัวของโปรแกรม

              ส่วนหัวของโปรแกรมนี้เรียกว่า Preprocessing Directive ใช้ระบุเพื่อบอกให้คอมไพเลอร์กระทำการใด ๆ ก่อนการแปลผลโปรแกรมในที่นี่คำสั่ง #include <stdio.h> ใช้บอกกับคอมไพเลอร์ให้นำเฮดเดอร์ไฟล์ที่ระบุคือ stdio.h เข้าร่วมในการแปลโปรแกรมด้วย โดยการกำหนด preprocessing directives นี้จะต้องขึ้นต้นด้วยเครื่องหมาย # เสมอ

    คำสั่งที่ใช้ระบุให้คอมไพเลอร์นำเฮดเดอร์ไฟล์เข้าร่วมในการแปลโปรแกรม สามารถเขียนได้ 2 รูปแบบ คือ

    - #include < ชื่อเฮดเดอร์ไฟล์ > คอมไพเลอร์จะทำการค้นหาเฮดเดอร์ไฟล์ที่ระบุจากไดเรกทอรีที่ใช้สำหรับเก็บเฮดเดอร์ไฟล์โดยเฉพาะ ( ปกติคือไดเรกทอรีชื่อ include)

    - #include “ ชื่อเฮดเดอร์ไฟล์ ” คอมไพเลอร์จะทำการค้นหาเฮดเดอร์ไฟที่ระบุ จากไดเร็คทอรีเดียวกันกับไฟล์ source code นั้น แต้ถ้าไม่พบก็จะไปค้นหาไดเร็คทอรีที่ใช้เก็บ เฮดเดอร์ไฟล์โดยเฉพาะ

    2. ส่วนของฟังก์ชั่นหลัก

               ฟังก์ชั่นหลักของภาษาซี คือ ฟังก์ชั่น main( ) ซึ่งโปรแกรมภาษาซีทุกโปรแกรมจะต้องมีฟังก์ชั่นนี้อยู่ในโปรแกรมเสมอ จะเห็นได้จากชื่อฟังก์ชั่นคือ main แปลว่า “ หลัก ” ดังนั้น การเขียนโปรแกรมภาษซีจึงขาดฟังก์ชั่นนี้ไปไม่ได้ โดยขอบเขตของฟังก์ชั่นจะถูกกำหนดด้วยเครื่องหมาย { และ } กล่าวคือ การทำงานของฟังก์ชั่นจะเริ่มต้นที่เครื่องหมาย { และจะสิ้นสุดที่เครื่องหมาย } ฟังก์ชั่น main( ) สามารถเขียนในรูปแบบของ void main(void) ก็ได้มีความหมายเหมือนกัน คือ หมายความว่า ฟังก์ชั่น main() จะไม่มีอาร์กิวเมนต์ (argument) คือไม่มีการรับค่าใด ๆ เข้ามาประมวลผลภายในฟังก์ชั่น และจะไม่มีการคืนค่าใด ๆ กลับออกไปจากฟังก์ชั่นด้วย

    3. ส่วนรายละเอียดของโปรแกรม

    เป็นส่วนของการเขียนคำสั่ง เพื่อให้โปรแกรมทำงานตามที่ได้ออกแบบไว้

     

    คอมเมนต์ในภาษาซี

    คอมเมนต์ (comment) คือส่วนที่เป็นหมายเหตุของโปรแกรม มีไว้เพื่อให้ผู้เขียนโปรแกรมใส่ข้อความอธิบายกำกับลงไปใน source code ซึ่งคอมไพเลอร์จะข้ามาการแปลผลในส่วนที่เป็นคอมเมนต์นี้ คอมเมนต์ในภาษาซีมี 2 แบบคือ

    •  คอมเมนต์แบบบรรทัดเดียว ใช้เครื่องหมาย //

    •  คอมเมนต์แบบหลายบรรทัด ใช้เครื่องหมาย /* และ */

    http://www.lks.ac.th/kuanjit/Program_C/ProgramC_20.htm

    ตัวแปรในภาษาซี

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

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

    1.  ข้อมูลชนิดตัวอักษร (Character) คือข้อมูลที่เป็นรหัสแทนตัวอักษรหรือค่าจำนวนเต็มได้แก่ ตัวอักษร ตัวเลข และกลุ่มตัวอักขระพิเศษใช้พื้นที่ในการเก็บข้อมูล 1 ไบต์
    2. ข้อมูลชนิดจำนวนเต็ม (Integer)  คือข้อมูลที่เป็นเลขจำนวนเต็ม  ได้แก่ จำนวนเต็มบวก จำนวนเต็มลบ ศูนย์ ใช้พื้นที่ในการเก็บ 2 ไบต์
    3. ข้อมูลชนิดจำนวนเต็มที่มีขนาด 2 เท่า (Long Integer) คือข้อมูลที่มีเลขเป็นจำนวนเต็ม  ใช้พื้นที่  4 ไบต์
    4. ข้อมูลชนิดเลขทศนิยม (Float) คือข้อมูลที่เป็นเลขทศนิยม ขนาด 4 ไบต์
    5. ข้อมูลชนิดเลขทศนิยมอย่างละเอียด (Double) คือข้อมูลที่เป็นเลขทศนิยม ใช้พื้นที่ในการเก็บ 8 ไบต์

    ชนิด

    ขนาดความกว้าง

    ช่วงของค่า

    การใช้งาน

    Char

    8 บิต

    ASCII character (-128 ถึง 127)

    เก็บข้อมูลชนิดอักขระ

    Unsignedchar

    8 บิต

    0-255

    เก็บข้อมูลอักขระแบบไม่คิดเครื่องหมาย

    Int

    16 บิต

    -32768 ถึง 32767

    เก็บข้อมูลชนิดจำนวนเต็ม

    long

    32 บิต

    -2147483648 ถึง 2147483649

    เก็บข้อมูลชนิดจำนวนเต็มแบบยาว

    Float

    32 บิต

    3.4E-38 ถึง 3.4E+38 หรือ ทศนิยม 6

    เก็บข้อมูลชนิดเลขทศนิยม

    Double

    64 บิต

    1.7E-308 ถึง 1.7E+308 หรือ ทศนิยม 12

    เก็บข้อมูลชนิดเลขทศนิยม

    Unsigned int

    16 บิต

    0 ถึง 65535

    เก็บข้อมูลชนิดจำนวนเต็ม ไม่คิดเครื่องหมาย

    Unsigned long

    32 บิต

    0 ถึง 4294967296

    เก็บข้อมูลชนิดจำนวนเต็มแบบยาว ไม่คิดเครื่องหมาย

    รูปแบบในการประกาศตัวแปรในภาษา C

         การสร้าวตัวแปรขึ้นมาใช้งานจะเรียกว่า  การประกาศตัวแปร (Variable Declaration) โดยเขียนคำสั่งให้ถูกต้องตามแบบการประกาศตัวแปร  แสดงดังนี้

    type name;

    type :  ชนิดของตัวแปร
    name : ชื่อของตัวแปร  ซึ่งต้องตั้งให้ถูกต้องตามหลักของภาษา C

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

    #include <stdio.h>

     

    int num;

    สร้างตัวแปรชื่อ num เพื่อเก็บข้อมูลชนิดจำนวนเต็ม

    float y;

    สร้างตัวแปรชื่อ y เพื่อเก็บข้อมูลชนิดเลขทศนิยม

    char n;

    สร้างตัวแปรชื่อ n เพื่อเก็บข้อมูลชนิดตัวอักขระ

    void main()

     

    {

     

         printf("Enter number : ")

     

         scanf("%d",&num);

     

         printf("Enter name : ");

     

         scanf("%f",&n);

     

         printf("Thank you");

     

    }

     

    หลักการตั้งชื่อตัวแปร

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

    1.

    ต้องขึ้นต้นด้วยตัวอักษร A-Z หรือ a-z หรือเครื่องหมาย _(Underscore) เท่านั้น

    2.

    ภายในชื่อตัวแปรสามารถใช้ตัวอักษร A-Z หรือ a-z หรือตัวเลข0-9 หรือเครื่องหมาย _

    3.

    ภายในชื่อห้ามเว้นชื่องว่าง หรือใช้สัญลักษณ์นอกเหนือจากข้อ 2

    4.

    ตัวอักษรเลขหรือใหญ่มีความหมายแตกต่างกัน

    5.

    ห้ามตั้งชื่อซ้ำกับคำสงวน (Reserved Word) ดังนี้

     

    auto

    default

    float

    register

    struct

    volatile

    break

    do

    far

    return

    switch

    while

    case

    double

    goto

    short

    typedef

    char

    else

    if

    signed

    union

    const

    enum

    int

    sizeof

    unsigned

    continue

    extern

    long

    static

    void

    ตัวอย่างการตั้งชื่อตัวแปรในภาษา C ทั้งที่ถูกต้องและไม่ถูกต้องตามหลักการ  แสดงดังนี้

    bath_room

    ถูกต้อง

    n-sync

    ผิดหลักการ เนื่องจากมีเครื่องหมาย - ปรากฎในชื่อ

    108dots

    ผิดหลักการ เนื่องจากขึ้นต้นด้วยตัวเลข

    Year#

    ผิดหลักการ เนื่องจากมีเครื่องหมาย # อยู่ในชื่อ

    _good

    ถูกต้อง

    goto

    ผิดหลักการ  เนื่องจากเป็นคำสงวน

    work

    ถูกต้อง

    break

    ผิดหลักการ  เนื่องจากเป็นคำสงวน

    ตัวแปรสำหรับข้อความ

         ในภาษา C ไม่มีการกำหนดชนิดของตัวแปรสำหรับข้อความโดยตรง  แต่จะใช้การกำหนดชนิดของตัวแปรอักขระ (char) ร่วมกับการกำหนดขนาดแทน  และจะเรียกตัวแปรสำหรับเก้บข้อความว่า  ตัวแปรสตริง (string) รูปแบบการประกาศตัวแปรสตริงแสดงได้ดังนี้

    char name[n] = "str";

    name

    ชื่อของตัวแปร

    n

    ขนาดของข้อความ หรือจำนวนอักขระในข้อความ

    str

    ข้อความเริ่มต้นที่จะกำหนดให้กับตัวแปรซึ่งต้องเขียนไว้ภายในเครื่องหมาย "  "

    ตัวอย่างการประกาศตัวแปรสำหรับเก็บข้อความ  แสดงได้ดังนี้

    char name[5] = "kwan" ;

    สร้างตัวแปร name สำหรับเก็บ ข้อความ kwan ซึ่งมี  4 ตัวอักษร ดังนั้น name ต้องมีขนาด 5

    char year[5] = "2549";

    สร้างตัวแปร year สำหรับเก็บ ข้อความ 2549 ซึ่งมี  4 ตัวอักษร ดังนั้น year ต้องมีขนาด 5

    char product_id[4] = "A01";

    สร้างตัวแปร product_id สำหรับเก็บ ข้อความ A01 ซึ่งมี  3 ตัวอักษร ดังนั้น product_id ต้องมีขนาด 4

     http://www.lks.ac.th/kuanjit/c_page01.htm

    ตัวคงที่ (constant)

              ตัวคงที่มีลักษณะคล้ายตัวแปรตรงที่ ค่าที่เก็บในตัวคงที่จะคงเดิมไม่มีการเปลี่ยนแปลงจนกระทั่งจบโปรแกรม แต่ค่าที่เก็บในตัวแปรสามารถเปลี่ยนแปลงได้ตลอดเวลา

     

    การประกาศตัวคงที่

            การประกาศตัวคงที่ทำได้ 2 วิธี ดังนี้

    1.      ใช้คำหลัก const ตามรูปแบบดังนี้

                       const ชนิดข้อมูล ชื่อตัวแปร = ค่าที่เก็บในตัวแปร;

    ตัวอย่าง 1.5

              การประกาศตัวคงที่โดยใช้คำหลัก const

              const int count = 120; //กำหนดให้ count เป็นตัวคงที่ชนิด int และเก็บค่า 120

              const float vat = 0.07;  //กำหนดให้ vat เป็นตัวคงที่ชนิด float และเก็บค่า 0.07

              const float pi = 3.14159;       //กำหนดให้ pi เป็นตัวคงที่ชนิด float และเก็บค่า 3.14159

     

    2.      ใช้ตัวประมวลผลก่อน ตามรูปแบบดังนี้

                       #define ชื่อตัวคงที่ ค่าคงที่

    ตัวอย่าง 1.6

              การประกาศตัวคงที่โดยใช้ข้อความสั่งตัวประมวลผลก่อน

              #define COUNT 120   //กำหนดให้ COUNT เป็นตัวคงที่ชนิด int และเก็บค่า 120

              #define VAT 7              //กำหนดให้ VAT เป็นตัวคงที่ชนิด float และเก็บค่า 0.07

              #define PI 3.14159      //กำหนดให้ PI เป็นตัวคงที่ชนิด float และเก็บค่า 3.14159

     

    1.4  การแสดงผลและการรับค่า

    ฟังก์ชัน printf()

            ฟังก์ชัน printf() เป็นฟังก์ชันจากคลัง ที่มาพร้อมกับตัวแปลโปรแกรมภาษาซี ใช้สำหรับการแสดงผล มีรูปแบบดังนี้

                       printf(“สายอักขระควบคุม”, ตัวแปร);

              โดยที่ สายอักขระควบคุม ประกอบด้วย 3 ส่วน คือ

    -          ตัวอักขระที่จะแสดง

    -          รูปแบบการแสดงผล ขึ้นต้นด้วยเครื่องหมายเปอร์เซ็นต์ (%)

    -          ลำดับหลีก (escape sequence)

              ตัวแปร คือ ชื่อของตัวแปรที่จะแสดงผล

    รูปแบบการแสดงผล (format specifies)

            การกำหนดรูปแบบการแสดงผล

    ·       ขึ้นต้นด้วยเครื่องหมายเปอร์เซ็นต์ (%)

    ·       ตามด้วยอักขระ 1 ตัว หรือหลายตัวโดยที่อักขระนั้นมีความหมายดังนี้

    อักขระ

    ชนิดข้อมูล

    รูปแบบการแสดงผล

    c

    char

    อักขระเดียว

    d

    o

    x

    ing

    จำนวนเต็มฐานสิบ

    จำนวนเต็มฐานแปด

    จำนวนเต็มฐานสิบหก

    f

    float

    จำนวนที่มีทศนิยมในรูปฐานสิบ

    ตัวอย่าง 1.7

            การใช้ฟังก์ชัน printf()

              #include <stdio.h>

              main ()

              {

                       int n;

                       float score;

                       n=10;

                       score = 100;

                       printf(“No : %d Score : %f”, n, score);

              }

              ผลการกระทำการ

              No:10 Score:100.000000

              แสดงค่าที่เก็บในตัวแปร n ในรูปแบบจำนวนเต็ม และแสดงค่าที่เก็บใน score ในรูปแบบจำนวนจริงที่มีทศนิยม

    ตัวอย่าง 1.8

            การใช้ฟังก์ชัน printf()

              #include <stdio.h>

              main ()

              {

                       int n;

                       float score;

                       n =10;

                       score =100;

                       printf(“No :%d”, n);

                       printf(“ Score : %f”, score);

              }

              ผลการกระทำการ

              No:10         Score: 100.000000

     

    ลำดับหลีก (Escape sequence)

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

              ลำดับหลีก จะเขียนขึ้นต้นด้วยเครื่องหมายทับหลัง (/) แล้วตามด้วยอักขระ ในการทำงาน เครื่องหมายทับกลับหลังจะบอกให้เครื่องคอมพิวเตอร์ทราบว่า ให้หลีกเลี่ยงการตีความอักขระที่ตามหลังมานี้ในลักษณะปกติ เพราะอักขระเหล่านี้จะมีความหมายพิเศษแตกต่างออกไป

              ลำดับหลีกที่ใช้ในการแสดงผลสิ่งที่ไม่ใช่อักขระปกติได้แก่

    ลำดับหลีก

    ผลการกระทำการ

    \n

    ขึ้นบรรทัดใหม่ (new line)

    \t

    เลื่อนไปยังจุดตั้งระยะ (tab) ถัดไป

    \a

    เสียงกระดิ่ง (bell)

    \b

    ถอยไปหนึ่งที่ว่าง (backspace)

    \f

    ขึ้นหน้าใหม่ (form feed)

    \\

    แสดงเครื่องหมายทับกลับหลัง (backslash)

    \’

    แสดงเครื่องหมายฝนทอง (single quote)

    \”

    แสดงเครื่องหมายฟันหนู (double quote)

     

    ตัวอย่าง 1.9

            การใช้ลำดับหลีก \n

              #include <stdio.h>                          //ข้อความสั่งตัวประมวลผลก่อน

              main()

              {

              printf(“Welcome to C!\n”);     //ฟังก์ชันจากคลังใช้ในการแสดงข้อความที่อยู่ใน” “

              }

              ผลการกระทำการ

              Welcome to C!

              -

              แสดงข้อความ Welcome to C!  ณ ตำแหน่งที่ตัวชี้ตำแหน่งอยู่ แล้วตัวชี้ตำแหน่งเลื่อนไปที่ต้นบรรทัดใหม่

     

     

     

    ตัวอย่าง 1.10

            การใช้ลำหลีก \f และ \n

              #include <stdio.h>       //ข้อความสั่งตัวประมวลผลก่อน

              main()

              {       

             printf(“\fwelcome “);      //ฟังก์ชันจากคลังใช้ในการแสดงข้อความที่อยู่ในฟันหนู (“ “)

             printf(“to C! \n”);          /*ฟังก์ชันจากคลังใช้ในการแสดงข้อความและอักขระที่อยู่ใน

                                                     ฟันหนู (“ “) */

             }

             ผลการกระทำการ

             Welcome to C!

             -

              เลื่อนไปหน้าใหม่ แล้วแสดงข้อความ Welcome to C! ที่สดมภ์แรกของบรรทัดแรก แล้วตัวชี้ตำแหน่งเลื่อนไปที่ต้นบรรทัดใหม่ ดังนี้

    ตัวอย่าง 1.11

              การใช้ลำดับหลีก \n

              #include <stdio.h>                          //ข้อความสั่งตัวประมวลผลก่อน

              main ()

              {

                       printf(“welcome\n to \n C!\n”);        /* ฟังก์ชันจากคลังใช้ในการแสดง

                                                              ข้อความและอักขระที่อยู่ใน ฟันหนู (“ “)*/

              }

              ผลการกระทำการ

              Welcome

              to

              C!

              -

              แสดงข้อความ Welcome ณ ตำแหน่งที่ตัวชี้จอภาพอยู่ แล้วตัวชี้ตำแหน่งเลื่อนไปที่ต้นบรรทัดใหม่ที่ต้นบรรทัดใหม่ แสดงข้อความ to แล้วตัวชี้ตำแหน่งเลื่อนไปที่ต้นบรรทัดใหม่

              ที่ต้นบรรทัดใหม่ แสดงข้อความ C! แล้วตัวชี้ตำแหน่งเลื่อนไปที่ต้นบรรทัดใหม่

     

    ตัวอย่าง 1.12

            การใช้รูปแบบการแสดงผลของจำนวนเต็ม

              #include <stdio.h>

              main ()

              {

                       int I,   j;

                       i = 368;

                       j = 24;

                       printf (“%\n”, i);

                       printf(“%d %d”, i, j);

              }

              ผลของการกระทำการ

              368

    368            24

    ตัวอย่าง 1.13

            การใช้รูปแบบการแสดงผลของจำนวนจริงที่มีทศนิยม

              #include <stdio.h>

              main ()

              {

                       float i, j;

                       i = 100.123456;

                       j = 4.34568e2;

                       printf (“\n \n Fixed point format”) ;

                       printf (“\n i=%f j=f”, i , j);

              }

              ผลการกระทำการ

              -บรรทัดว่าง-

              -บรรทัดว่าง-

              Fixed point format

              -บรรทัดว่าง-

              i=100.123456 j=434.567810

     

    ฟังก์ชัน Scanf()

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

              ฟังก์ชัน scanf() มีรูปแบบดังนี้

                                 scanf(“%รูปแบบ”,&ตัวแปร);

                       โดยที่ & ตัวแปร หมายถึง เลขที่อยู่ (address) ของตัวแปรที่จะรับค่ามาเก็บในหน่วยความจำ

     

    ตัวอย่าง 1.14

              การรับข้อมูลโดยใช้ scanf()

              scanf(“%f”, &radius);

              รับข้อมูลชนิด float จากแป้นพิมพ์ แล้วนำไปเก็บไว้ในตัวแปร radius ซึ่งมีเลขที่อยู่คือ &radius

    ตัวอย่าง 1.15

              การรับข้อมูลโดยใช้ scanf()

              scanf(“%d%fd”, &no, &amount, &unit);

              รับข้อมูล 3 ค่า ชนิด int, float และ int จากแป้นพิมพ์ แล้วนำไปเก็บไว้ในตัวแปร no, amount และ unit ซึ่งมีเลขที่อยู่ตามที่กำหนดไว้ใน &no, &amount และ &unit ตามลำดับ

    ตัวอย่าง 1.16

              การรับข้อมูลโดยใช้ scanf()

              scanf(“%f%f%f”, &length, &width, &height);

              รับข้อมูล 3 ค่า ชนิด float จากแป้นพิมพ์แล้วนำไปเก็บไว้ในตัวแปร length, width และ height ซึ่งมีเลขที่อยู่คือ ตามที่กำหนดไว้ใน &length, &width และ &height ตามลำดับ

     

    ตัวแปร                  หน่วยความจำ                 เลขที่อยู่ (เปลี่ยนแปลงไปในการกระทำการแต่ละครั้ง)

     

    35.5

     

    42.0

     

    5.2

    length                                               8760

    width                                       8764

    height                                               8768


    http://elearning.narinukul.ac.th/ICT1/%E0%B8%A0%E0%B8%B2%E0%B8%A9%E0%B8%B2%E0%B8%8B%E0%B8%B5.htm

    การจัดรูปแบบในการรับและแสดงผลข้อมูล

     

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

              สำหรับภาษาซีนั้นได้มีการเตรียมฟังก์ชันมาตรฐานที่เกี่ยวข้องกับการรับและแสดงผลไว้ใน header  file ที่ชื่อว่า  stdio.h ดังนั้นผู้เขียนโปรแกรมสามารถเรียกใช้ฟังก์ชันเหล่านี้ได้โดยี่จะต้องประกาศให้ตัวแปรโปรแกรม (compiler) ได้ทราบถึงแหล่งที่มาของฟังก์ชันเหล่านี้ โดยการใช้ข้อความสั่ง #include <stdio.h> ที่ส่วนต้นของโปรแกรม เนื้อหาในบทนี้จะกล่าวถึงฟังก์ชันที่ใช้ในการรับข้อมูลจากแป้นพิมพ์ และฟังก์ชันที่ใช้ในการแสดงผลข้อมูลออกทางจอภาพ

     

    2.1  ฟังก์ชันรับข้อมูล

            ในภาษาซีสามารถใช้ฟังก์ชัน scanf () ในการรับข้อมูลจากแป้นพิมพ์ซึ่งมีรูปแบบดังนี้

        

                                 scanf(“%รูปแบบ”, &ตัวแปร);

     

              รูปแบบ หมายถึง รูปแบบการรับข้อมูล เช่น %d ใช้กับการรับข้อมูลจำนวนเต็ม %fใช้กับการรับข้อมูลจำนวนจริง

              ในการรับข้อมูลสามารถรับข้อมูลได้ครั้งละหลายตัวแปรได้โดยจะต้องมีการระบุรูปแบบกำกับให้กับตัวแปรทุกตัว เช่น scanf(“%”, &x, &y); หมายถึงการรับข้อมูลชนิดจำนวนเต็มมาเก็บไว้ในตัวแปร x และ ตัวแปร y ที่ตำแหน่งของตัวแปรดังกล่าวในหน่วยความจำ ตามลำดับ โดยที่ตัวแปรทั้งสองได้มีการประกาศไว้ที่ส่วนต้นของโปรแกรมหลักแล้ว โดยจะต้องใช้เครื่องหมาย & นำหน้าตัวแปรทุกครั้งสำหรับฟังก์ชัน scanf()

     

     

     

    เนื่องจากตัวแปรมีหลายชนิด ดังนั้นจะขอแสดงรูปแบบการรับข้อมูลเข้าตามชนิดของตัวแปรดังนี้

    ชนิดข้อมูล

    ชนิดตัวแปร

    รูปแบบสำหรับ Scanf

    จำนวนเต็ม

    Short

    Integer

    Long

    Unsigned short

    Unsigned int

    Unsigned long

    %hd หรือ %hi

    %d หรือ %I

    %ld หรือ %li

    %hu

    %u

    %lu

    จำนวนจริง

    float

    double

    long double

    %f

    %lf

    %Lf

    อักขระ

    สายอักขระ

    Char

    Char s[]

    %c

    %s

        ตารางที่ 2.1 รูปแบบของตัวแปรแบบต่างๆ สำหรับฟังก์ชัน scanf()

     

    ตัวอย่าง 2.1

            การรับข้อมูลชนิดอักขระและสายอักขระ

              #include <stdio.h>

              main ()

              {

                       char a;

                       char b [10];

                       printf(“enter your string = “);

                       scanf(“%c%s”, &a, b); /* กรณีรับข้อมูลเป็นสายอักขระไม่ต้องมีเครื่องหมาย &

                                                    หน้าตัวแปร */

              }

     

     

        

    ข้อมูลป้อนจากผู้ใช้

     

     

         ผลการกระทำที่เกิดขึ้นบนจอภาพคือ

    enter your string = January

        

     

         การตัวอย่างข้างต้นจะเห็นว่าการรับข้อมูลโดยใช้ฟังก์ชันscanf() สำหรับตัวแปรชนิดอักขระ (a) และตัวแปรชนิดสายอักขระ (b) มีความแตกต่างกันที่ตัวแปรชนิดอักขระไม่ต้องมีเครื่องหมาย & หน้าตัวแปร เมื่อโปรแกรมรับข้อมูลจะกาแป้นพิมพ์แล้ว จะส่งผลให้ตัวแปร a มีค่า ‘J’    เก็บอยู่ และตัวแปร b[] มีค่าเป็น “anuary”

     

    ตัวอย่าง 2.2

         การรับข้อมูลชนิดจำนวนเต็ม

         #include <stdio.h>

          main()

         {            

                       int y;

                       printf (“enter an integer: “);

    ข้อมูลป้อนจากผู้ใช้

                                 scanf(“%d”, &y);

         }

         ผลการกระทำการที่เกิดขึ้นบนจอภาพคือ

     

    enter an integer: 123

     

     

     

     

     

     

    ตัวอย่าง 2.3

         การรับข้อมูลชนิดจำนวนเต็มที่มีการระบุจำนวนหลัก

         #include <stdio.h>

         main()

         {

                       int y, z;

                       printf(“enter a five digit integer: “);

                       scanf(“3d%d”, &y, &z);

                       printf(“your input number are %d and %d\n”, y, z);

         }

     

    ข้อมูลป้อนจากผู้ใช้

     

    enter a five digit integer:12345

    your input number are 123 and 45

     

     

     

     

            จากผลลัพธ์ที่เกิดขึ้นจะโปรแกรมทำการรับข้อมูลเข้าจากผู้ใช้โดยจะนำตัวเลข 3 ตัวแรกไปเก็บในตัวแปร y และนำตัวเลขที่เหลือไปเก็บในตัวแปร z เมื่อทำการแสดงค่าของ y โดยใช้ฟังก์ชัน printf() จึงได้ผลลัพธ์เป็น 123 และ 45 ตามลำดับ

    ตัวอย่าง 2.4

              การรับข้อมูลรูปแบบวันที่

              #include <stdio.h>

              main ()

              {

                       int month;

                       int day;

                       int year;

                       printf(“please input a date in the from dd-mm –yyyy : “);

                       scanf(“%d%*c%d%*c%d”, &day, &month, &year);

              }

    ข้อมูลป้อนจากผู้ใช้

              ผลการการกระทำที่เกิดขึ้นบนจอภาพคือ

     

    Please input a date in the form  dd-mm-yyyy:30-12-2003

     

     

            จากโปรแกรมข้างต้นผู้ใช้จะใส่ข้อมูลในรูปแบบวันที่ซึ่งจะมีเครื่องหมาย –คั่นระหว่างวันเดือนปี แต่โปรแกรมจะทำการรับข้อมูลเฉพาะส่วนที่เป็นตัวเลขแสดงวันเดือนปีเท่านั้น โดยจะข้ามเครื่องหมาย –เมื่อโปรแกรมกระทำการเสร็จสิ้นลงค่าที่เก็บในตัวแปร day, month และ year คือ 30,12 และ 2003 ตามลำดับ

    2.2  ฟังก์ชันในการแสดงผลข้อมูลออกทางจอภาพ

            เมื่อต้องการแสดงข้อความออกทางจอภาพหรือแสดงผลลัพธ์ที่ได้จากการกระทำการ ภาษาซีได้สร้างฟังก์ชันมาตรฐานเตรียมไว้โดยมีชื่อว่า rintf() การใช้งานฟังก์ชันนี้แบ่งเป็น 3 ลักษณะคือ การแสดงเฉพาะข้อความการแสดงค่าของตัวแปรที่ได้จากการประมวลผล และการแสดงทั้งข้อความและค่าที่เก็บอยู่ในตัวแปร การแสดงข้อความนี้สามารถจัดรูปแบบการขึ้นบรรทัด การเว้นวรรค ได้ดังแสดงในตารางที่ 2.2

    รหัสที่ใช้ในคำสั่ง printf

    ความหมาย

    \n

    เป็นการสั่งให้เคอร์เซอร์ขึ้นบรรทัดใหม่

    \t

    เป็นการสั่งให้เคอร์เซอร์เลื่อนไปทางขวา 1ช่วงแท็บ

    \a

    เป็นการสั่งให้เครื่องคอมพิวเตอร์ส่งเสียงระฆัง

    \\

    เป็นการแสดงสัญลักษณ์ออกทางจอภาพ 1 ตัว

    \”

    เป็นการแสดงสัญลักษณ์”ออกทางจอภาพ 1 ตัว

         ตารางที่ 2.2 รูปแบบของรหัสคำสั่งสำหรับการจัดรูปแบบโดยใช้ฟังก์ชัน printf()

     

    2.2.1        การแสดงเฉพาะข้อความ

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

                       printf(“ข้อความ”);

     

              เช่น printf(“This program will calculate tax\n”); โดยจะมีเครื่องหมายฟันหนู (“) ปิดที่หัวและท้ายข้อความและจะสังเกตเห็นว่ามีการใช้สัญลักษณ์ \n ต่อท้ายที่ข้อความซึ่งเป็นการใช้เคอร์เซอร์ขึ้นบรรทัดใหม่หลังจากแสดงข้อความนี้แล้ว ถ้าต้องการเว้นบรรทัดเพิ่มก็สามารถแสดงสัญลักษณ์\n เพิ่มเติมได้ และเมื่อต้องการเว้นวรรคหรือแสดงสัญลักษณ์ต่างๆ ก็สามารถใช้รหัสที่แสดงในตารางที่ 2.2

     

    ตัวอย่าง 2.5

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

              #include <stdio.h>

              main()

              {

                       printf(“Welcome to C”);

                       printf(“programming\n”);

                       printf(“This is my first program\n\n”);

                       printf(“Thank you”);

                       printf(“\nbye bye”);

              }

              ผลการกระทำการที่ปรากฏบนจอภาพคือ

    Welcome to Cprogramming

    This is my first program

    -บรรทัดว่าง-

    thank you

    bye bye

     

     

     

     

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

     

     

     

     

     

     

     

    ตัวอย่าง 2.6

              โปรแกรมแสดงการแสดงสัญลักษณ์ “ที่หัวและท้ายคำ”

              #include <stdio.h>

              main ()

              {

                       printf(“Good\t Morning\n “);

                        printf(“\new \” programmer\n”);

              }

              ผลการกระทำการที่ปรากฏบนจอภาพคือ

    Good Morning

    “new” programmer

     

     

     

              จะเห็นว่าผลการกระทำการของโปรแกรมคือ จะเว้นช่วง 1 แท็บระหว่างคำว่า Good และคำว่า Morning และมีการแสดงสัญลักษณ์ฟันหนู(“)ที่คำว่า new

    ตัวอย่าง 2.7

              โปรแกรมแสดงการแสดงสัญลักษณ์ขึ้นบรรทัดใหม่

              #include <stdio.h>

              main ()

              {

                       printf(“1 January \n2 February \n3 March \n4 April \n”);

                       printf(“5 May \n”);

              }

              ผลการกระทำการบนจอภาพคือ

    1 January

    2 February

    3 March

    4 April

    5 May

     

     

     

     

     

     

    2.2.2        การแสดงค่าของตัวแปรที่ได้จากการกระทำการ

                       เมื่อการกระทำโปรแกรมเสร็จสิ้นสามารถแสดงผลลัพธ์ที่เก็บอยู่ในตัวแปรได้โดยการระบุรูปแบบที่ต้องโดยดูได้จากตารางที่ 2.3 นอกจากนี้ยังสามารถระบุจำนวนตัวเลขหลังจุดทศนิยมที่ต้องการแสดงได้อีกด้วย เช่น printf(“%10.2f”, amount); ในกรณีที่ต้องการแสดงตัวเลขจากตัวแปรต่างๆ ในหลายบรรทัดและต้องการจัดรูปแบบให้อยู่ในสดมภ์เดียวกันก็สามารถนำการจัดรูปแบบลักษณะนี้มาใช้ได้เช่นเดียวกันดังตัวอย่าง 2.8

    ชนิดข้อมูล

    ชนิดตัวแปร

    รูปแบบสำหรับ printf

    จำนวนเต็ม

    Short

    Integer

    Long

    Unsigned short

    Unsingned int

    Unsgned long

    %dหรือ%i

    %dหรือ%I

    %ldหรือ%li

    %u

    %u

    %lu

    จำนวนจริง

    Float

    Double

    Long double

    %f

    %f

    %Lf

    ตัวอักขระ

    สายอักขระ

    Char

    Char s[]

    %c

    %s

     

         ตารางที่ 2.3 รูปแบบของรหัสคำสั่งสำหรับการจัดรูปแบบโดยใช้ฟังก์ชัน printf()

    ตัวอย่าง 2.8

              โปรแกรมแสดงตัวเลขในรูปแบบต่างๆ

              #include <stdio.h>

              main()

              {

                                 int a;

                                 double b;

                                 a = 1;

                                 b = 1040.041;

                                 printf(“%4I = %10.2f\n”, a, b);

                                 a = 2;

                                 b = 5.05;

                                 printf(“%4I = %10.2f\n”, a, b) ;

                                 a = 3;

                                 b = 1234567.351;

                                 printf(“%4I = %10.2f\n”, a, b);

                                 printf(“100%%”); //ใช้สัญลักษณ์% สองครั้งเมื่อต้องการแสดงสัญลักษณ์

                                                         % ทางจอภาพ

              }

              ผลการกระทำการที่ปรากฏบนจอภาพคือ

     

     

     

    1

    =

     

     

     

    1

    0

    4

    0

    .

    0

    4

     

     

     

    2

    =

     

     

     

     

     

     

    5

    .

    0

    5

     

     

     

    3

    =

    1

    2

    3

    4

    5

    6

    7

    .

    3

    5

    1

    0

    0

    %

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    ตัวอย่าง 2.9

              การแสดงตัวเลขที่ระบุเฉพาะจำนวนตัวเลขหลังจุดทศนิยม

              #include <stdio.h>

              main()

              {

                                 float a = 5;

                                 printf(“%.3f\n”, a);

                                 printf(“%.4f\n”, a);

              }

     

     

              ผลการกระทำการที่ปรากฏบนจอภาพคือ

    5

    .

    0

    0

    0

     

     

     

     

     

     

     

     

     

     

    5

    .

    0

    0

    0

    0

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

         ในการจัดรูปแบบผลลัพธ์ที่จะปรากฏบนจอภาพนั้นจะมีรูปแบบดังนี้

     

    “%

    Flag

    Maximum Width

    Precision

    Size

    Conversion code

     

    Flag มีค่าที่เป็นไปได้คือ – หมายถึงการจัดชิดซ้าย

              + หมายถึงการกำหนดให้แสดงเครื่องหมาย +หน้าตัวเลข

    maximumWidth คือ การกำหนดจำนวนสดมภ์ที่จองไว้สำหรับการแสดงผลข้อมูล

    precision คือการกำหนดจำนวนตัวเลขหลังจุดทศนิยม

    size จะสอดคล้องกับชนิดของตัวแปร เช่น h ใช้กับตัวแปรชนิด int ถ้าเป็น l จะใช้กับตัวแปรชนิด double เป็นต้น ดังตารางที่ 2.3

     

    conversion code คือการกำหนดชนิดของข้อมูลในการแสดงผลเช่น

          ถ้ามีค่าเป็น O (โอ) หมายถึงการแปลงค่าของข้อมูลให้เป็นเลขบานแปด

          ถ้ามีค่าเป็น x หมายถึงการแปลงค่าของข้อมูลให้เป็นเลขฐานสิบหก

          ถ้ามีค่าเป็น d หมายถึงการแปลงค่าของข้อมูลให้เป็นเลขฐานสิบ

          ถ้ามีค่าเป็น s หมายถึงการแสดงสายอักขระ

          ถ้ามีค่าเป็น e หมายถึงการแสดงตัวเลขให้เป็นรูปแบบวิทยาศาสตร์

          ถ้ามีค่าเป็น f หมายถึงการแสดงตัวเลขในรูปแบบตัวเลขจำนวนจริงที่มีจุดทศนิยม

          ถ้ามีค่าเป็น p หมายถึงการแสดงค่าที่เก็บในตัวแปรชนิดตัวชี้ (ดูรายละเอียดในบทที่ 7)

     

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

    ตัวระบุรูปแบบ

    ความหมาย

    e หรือ E

    แสดงตัวเลขในรูปแบบวิทยาศาสตร์ เช่น 1.357911e+10

    f

    แสดงตัวเลขในแบบทศนิยม เช่น 2.4567

    g หรือ E

    แสดงตัวเลขในรูปแบบวิทยาศาสตร์หรือแสดงตัวเลขในแบบทศนิยม

    L

    ใส่ไว้หน้าตัวระบุรูปแบบ f เพื่อเป็นการแสดงถึงการแสดงเลขแบบ long double

    ตารางที่ 2.4 การจัดรูปแบบตัวเลขที่มีจุดทศนิยม

    ตัวอย่าง 2.10

              การจัดรูปแบบจำนวนจริง

              #include  <stdio.h>

              main ()

              {

                                 printf(“%e\n”, 9876543.21);

                                 printf(“%e\n”, +9876543.21);

                                 printf(“%e\n”, -9876543.21);

                                 printf(“%E\n”, -9876543.21);

                                 printf(“%f\n”, 9876543.21);

                                 printf(“%g\n”, 9876543.21);

                                 printf(“%G\n”, 9876543.21);

              }

              ผลการกระทำการที่ปรากฏบนจอภาพคือ

    9

    .

    8

    7

    6

    5

    4

    3

    e

    +

    0

    0

    6

     

     

     

     

    9

    .

    8

    7

    6

    5

    4

    3

    e

    +

    0

    0

    6

     

     

     

     

    -

    9

    .

    8

    7

    6

    5

    4

    3

    e

    +

    0

    0

    6

     

     

     

    9

    .

    8

    7

    6

    4

    3

    2

    E

    +

    0

    0

    6

     

     

     

     

    9

    8

    7

    6

    5

    4

    3

    .

    2

    1

     

     

     

     

     

     

     

    9

    .

    8

    7

    6

    5

    4

    e

    +

    0

    0

    6

     

     

     

     

     

    9

    .

    8

    7

    6

    5

    4

    E

    +

    0

    0

    6

     

     

     

     

     

    ตัวอย่าง 2.11

              การจัดรูปแบบจำนวนเต็ม

              #include <Stdio.h>

              main()

              }

                                 printf(“%5d\n”, 9);

                                 printf(“%5d\n”, 98);

                                 printf(“%5d\n”, 987);

                                 printf(“%5d\n”, 9876);

                                 printf(“%5d\n”, 98765);

                                 printf(“%5d\n”, 987654);

                                 printf(“%5d\n”, -9);

                                 printf(“%5d\n”, -98);

                                 printf(“%5d\n”, -987);

                                 printf(“%5d\n”, -9876);

                                 printf(“%5d\n”, -98765);

                                 printf(“%5d\n”, -987654);

              }

              ผลการกระทำการที่ปรากฏบนจอภาพคือ

     

     

     

     

    9

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    9

    8

     

     

     

     

     

     

     

     

     

     

     

     

     

    9

    8

    7

     

     

     

     

     

     

     

     

     

     

     

     

    9

    8

    7

    6

     

     

     

     

     

     

     

     

     

     

     

    9

    8

    7

    6

    5

    4

     

     

     

     

     

     

     

     

     

     

     

     

     

    -

    9

     

     

     

     

     

     

     

     

     

     

     

     

     

    -

    9

    8

     

     

     

     

     

     

     

     

     

     

     

     

    -

    9

    8

    7

     

     

     

     

     

     

     

     

     

     

     

    -

    9

    8

    7

    6

     

     

     

     

     

     

     

     

     

     

     

    -

    9

    8

    7

    5

     

     

     

     

     

     

     

     

     

     

     

    -

    9

    8

    7

    6

    5

    4

     

     

     

     

     

     

     

     

     

     

     

    ตัวอย่าง 2.12

              แสดงสายอักขระหรือข้อมูลในแถวลำดับ

              #include <stdio.h>

              main()

              {

                       char string[] = “This string is printed”;

                       char alpha = ‘a’;

                       printf(“%s\n”, string);

                       printf(“%c\n”, alpha);

                       printf(“%24\n”, string);

                       printf(“7s\n”, string);

              }

             

    ผลการกระทำการที่ปรากฏบนจอภาพคือ

    T

    h

    I

    S

     

    S

    T

    E

    I

    N

    G

     

    I

    S

     

    P

    R

    I

    N

    T

    E

    d

     

     

    a

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    T

    H

    I

    S

     

    S

    T

    R

    I

    N

    G

     

    I

    S

     

    P

    R

    I

    N

    T

    E

    D

    T

    H

    I

    S

     

    S

    T

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

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

     

     

     

     

     

    ตัวอย่าง 2.13

              การจัดรูปแบบโดยใช้เครื่องหมาย + เพื่อแสดงเครื่องหมายหน้าตัวเลข

              #include <stdio.h>

              main ()

              {

                                 printf(“%+08d\n”, 999);

                                 printf(“%08d\n”, 999);

              }

    ผลการกระทำการที่ปรากฏบนจอภาพคือ

    +

    0

    0

    0

    0

    9

    9

    9

     

     

     

     

     

     

     

     

    0

    0

    0

    0

    0

    9

    9

    9

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    ตัวอย่าง 2.14

              การจัดรูปแบบชิดซ้ายและชิดขวา

              #include <stdio.h>

              main()

              }

                       printf(“%s%10d%10c\n”, “good”, 3, ‘x’);

                       //ใช้เครื่องหมาย-เมื่อต้องการจัดชิดซ้าย

                       pintf(“%-10s%-10d%-10c%\n”, “good”, 3,’x’);

              }

              ผลการกระทำการที่ปรากฏบนจอภาพคือ

     

     

     

     

     

     

    G

    O

    O

    D

     

     

     

    3

     

     

     

    X

     

     

    G

    O

    O

    D

     

     

     

     

     

     

    3

     

     

     

    X

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    ตัวอย่าง 2.15

              การแสดงค่าของตัวแปรในรูปแบบเลขฐานแปดและฐานสิบหก

              #include <stdio.h>

              main()

              {

                       printf(“%o\n”,455);                 //แสดงในรูปแบบเลขฐานแปด

                       printf(“%x\n”,455);                  //แสดงในรูปแบบเลขฐานสิบหก

                       printf(“%d\n”,455);                 //แสดงในรูปแบบเลขฐานสิบ

              }

         ผลการกระทำการที่ปรากฏบนจอภาพคือ

    7

    0

    7

     

     

     

     

     

     

     

     

     

     

     

     

     

    1

    C

    7

     

     

     

     

     

     

     

     

     

     

     

     

     

    4

    5

    5

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

         นอกจากการใช้ฟังก์ชัน printf() ในการแสดงข้อความแล้ว ภาษาซียังได้จัดเตรียมฟังก์ชันที่ใช้ในการแสดงสายอักขระชื่อ puts() โดยมีรูปแบบการเรียกใช้ดังนี้

     

                       puts(“ข้อความ”);

              หรือ   puts(ตัวแปรชนิดตัวชี้ที่ชี้ไปยังข้อมูลชนิดตัวอักขระ);

     

    ตัวอย่าง 2.16

              การใช้ฟังก์ชัน gets() และ puts() ในการแสดงผลข้อความ

              #include <stdio.h>

              main ()

              {

                       char input [50];

                       puts (“please enter sentence:”);

         gets (input); /*ฟังก์ชัน gets()ทำหน้าที่รับข้อมูลเข้าผ่านทางแป้นพิมพ์มาเก็บไว้ในตัวแปร*/

                       puts(“This is an output\n”);

    ข้อมูลป้อนจากผู้ใช้

                                 puts (input);

              }

              ผลการกระทำการบนจอภาพคือ

    Please enter sentence: hello

    This is an output

    hello

     

     

     

    2.2.3  การแสดงทั้งข้อความและค่าที่เก็บในตัวแปร

                  ฟังก์ชัน printf() สามารถใช้ในการแสดงทั้งข้อความและค่าที่เก็บค่าตัวแปรได้เช่น printf(“The value of b = %10.2f”,b); ดูตัวอย่างโปรแกรมด้านล่าง

    ตัวอย่าง 2.17

              การรับข้อมูลชนิดตัวอักขระและสายอักขระ

              #include <stdio.h>

              main()

              {

                       char a;

                       char b[10];

                       printf(“enter your string = “);

                       scanf(“%c%s”, &a, b); /* กรณีรับข้อมูลเป็นสายอักขระไม่ต้องมีเครื่องหมาย &

                                                    หน้าตัวแปร*/

                       printf(“your character is \”%c\” “, a);

    ข้อมูลป้อนจากผู้ใช้

                                          printf(“your string is \ “%s\”\n”, b);

              }

              ผลการกระทำการที่เกิดขึ้นบนจอภาพคือ

    Enter your string = January

    Your character is “J”

    Your string is “anuary”

     

     

     

     

    ตัวอย่าง 2.18

              การใช้ฟังก์ชัน printf() ในการแสดงทั้งข้อความและค่าที่เก็บในตัวแปร

              #include <stdio.h>

              #define amount 5000.00

              #define rate 0.06

              #define period 7

              main ()

              {

                     printf(“rate:   %7.2f%%\n”, rate);

                     printf(“amount:      %7.2f\n\n”, amount);

                     printf(“period:         %7I years”, period);

              }

              ผลการกระทำการที่ปรากฏบนจอภาพคือ

    R

    A

    T

    E

    :

     

     

    0

    .

    0

    6

    %

     

     

     

     

     

     

     

    A

    M

    O

    U

    N

    T

    :

    5

    0

    0

    0

    .

    0

    0

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    P

    E

    R

    I

    O

    D

    :

     

     

     

     

     

     

    7

    Y

    E

    A

    R

    s

     

    ตัวอย่าง 2.19

              การรับและแสดงผลข้อมูลโดยใช้ฟังก์ชัน scanf() และ printf()

              #include <stdio.h>

              main ()

              {

                     char d1, d2, d3, d4;

                     int x;

                     scanf(“%d%c%c%c”, &x, &d1, &d2, &d3, &d4);

                     printf(“%d%c%c%c%c”, x, d1, d3, d2, d4);

              }

              จากโปรแกรมในตัวอย่าง 2.19 ถ้าผู้ใช้ป้อนข้อมูล 97 354 ฟังก์ชัน scanf() จะนำข้อมูล     เลข 97 ไปเก็บไว้ในตัวแปร x นำตัวอักขระช่องว่างไปเก็บไว้ในตัวแปร d1 นำตัวอักขระ 3 ไปเก็บไว้ในตัวแปร d2  นำตัวอักขระ  5  นำตัวอักขระ 5 ไปเก็บไว้ในตัวแปร d3 และนำตัวอักขระ 4       ไปเก็บไว้ในตัวแปร d4  และเมื่อโปรแกรมทำงานถึงฟังก์ชัน pintf() โดยจะทำการแสดงค่าของตัวแปรแต่ละตัวตามลำดับดังนี้ 97 634

    ตัวอย่าง 2.20

              การรับและแสดงผลตัวแปรชนิด unsigned

              #include <stdio.h>

              main ()

         {

              unsingned x;

              printf(“enter number “);

              scanf(“%u”, &x);

    ข้อมูลป้อนจากผู้ใช้

                       printf(“you entered %u”, x);

         }

         ผลการกระทำการบนจอภาพคือ

    Enter  number 8

    You entered 8

     

     

     

    ตัวอย่าง 2.21

              การรับและแสดงผลตัวแปรชนิด long

              #include <stdio.h>

              main ()

              {

                     long result;

                     printf(“please enter result : “);

                     scanf(“%ld”,&result);

                     printf(“You enter %ld \n”, result);

              }

    ข้อมูลป้อนจากผู้ใช้

     

     

    ผลการกระทำการบนจอภาพคือ

    Please enter result:0

    Your enter 0

     

             

     

     

    นอกจากนี้การรับข้อมูลชนิดอักขระ (char) สามารถใช้ฟังก์ชัน getchar()และใช้ฟังก์ชัน putchar() ในการแสดงผลบนจอภาพ โดยมีรูปแบบดังนี้

                     ตัวแปร = getchar();

              เช่น data = getchar(); จะเป็นการรับข้อมูล 1 ตัวอักขระมาเก็บไว้ในตัวแปร data ส่วนการแสดงผลออกทางจอภาพจะใช้ ฟังก์ชัน putchar ซึ่งมีรูปแบบดังนี้

                                 putchar(ตัวแปร);

                     เช่น putchar(data);

    ตัวอย่าง 2.22

              แสดงการใช้ฟังก์ชัน getchr() และ putcar()

              #include <stdio.h>

              main()

              {

                     char c;

                     printf(“please enter an alphabet : “);

    ข้อมูลป้อนจากผู้ใช้

                                 c = getchar();

                     printf(“your alphabet is “);

                     putchar(c);

              }

    Please enter an alphabet :s

    Your alphabet is s 

                       ผลการกระทำการที่ปรากฏบนจอภาพคือ

     

             

     

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

    http://elearning.narinukul.ac.th/ICT1/%E0%B8%A0%E0%B8%B2%E0%B8%A9%E0%B8%B2%E0%B8%8B%E0%B8%B5.htm

     

    นิพจน์  (expressions)

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

            นิพจน์ที่มีระดับการประมวลผลแบบง่ายที่สุด จะประกอบด้วย ตัวแปรเพียงตัวเดียว หรือ ค่าคงที่ นิพจน์ที่มีลักษณะเป็นค่าคงที่ เช่น

                    100

                    ‘g’

            นิพจน์ที่เป็นค่าคงที่ที่เป็นสัญลักษณ์ เช่น

                    #define VAT 7

                    #define PI 3.14159

                    cosnt int a = 35;

                    cosnt char ch = ‘m’;

            จากข้อความสั่งในภาษาซีดังกล่าวข้างต้น ทำให้ VAT, PI, a และ ch ต่างเป็นนิพจน์ที่เป็นค่าคงที่

            นิพจน์ที่มีลักษณะเป็นตัวแปร เช่น

                    int count ;

                    float amount;

                    char ch;

            จากข้อความสั่งในภาษาซีดังกล่าวข้างต้น ทำให้ count, amount และ ch ต่างเป็นนิพจน์ที่เป็นตัวแปรดังนั้น นิพจน์ จึงหมายถึง จำนวนใดจำนวนหนึ่งต่อไปนี้

    -          จำนวนเต็มจำนวนเดียว

    -          จำนวนจริงจำนวนเดียว

    -       ตัวเลขจำนวนเต็ม หรือ ตัวเลขจำนวนจริง หลายจำนวนที่เชื่อมโยงกันด้วยตัวดำเนินการ +, -,*,/ หรือ % ซึ่งเรียกว่า การคำนวณทางคณิตศาสตร์

            สำหรับนิพจน์ที่มีระดับการประมวลผลที่ซับซ้อน จะประกอบด้วย นิพจน์ที่มีระดับการประมวลผลอย่างง่ายหลายนิพจน์ และเชื่อมต่อกันด้วยตัวดำเนินการ เช่น

            นิพจน์ที่ประกอบด้วย 2 นิพจน์ และ 1 ตัวดำเนินการ

                    37+6

                    54*7

                    405/9

            นิพจน์ที่มีความซับซ้อนมากขึ้น เช่น

                    score1 *2 + score2 *5 +score3 *3

    1.6  ข้อความสั่งกำหนดค่า (assingnment statemnent)

            ข้อความสั่งกำหนดค่า ใช้สำหรับกำหนดค่าให้กับตัวแปร มีรูปแบบดังนี้

                            ตัวแปร = นิพจน์;

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

            เมื่อนำนิพจน์มาเขียนไว้ในโปรแกรมภาษาซีจะกลายเป็นข้อความกำหนดค่า ดังตัวอย่างต่อไปนี้

                            n = 10.5;

                            result = 25 * 6;

                            point = scorel * 2 + score2 5 + score3 * 3;

    ตัวอย่าง 1.17

            การใช้ข้อความสั่งกำหนดค่า

            #include <stdio.h>

            main ()

            {

                    int a, b;

                    scanf (“%d”,&a);

                    a = b;                               // นำค่าที่เก็บใน b ไปเก็บไว้ใน a

                    printf(“ a is %d\n” a);

                    printf (“b is %d\n”, b);

            }

    ข้อความสั่งกำหนดค่าอาจเขียนได้ในรูปแบบที่ซับซ้อนขึ้นดังนี้

                    a = b = 0;

            กำหนดให้เก็บค่าศูนยืไว้ใน  a และ b

     

    ตัวอย่าง 1.18

            การใช้ข้อความสั่งกำหนดค่าในรูปแบบที่ซับซ้อน

            #include <stdio.h>

            main()

            {

                    int sum, total;

                    sum = total = 0;

                    printf(“sum = %d \n”, sum);

                    printf(“ total = %d \n”, total);

            }

            ผลการกระทำการ

            um = 0

            total =0

            -

     

    1.7  การคำนวณทางคณิตศาสตร์

            ในการเขียนโปรแกรม เพื่อทำการคำนวณทางคณิตศาสตร์ จะต้องใช้ตัวดำเนินการต่างๆ ซึ่งมีวิธีการใช้งาน และการทำงาน ดังนี้

    การคำนวณ

    ตัวดำเนินการ

    ตัวอย่าง

    การทำงาน

    บวก

    +

    c=a+b;

    นำค่าที่เก็บในa บวกกับค่าที่เก็บใน b แล้วเก็บผลลัพธ์ไว้ใน c

    ลบ

    -

    c=a-b;

    นำค่าที่เก็บใน b ลบออกจากค่าที่เก็บใน a แล้วเก็บผลลัพธ์ไว้ใน c

    คูณ

    *

    c=a*b;

    นำค่าที่เก็บใน a คูณกับค่าที่เก็บใน b แล้วเก็บผลลัพธ์ไว้ใน c

    หาร

    /

    c=a/b;

    ให้ค่าที่เก็บใน a เป็นตัวตั้ง ค่าที่เก็บใน b เป็นตัวหารแล้วเก็บผลหารไว้ใน c ถ้าทั้งตัวตั้งและตัวหารต่างเป็นจำนวนเต็มค่าที่เก็บใน c จะเป็นจำนวนเต็มแต่ถ้าตัวตั้งหรือตัวหารตัวใดตัวหนึ่งเป็นจำนวนจริงที่มีทศนิยม ผลลัพธ์ที่ได้จะเป็นจำนวนจริงที่มีทศนิยมด้วย

    มอดูลัส

    %

    c=a%b;

    ให้ค่าที่เก็บใน a เป็นตัวตั้ง ค่าที่เก็บใน b เป็นตัวหารแล้วเก็บเศษไว้ใน c

     

    ตัวอย่าง 1.19

            การแสดงผลลัพธ์ของการบวก

            #include <stdio.h>

            main()

            {

                    int a, b, sum;                   

                    scanf(“%d”, &a);              //รับค่าจำนวนเต็มมาเก็บไว้ใน a

                    scanf(“%d’,&b);                        //รับค่าจำนวนเต็มมาเก็บไว้ใน a

                    printf(“sum is %d\n”, a+b);       //แสดงผลจากการบวก

            }

     

    ตัวอย่าง 1.20

            การใช้ข้อความสั่งกำหนดค่า และแสดงผลลัพธ์ของการบวก

            #include <stdio.h>

            main ()

            {

                    int a, b, sum;

                    scanf(“%d”, &a);              //รับค่าจำนวนเต็มมาเก็บไว้ใน a

                    scanf(“%d”, &b);              //รับค่าจำนวนเต็มมาเก็บไว้ใน b

                   sum = a + b;             /* นำค่าที่เก็บใน a บวกกับค่าที่เก็บใน b แล้วนำผลบวกไปเก็บใน sum */

                   printf(“Sam is %d\n”,sum);       //แสดงผลจากการบวก

                   sum =sum + sum;     /*นำค่าที่เก็บใน sum บวกกัน แล้วเก็บไว้ใน sum ตามเดิม */

                   printf(“Sum is %d\n” , sum);     //แสดงค่าที่เก็บไว้ใน sum

           }

     

    ตัวอย่าง 1.21

           การแสดงผลลัพธ์ของการคูณ

           #include <stdio.h>

           #define GP 454

           int gram, pound;

           main ()

           {

                   scanf(“%d”, &pound);              //รับค่าจำนวนเต็ม pound

                   gram = pound * GP;         //แปลงปอนด์ให้เป็นกรัม

                   priintf(“weight in grams= %d\n”, gram);    //แสดงค่ากรัมที่ได้จากการแปลง

           }

     

    ตัวอย่าง 1.22

           การแสดงผลลัพธ์ของการหารและมอดูลัส

           #include <stdio.h>

           #define MS 60                  // กำหนดให้ MS เป็นตัวคงที่มีค่า 60

           #define HM 60                  //กำหนดให้ HM เป็นตัวคงที่มีค่า 60

           int sec, min, hr, sec_left, min_left;

           main ()

           {

                   scanf(“%d”, &sec);    //รับค่า sec (วินาที)

                   min = sec / MS;        //แปลงวินาทีให้เป็นนาที

                   sec_left = sec % MS;       //หาเศษวินาทีจากการแปลงเป็นนาที

                   hr= min /HM;             //แปลงนาทีให้เป็นชั่วโมง

                   min_left =min % HM; //หาเศษนาทีจากการแปลงเป็นชั่วโมง

                   printf (“%d seconds is equal to “, sec);

                   printf(“%d h, %d m, and %d s”, hr, min_left, sec_left);

           }

    ตัวอย่าง 1.23

           การแสดงผลลัพธ์ของการหาร

           #include <stdio.h>

           main ()

           {

                   printf(“\n integer division”);

                   printf(“\n 11/4 = %d”,11/4);      //การหาร โดยมีตัวตั้งและตัวหารเป็นจำนวนเต็ม

                   printf(“\n ¾ = %d”, ¾);      //การหารโดยมีตัวตั้งและตัวหารเป็นจำนวนเต็ม

                   printf(“\n floating point division”);

                   printf(“\n 11./4. = %f”, 11./4.); /* การหาร โดยมีตัวตั้งและตัวหารเป็นจำนวนจริงที่มีทศนิยม*/

                   printf(“\n 3./4 = %f”, 3./4.);       /* การหาร โดยมีตัวตั้งและตัวหารเป็นจำนวนจริงที่มีทศนิยม */

           }

           ผลการกระทำการ

           integer division

           11/4 = 2

           3/4 = 0

           floating point division

           11./4. = 2.750000

           3./4.=0.750000

    ตัวอย่าง 1.24

           การใช้ข้อความสั่งกำหนดค่า และการบวก

           #include <stdio.h>

           main ()

           {

                   int a, b, x;

                   a = 20;                     //กำหนดให้เก็บค่า 20 ไว้ใน a

                   x = a;                       //กำหนดให้เก็บค่าที่อยู่ใน a ไว้ใน b

                   printf(“x is %d\h”, x);                //แสดงค่าที่เก็บใน x

                   x = a +l;                   //นำค่าที่เก็บใน a บวก 1 แล้วเก็บใน x

                   printf(“x is %d\n”, x);                //แสดงค่าที่เก็บใน x

                   b = 30;                     //กำหนดให้เก็บค่า 30 ไว้ใน b

                   x = a + b;                 // นำค่าที่อยู่ใน a บวกกับค่าที่อยู่

                                                   ใน b แล้วเก็บไว้ใน x 

                   printf(“x is %d\n” , x);               // แสดงค่าที่เก็บใน x

           }

           ผลการกระทำการ

           x is 20

           x is 21

           x is 50

           -

     

    ลำดับการดำเนินการในนิพจน์ที่มีตัวดำเนินการหลายตัว

           ในกรณีที่นิพจน์มีตัวดำเนินการหลายตัว จะต้องดำเนินการตามลำดับต่อไปนี้

    1.      ()

    2.      * / %

    3.      +   -

    ถ้าในนิพจน์มีตัวดำเนินการที่มีลำดับเท่ากัน จะประมวลผลจากซ้ายไปขวา

     

    ตัวอย่าง 1.25

            การประมวลผลนิพจน์มีตัวดำเนินการหลายตัว

            #include <stdio.h>

            main ()

            {

                    int p, q, r, w, m, n, y;

                    p = 30;

                    q = 2;

                    r = 10;

                    w = 7;

                    m = 20;

                    n = 5;

                    y = p + q * r % w – m / n;

                    printf(“y = %d” , Y) ;

            }

            ผลการกระทำการ

            y = 32

            การประมวลผลนิพจน์ p+q *r %w –m/n จะทำตามลำดับดังนี้

    1.      q*r  = 2*10 = 20

    2.      20%w = 20%7 = 6

    3.      m/n  = 20/5 = 4

    4.      p+6 = 30+6 = 36

    5.      36-4 = 32

    ตัวอย่าง 1.26

            การใช้ข้อความสั่งกำหนดค่าในรูปแบบที่ซับซ้อน และมีตัวดำเนินการหลายตัว

            #include <stdio.h>

            main ()

            {

                    float sum, point, scorel, score2, score3;

                    scanf(“%f%f”, &scorel, &scorel, &score2, &score3);

                    sum = point = scorel*2 + score2 5 +score3 3;

                    printf(“sum = %f \n’,sum);

                    printf(“point = %f\n”, point);

            }

     

    1.8  ตัวดำเนินการเอกภาค (unary operator)

            ตัวดำเนินการเอกภาค คือ การใช้ตัวดำเนินการ กับตัวแปรตัวเดียว ในที่นี้จะแสดง การใช้ตัวดำเนินการ 2 ตัวกับตัวแปรตัวเดียว ซึ่งมีลักษณะการใช้ แบบคือ

    1.    ตัวดำเนินการการเอกภาคเติมหลัง (postfix mode) หมายถึง ตัวดำเนินการเอกภาคอยู่หลังตัวแปร เช่น a++ หมายถึง ให้เพิ่มค่าให้ตัวแปร a ขึ้นอีก 1

    2.    ตัวดำเนินการเอกภาคเติมหน้า (prefix mode) หมายถึง ตัวดำเนินการเอกภาคอยู่หลังตัวแปร เช่น ++a หมายถึง ให้เพิ่มค่าให้ค่าให้ตัวแปร a ขึ้นอีก 1

           

    การใช้ตัวดำเนินการเอกภาคทั้ง 2 แบบมีการใช้งานดังนี้

    การคำนวณ

    ตัวดำเนินการ

    ตัวอย่าง

    การทำงาน

    เพิ่มค่าตัวถูกดำเนินการทีละหนึ่ง

    ++

    X++

    X=x+1

    เพิ่มค่าตัวถูกดำเนินการทีละหนึ่ง

    ++

    ++X

    X=X+1

    ลดค่าตัวถูกดำเนินการทีละหนึ่ง

    - -

    --X

    X=X-1

    ลดค่าตัวถูกดำเนินการทีละหนึ่ง

    --

    X --

    X=X-1

     

    ตัวอย่าง 1.27

            การใช้ตัวดำเนินการเอกภาค

            #include <stdio. H>

            main ()

            {

                int a, b, x;

                a = 20;                         //กำหนดให้เก็บค่า 20 ไว้ใน a

                x = a;                           //กำหนดให้เก็บค่าที่เก็บใน a ไว้ใน b

                printf(“x is %d\n”, x);            //แสดงค่าที่เก็บใน x

                x ++;                            // เพิ่มค่า x ขึ้นอีก 1

                printf(“x is %d\n”, x);            //แสดงค่า x

                b = 30;                         //กำหนดให้เก็บค่า 20 ไว้ใน a

                x = a + b;                             //*กำหนดให้นำค่าที่อยู่ใน a บวกเข้ากับที่เก็บ

                                                       ใน b แล้วนำไปเก็บไว้ใน x*/

                printf(“x is %d\n”, x);            //แสดงค่าที่เก็บใน x

            }

                ผลการกระทำการ

                x is 20

                x is 21

                x is 50

            จากที่กล่าวมาแล้วข้างต้น จะเห็นว่าการใช้ตัวดำเนินการเอกภาคทั้ง 2 แบบมีการทำงานเหมือนกัน แต่ในความเป็นจริง ตัวดำเนินการเอกภาคเติมหลัง มีการทำงานและความหมายแตกต่างจากตัวดำเนินการเอกภาคเติมหน้า เมื่อมีการใช้งานร่วมกับการทำงานอื่นภายในคำสั่งเดียวกัน ดังนี้

    -          ตัวดำเนินการเอกภาคเติมหลัง (postfix mode) จะทำงานอื่นภายในข้อความสั่งเดียวกันก่อน จึงจะเพิ่มค่าให้ตัวแปร

    -          ตัวดำเนินการภาคเติมหน้า (prefix mode) จะเพิ่มค่าให้ตัวแปรก่อนแล้วจึงจะทำงานอื่นภายในข้อความสั่งเดียวกัน

    ตัวอย่าง 1.28

            การใช้ตัวดำเนินการเอกภาคร่วมกับการทำงานอื่นๆ ภายในข้อความสั่งเดียวกัน

            #include <stdio.h>

            main ()

            {

                    int x, y;

                    x = y = 0;

                    printf(“\nx y”);

                    printf(“\n%d %d”, x++; ++y); /*พิมพ์ค่า x ก่อนแล้วจึงเพิ่มค่า x ขึ้นอีก 1 เพิ่มค่า y – ขึ้นอีก 1 แล้วจึงพิมพ์ค่า y */

                    printf(“\n%d %d”, x++, ++y);

                    printf(“\n%d %d”, x++, ++y);

                    printf(“\n%d %d”, x++, ++y);

                    printf(“\n%d %d”, x++, ++y);

                    y = x++;                   //เก็บค่า xไว้ใน y ก่อนแล้วจึงเพิ่มค่า x ขึ้นอีก 1

                    printf(“\n%d %d”, x, y);

                    y = ++x;                   // เพิ่มค่า x ขึ้นอีก 1 แล้วจึงเก็บค่า x1 ไว้ใน y

                    printf(“\n%d %d”, x,y);

            }

            ผลการกระทำการ

            x      y

            0      1

            1      2

            2      3

            3      4

            4      5

            5      4

            6      6

    1.9  ตัวดำเนินการประกอบ (Compound operator)

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

    ตัวดำเนินการประกอบ

    ตัวอย่าง

    การทำงาน

    +=

    X+=5

    X=x+5

    -=

    x-=5

    X=x-5

    *=

    X*=y

    X=x*y

    /=

    X/=y

    X=x/y

    %=

    X%=5

    X=x%5

    +=

    X+=y/8

    X=x+y/8

     

    ลำดับในการดำเนินการ

            ในกรณีที่คำสั่งประกอบด้วยตัวดำเนินการประกอบ ตัวดำเนินการเอกภาคหลายตัว           จะประมวลผลตามลำดับต่อไปนี้

    1.      ()

    2.      ++ --

    3.      */ %

    4.      + -

    5.      + = * = / = - = % =

    ถ้าในคำสั่งมีตัวดำเนินการที่อยู่ในลำดับเท่ากัน จะประมวลผลจากซ้ายไปขวา

    ตัวอย่าง 1.29

            การใช้ตัวดำเนินการประกอบ

            #include <stdio.h>

            main ( )

            {

                    int    x = 10, y = 20;

                    printf(“\n %d %d”, x, y);

                    ++x;

                    printf(“\n %d %d”,x, y);

                    y = - - x;

                    printf(“\n %d %d”, x,y);

                    x = x -- + y;

                    printf(“\n %d %d”, x, y);

                    y = x - ++x;

                    printf(“\n %d %d”, x, y);

            }

            ผลการกระทำการ

    10                20

    11                20

    10                10

    19                10

    20                0

            การทำงานของคำสั่งกำหนดค่าและคำสั่งที่เปลี่ยนแปลงค่าของตัวแปร  x และ y

    คำสั่ง

    x

    y

    int x = 10, y = 20;

    10

    20

    ++x;

    11

    20

    y=--x;

    10

    10

    x=x -- +y;

    19

    10

    y=x - ++x;

    20

    0

    1.10          การแปลงชนิดข้อมูล (type cast)

            การแปลงชนิดข้อมูลมีหลายวิธี แต่ที่กล่าวในที่นี้ คือการแปลงชนิดข้อมูลโดยการกำหนดชนิดไว้ที่หน้าข้อมูลนั้น รูปแบบ

            ตัวแปร = (ชนิดข้อมูล) นิพจน์;

            โดยที่   (ชนิดข้อมูล) นิพจน์ อาจมีหลายชุดแล้วเชื่อมโยงกันด้วยตัวดำเนินการต่างๆ

    ตัวอย่าง 1.30

            การแปลงชนิดข้อมูล จากจำนวนจริงที่มีทศนิยมให้เป็นจำนวนเต็ม

            #include <stdio.h>

            main ( )

            {

                            int x;

                            x = 5.6 + 3.5;

                            printf(“\n %d”, x);

                            x=(int) 5.6 + (int) 3.5;       // แปลง 5.6 ให้เป็น 5 และแปลง 3.5 ให้เป็น 3

                            printf(“\n %d”, x);

            }

            ผลการกระทำการ

            9

            -บรรทัดว่าง-

            8

    ตัวอย่าง 1.31

            การแปลงชนิดข้อมูลจากจำนวนเต็มให้เป็นจำนวนจริงที่มีทศนิยม

            #include <stdio.h>

            main ()

            {

                            int x = 3, y = 2;

                            float a, b;

                            a = x / y;  //ทั้งตัวตั้งและตัวหารต่างเป็นจำนวนเต็ม ผลลัพธ์จึงปัด

                                            เศษทิ้ง

                            printf(“\n %f”, a);

                            b = (float) x / y;        /* กำหนดให้ตัวตั้งเป็นจำนวนจริงที่ทศนิยม

                                                ผลลัพธ์จึงเป็นจำนวนจริงที่มีทศนิยมด้วย */

                            printf(“\n %f”, b);

            }

            ผลการกระทำการ

            1.000000

            1.500000

     

    1.11          การกำหนดค่าจากข้อมูลหลายชนิด (assignment with mixed types)

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

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

            ดังนั้น ถ้าตัวแปร หรือ ตัวคงที่ ตัวหนึ่งเป็นชนิดจำนวนเต็ม (int) ส่วนอีกตัวหนึ่งเป็นชนิดจำนวนจริง (float) จะต้องแปลงตัวแปรหรือตัวคงที่ที่เป็นจำนวนเต็ม (int) ให้เป็นจำนวนจริง (float) ก่อน แล้วจึงดำเนินการ

     

     

     

    ตัวอย่าง 1.32

            แสดงการกำหนดค่าจากข้อมูลหลายชนิด

            #include <stdio.h>

            main ( )

            {

                            int i, j, k;

                            float a, b, c;

                            i = 5;

                            j = 3;

                            a = 2.5;

                            b=30.6;

                            k=i +a;                     /*แปลงชนิดข้อมูลของ i ให้เป็น float ก่อนแล้ว

                                                    จึงบวก จากนั้นปิดเศษทิ้ง

                                                     แล้วค่อยนำไปเก็บที่ k */

                            printf(“k - %d, k);

                            k = a + b; //ปัดเศษของผลบวกทิ้ง แล้วค่อยนำไปเก็บไว้ใน k

                            printf(“k = %d”, k);

                            c =  a + b;

                            printf(“c = %f”, c);

                            c = i  + a;

                            printf(“c = %f”, c);

                    }

                    ผลการกระทำการ

                    k = 7

                    k = 33

                    c = 33.100000

    http://elearning.narinukul.ac.th/ICT1/%E0%B8%A0%E0%B8%B2%E0%B8%A9%E0%B8%B2%E0%B8%8B%E0%B8%B5.htm

    ตัวอย่างการเขียนโปรแกรมต่างๆ
    ฟังก์ชันของภาษา c
    ในบทนี้จะอธิบายถึงฟังก์ชัน   ในภาษาซีซึ่งกล่าวถึงการทำงานของฟังชันก์   การสร้างฟังก์ชันและรูปแบบของฟังก์ชัน   การส่งค่าลักษณะต่าง ๆ และจะกล่าวถึงฟังก์ชันมาตรฐานของภาษาซีด้วย
    การเขียนโปรแกรมภาษาในภาษาซี
    การเขียนโปรแกรมในภาษาซีนั้นสามารถเขียนได้ 2 แบบ
    แบบที่ 1 เขียนแบบโครงสร้าง
                    หรือเป็นบรรทัดไปเรื่อย ๆ หรือทั้งโปรแกรมมีเพียงหนึ่งฟังก์ชันคือ ฟังชันก์ main( ) การเขียนแบบนี้มีข้อดีคือ  เหมาะสำหรับโปรแกรมสั้น ๆ แต่เมื่อนำไปใช้กับโปรแกรมที่มีขนาดยาวถ้าในโปรแกรมมีชุดคำสั่งที่ซ้ำกัน และการตรวจสอบหาข้อผิดพลาดนั้นทำได้ยาก  เพราะจะต้องรันทั้งโปรแกรม
    แบบที่ 2 เขียนแบบฟังก์ชัน
    เป็นการเขียนโปรแกรมโดยแบ่งการทำงานของโปรแกรมออกเป็นฟังก์ชันย่อย   แต่ยังต้องมีฟังก์ชัน main( ) อยู่เหมือนเดิม  แต่ฟังก์ชัน main( ) นี้จะไปเรียกฟังก์ชันอื่นขึ้นมาทำงานต่อไป   การเขียนแบบนี้มีข้อดีคือ การทำงานของโปรแกรมนั้นตรวจสอบได้ง่าย  เพราะสามารถรันเฉพาะฟังก์ชันได้   และทำให้ตัวโปรแกรมนั้นสั้นลงในกรณีที่ชุดคำสั่งที่เหมือนกัน   ซึ่งโปรแกรมเมอร์เกือบทั้งหมดนิยมเขียนในลักษณะนี้
    การเขียนโปรแกรมแบบฟังก์ชัน
    การเขียนโปรแกรมแบบฟังก์ชันมีขั้นตอนดังนี้
    1. ประกาศฟังก์ชันที่ต้องการไว้ในส่วนแรกของโปรแกรม
    2. เรียกใช้ฟังก์ชันที่ประกาศไว้
    3. กำหนดหรือสร้างรายละเอียดของฟังก์ชันนั้น

    โปรแกรม 5 – 1 แสดงขั้นตอน 3 ขั้นตอนของการสร้างฟังก์ชัน

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

    การสร้างฟังก์ชัน

    รูปที่ 5 – 2 ส่วนประกอบต่าง ๆ ของฟังก์ชัน

      

    ส่วนหัวของฟังก์ชัน  ( Function Header )ประกอบด้วย 3 ส่วนหลัก  คือ  ชนิดข้อมูลของค่าที่ส่งกลับ  (Return Type )ชื่อฟังก์ชัน ( Function name )   และรายชื่อพารามิเตอร์ซึ่งจะมีการบอกชนิดข้อมูล  เหมือนการประกาศตัวแปร  และสามารถมีหลายตัวได้โดยเครื่องหมาย , คั้นระหว่างแต่ละพารามิเตอร์
    ถ้าไม่ได้ใช้ Return type ภาษาซี จะถือว่ามีค่าที่ส่งกลับเป็นชนิดข้อมูลแบบ Integer  แล้ว ในส่วนรายละเอียดของฟังก์ชันจะต้องมีคำสั่ง Return  ด้วนในบรรทัดที่ต้องการออกจากฟังก์ชัน  ถ้าไม่ต้องการให้ฟังก์ชันนั้นมีการส่งค่ากลับ ให้ใส่ Return Type เป็น Void และไม่ต้องใส่คำสั่ง Return
    และในส่วนของรายชื่อพารามิเตอร์   ถ้าไม่ต้องการส่งค่ากลับก็ไม่ต้องใส่ก็ได้ หรือใส่เป็น Void ไว้
    ส่วนรายละเอียดของฟังก์ชัน ประกอบด้วย  การประกาศตัวแปรแบบ Local และ  ชุดคำสั่งต่าง ๆ ของฟังก์ชันนั้น   เมื่อต้องการจบฟังก์ชัน  ถ้ามีการใส่ Return Type  ไว้ก็ให้ส่งค่ากลับตามชนิดของ  Return Type  ที่ใส่ เช่น
    return 0; แต่ถ้าไม่มีการส่งค่ากลับใส่  ก็ไม่จำเป็นต้องมีคำสั่ง return  หรือให้ใส่คำสั่งดังนี้ return ;


                   

    รูปที่ 5 – 3 แสดงตัวอย่างของฟังก์ชัน

    รูปแบบของฟังก์ชัน
    รูปแบบของฟังก์ชันของภาษา ซี มีอยู่ 4 รูปแบบ
    แบบที่ 1 ฟังก์ชันแบบไม่มีการส่งค่ากลับ  และไม่มีพารามิเตอร์   เป็นฟังก์ชันที่ไม่มีการส่งค่ากลับไปให้กับฟังก์ชันที่เรียกมา  และไม่มีการส่งค่าจากฟังก์ชันที่เรียกมาให้ด้วย
    แบบที่ 2 ฟังก์ชันแบบไม่มีการส่งค่ากลับ และพารามิเตอร์  เป็นฟังก์ชันที่จะไม่มีการส่งค่ากลับไปให้ฟังก์ชันที่เรียกขึ้นมา   แต่มีการส่งค่าจากฟังก์ชันที่เรียกมาให้ด้วย
    แบบที่ 3 ฟังก์ชันแบบมีการส่งค่ากลับ  และไม่มีพารามิเตอร์  เป็นฟังก์ชันที่จะมีการส่งค่ากลับไปให้ฟังก์ชันที่เรียกมา   แต่ไม่มีการส่งค่าจากฟังก์ชันที่เรียกมาให้ด้วย
    แบบที่ 4 ฟังก์ชันแบบมีการส่งค่ากลับ  และมีพารามิเตอร์  เป็นฟังก์ชันที่จะมีการส่งค่ากลับไปให้กับฟังก์ชันที่เรียกมา  แต่มีการส่งค่าจากฟังก์ชันที่เรียกมาให้ด้วย
    โปรแกรม 5- 2 ตัวอย่างฟังก์ชันแบบไม่มีการส่งค่ากลับ   และไม่มีพารามิเตอร์
    การประกาศฟังก์ชั่น (Prototype Declarations)
    การประกาศฟังก์ชั่นนั้น  เป็นสิ่งที่จำเป็นต้องทำเสมอเมื่อจะสร้างฟังก์ชั่น  การประกาศฟังก์ชั่นนั้นจะประกาศอยู่ตรงส่วนบนสุดของโปรแกรม  หรือก่อนส่วนการประกาศตัวแปรแบบ Global ดังที่แสดงในตัวอย่างที่ 5-1 ซึ่งเมื่อสังเกตแล้วจะพบว่าการประกาศฟังก์ชั่นก็คือ  การตัดเอาเฉพาะส่วนหัวของฟังก์ชั่นไป  แล้วต่อฐานด้วยเครื่องหมาย ; นั่นเอง

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

    test(a,7);
    test(6,b);
    test(a+6,b);
    test(test(a,b),b);

      

    รูปที่ 5-4 แสดงตัวอย่างการเรียกใช้ฟังก์ชันแบบต่างๆ

    ตัวอย่างโปรแกรม
    โปรแกรม 5-6 โปรแกรมแสดงเลขหลักแรก

    ผลลัพธ์ที่ได้
    Enter an integer: 27
    Least significant digit is: 7
    โปรแกรม 5-7 โปรแกรมบวกค่าตัวเลขทั้งสองหลักแรกมาบวกกัน

     ผลลัพธ์ที่ได้
         Enter an integer: 23
         Sum of last two digits is:5
         Enter an integer: 8
         Sum of last two digits is:8

     

    โปรแกรม 5-8 โปรแกรมแสดงตัวเลขในรูปแบบ Long Integer

    ผลลัพธ์ที่ได้
                Enter a number with up to 6 digits: 123456
            The number you entered is 123,456

            Enter a number with up to 6 digits: 12
            The number you entered is 000,012
    การส่งค่าผ่านพารามิเตอร์
    ในภาษา C นั้นจะมีการส่งค่าผ่านพารามิเตอร์  หรือ  Parameter Passing ซึ่งสามารถแบ่งได้เป็น  3 ประเภทใหญ่ๆ  ดังนี้

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

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

    การส่งค่าแบบอ้างที่อยู่(Pass by Address)
    การส่งค่าแบบนี้จะใช้พอยเตอร์ซึ่งจะขอยกไปกล่าวในบทที่8

    ฟังก์ชันมาตรฐาน
    ในภาษา C ได้จัดเตรียมฟังก์ชันมาตรฐานต่างๆเอาไว้ให้ใช้มากมาย  ฟังก์ชันมาตรฐานต่างๆ จะอยู่ในStandard Library Files  ที่มีนามสกุลเป็น.h ถ้าต้องใช้ฟังก์ชันมาตรฐานเหล่านั้นจะต้องทราบก่อนว่าฟังก์ชันนั้นอยู่ใน Standard Library Files อันไหน แล้วนำเอา Standard Library Files นั้นเข้ามาโดยใช้คำสั่ง include
    ยกตัวอย่างฟังก์ชันที่ใช้บ่อยๆ คือ ฟังก์ชัน scanf() , printf() ซึ่งถ้าจะใช้ฟังก์ชันทั้ง 2 นี้จะต้องนำเข้า Standard Library Files ที่ชื่อ stdio.h ก่อนจึงจะสามารถใช้ได้

    ฟังก์ชันมาตรฐานทางคณิตศาสตร์
    ถ้าต้องการใช้ฟังก์ชันมาตรฐานทางคณิตศาสตร์จะต้องนำเข้า  Standard Library Files 2ไฟล์ คือ math.h และ stdlib.h

              abs/fabs/labs ทั้ง3ฟังก์ชัน จะส่งค่ากลับเป็นค่า Absolute ของตัวเลขที่ส่งไปให้  ค่าAbsolute คือ ค่าทางบวกของค่านั้น สำหรับ abs ต้องมีการส่งพารามิเตอร์ที่มีชนิดข้อมูลเป็นตัวเลขจำนวนเต็มหรือ Integer สำหรับ labs ต้องมีการส่งพารามิเตอร์ที่มีชนิดข้อมูลเป็นตัวเลขที่เป็นทศนิยมหรือ Float-Point การประกาศฟังก์ชันของทั้ง 3 ฟังก์ชันเป็นดังนี้
    int abs (Int number);
    long labs(long number);
    double fabs(double number);
    ตัวอย่าง
    abs(3)        ส่งค่ากลับเป็น 3
    fabs(-3.4)   ส่งค่ากลับเป็น 3.4

    ceil ฟังก์ชัน ceil หรือ ceiling เป็นฟังก์ชันที่จะหาค่าจำนวนเต็มที่มากกว่าหรือเท่ากับ ค่าที่ส่งไปให้ ตัวอย่างเช่น  หาค่า ceiling ของ 3.000001 จะเป็น 4.0 ถ้าพิจารณาแล้ว ผลของฟังก์ชัน ceil คือ ค่าตัวเลขจำนวนเต็มที่อยู่ทางด้านขวามือของค่าที่ส่งไปให้ ดังแสดงในรูปที่ 5-6

    การประกาศฟังก์ชันของ ceil จะเป็นดังนี้
    Double ceil (double number);
    ตัวอย่าง
    ceil(-1.9)              ส่งค่ากลับเป็น-1.0
    ceil(1.1)               ส่งค่ากลับเป็น  2.0

    floor ฟังก์ชัน floor เป็นฟังก์ชันที่จะหาค่าจำนวนเต็มที่น้อยกว่าหรือเท่ากับค่าที่ส่งไปให้ ตัวอย่างเช่น หาค่า floor ของ 3.99999 จะเป็น 3.0 ถ้าพิจารณาแล้ว ผลของฟังก์ชัน floor คือ ค่าตัวเลขจำนวนเต็มที่อยู่ทางด้านซ้ายมือของค่าที่ส่งไปให้  ดังแสดงในรูปที่ 4-6 โดยมีการประกาศฟังก์ชันเป็นดังนี้

                    double floor(double number);
    ตัวอย่าง
                    floor(-1.1)            ส่งค่ากลับเป็น -2.0
                    floor(1.9)             ส่งค่ากลับเป็น 1.0
    pow ฟังก์ชัน pow เป็นฟังก์ชันที่หาค่า x ยกกำลังด้วย y หรือ xy ซึ่งมีการประกาศฟังก์ชันดังนี้

                    double pow(double x,double y);
    ตัวอย่าง
                    pow(3.0,4.0)       ส่งค่ากลับเป็น 81.0
                    pow(3.4,2.3)       ส่งค่ากลับเป็น 16.687893
    sqrt ฟังก์ชัน sqrt เป็นฟังก์ชันที่หาค่ารากที่สองของค่าที่ส่งไปให้  ซึ่งมีการประกาศฟังก์ชันเป็นดังนี้ double sqrt(double number);
                    ตัวอย่าง
              sqrt(25.0)            ส่งค่ากลับเป็น 5.0

     



    อ่านทั้งหมด: 878, ความเห็นทั้งหมด: 0

    แสดงความเห็น
    ข้อความ
       
      
     
     
       
    แนบรูป *เฉพาะสมาชิกเท่านั้น
    จาก  
    พิมพ์คำว่า คนไทย ในช่องนี้ ->

    เรื่องราวอื่นๆจากบลอกเพื่อนบ้าน

    รพ.จุฬาลงกรณ์ เชิญประชาชนร่วมบำเพ็ญกุศล (ดีโพลมา2559)ร่วมกับสื่อสยามข่าวมวลชน(รายงาน)
    กำเนิดเจ้าแม่กวนอิม -ตอนที่ 25(ดีโพลมา2558)ร่วมกับสื่อสยามข่าวมวลชน(รายงาน)
    ไปเที่ยวเดอะกะตะรีสอร์ทที่ภูเก็ตมา(ดีโพลมา2557)ร่วมกับสื่อสยามข่าวมวลชน(รายงาน).
    คลิปสรุปข่าวประจำวันนี้มีหลายข่าวต่อเนื่องอัตโนมัติ (ดีโพลมา2560)
    กฎหมายค่าส่วนกลาง(ดีโพลมา2559)
    กำเนิดเจ้าแม่กวนอิม - ตอนที่ 24 (ดีโพลมา2558)
    กินอย่างไร เมื่อไตรกลีเซอไรด์ในเลือดสูง
    กินอย่างไรห่างไกลเบาหวาน
    กินอย่างไร เมื่อเป็นโรคเบาหวาน
    หางาน part time งานผ่านเน็ต รับงานทำที่บ้านได้ คลิก
    โรคความดันโลหิตสูง รักษาได้ แค่หลีกให้ไกลจากโซเดียม
    อีเมล และสมอง อัศจรรย์แห่งการเชื่อมโยง
    Japanese Language Course
    แค่หลับสนิท ก็ผอมได้ไม่น่าเชื่อ!
    อลังการอะ ศิลปะบนผนังที่ห้างรูปเกือกม้าในเนเธอร์แลนด์
    วิธีลดน้ําหนัก 5 กิโล 1 อาทิตย์ สูตรเด็ดที่สาว ๆ ต้องคิดก่อนลอง !
    คลิปสรุปข่าวประจำวันนี้มีหลายข่าวต่อเนื่องอัตโนมัติ(ดีโพลมา2556)
    สตช. เพิ่งตื่น สั่งเข้มปราบปรามแหล่งเงินกู้นอกระบบ(ดีโพลมา2555)
    กำเนิดเจ้าแม่กวนอิม - ตอนที่ 23(ดีโพลมา2554)
    30 วิธีฉลาดสุดๆ ที่ทำให้ชีวิตคุณ “ง่ายขึ้น” ไปดูว่ามีอะไรบ้าง!
    การปรับเปลี่ยนตัวเอง เพื่อเป็นคนที่มีความสุขทำอย่างสม่ำเสมอ
    งานพิเศษ งานรายได้เสริม ใช้เวลาว่างๆ 2-3 ชั่วโมง ทำงาน ที่นี่ค่ะ
    คลิปสรุปข่าวประจำวันนี้มีหลายข่าวต่อเนื่องอัตโนมัติ(ดีโพลมา2553)
    อินไซด์ตำรวจประจำวันที่18ต.ค.2557(ดีโพลมา2552)
    กำเนิดเจ้าแม่กวนอิม - ตอนที่ 22(ดีโพลมา2551)
    ตามหาญาติ (ดีโพลมา2550)
    หางานทำที่บ้าน งานทำทางเน็ต สร้างรายได้ที่บ้านค่ะ
    เลือกที่พัก รายวัน รายเดือน อย่างไรดี
    คลิปสรุปข่าวประจำวันนี้มีหลายข่าวต่อเนื่องอัตโนมัติ(ดีโพลมา2549)
    คลิปสรุปข่าวประจำวันนี้มีหลายข่าวต่อเนื่องอัตโนมัติ(ดีโพลมา2548)
    แต่งตั้งนายตำรวจราชสำนัก (ดีโพลมา2547)
    กำเนิดเจ้าแม่กวนอิม - ตอนที่ 21ขอขอบคุณที่มาของข่าว/ภาพจากผู้ที่มีชื่ออยู่ด้านล่างนี้ทุก
    หนังเรื่องผีชี่วะ ภาค4 (ดีโพลมา2545)
    หนี้เสียเกิดจากการปล่อยสินเชื่อที่ไม่มีคุณภาพ (ดีโพลมา2544)
    หางาน หางานทำที่บ้าน คีย์งานผ่านเน็ต ง่ายๆ คลิกเลย
    9 สุดยอดผัก แหล่งสารต้านอนุมูลอิสระชั้นเลิศ
    ลดความเครียดและรอบเอวด้วยอาหาร 4 ชนิด ที่คิดไม่ถึง
    เช็กสิ 14 สัญญาณที่บ่งบอกว่าคุณกำลังเครียดมากเกินไป
    คลิปสรุปข่าวประจำวันนี้มีหลายข่าวต่อเนื่องอัตโนมัติ(ดีโพลมา2541)
    "เอก" รองผบ.ตร. ตั้งกรรมการ กำกับแต่งตั้งตำรวจ ล้อมคอกร้องทุกข์(ดีโพลมา2540)
    กำเนิดเจ้าแม่กวนอิม - ตอนที่ 20(ดีโพลมา2539)
    MAiSEN รีวิว เมนู ชุดสุกี้ยากี้ คุโรบูตะ ไข่ออนเซน ร้าน ไมเซน สยามสแควร์วัน
    คลิปสรุปข่าวประจำวันนี้มีหลายข่าวต่อเนื่องอัตโนมัติ(ดีโพลมา2538)
    กฎหมายถอนฟ้อง(ดีโพลมา2537)
    กำเนิดเจ้าแม่กวนอิม - ตอนที่ 19(ดีโพลมา2536)
    “รพ.จุฬาลงกรณ์” เชิญผู้สูงวัยชาย-หญิง(ดีโพลมา2535)
    งานพิเศษ งาน part time พิมพ์ข้อมูลผ่านเว็บ หางานคลิกเลย
    International Course
    คลิปสรุปข่าวประจำวันนี้มีหลายข่าวต่อเนื่องอัตโนมัติ(ดีโพลมา2534)
    พิธีสวนสนาม นรต. วันตำรวจ (ดีโพลมา2533)

    เลือกดูบลอก Search:
    ใช้เวลาประมวลผลหน้านี้ 62.4001ms