Link Banner

หน้าแรก

โปรแกรมย่อยและฟังก์ชันมาตรฐาน


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

การสร้างและใช้งานโปรแกรมย่อย

ประเภทของโปรแกรมย่อย

ประเภทของโปรแกรมย่อย (Procedure) เป็นส่วนหนึ่งของโปรแกรม มีหน้าที่เฉพาะตัวโดยแยกการทำงานออกจาก โปรแกรมอย่างอิสระ

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

Visual Basic 2008 สามารแบ่งโปรแกรมย่อยได้ 2 ประเภท คือ

Sub มาจากคำเต็มว่า ซับรูทีน (Subroutine) เป็นโปรแกรมย่อยเมื่อทำงานแล้ว จะไม่มีการส่งผลการทำงานกลับไปยังโปรแกรม ที่เรียกซับรูทีนนี้ใช้งาน

Function เป็นโปรแกรมย่อยเมื่อทำงานเสร็จแล้ว จะต้องมีการส่งผลการทำงานกลับไปยังโปรแกรมที่เรียกฟังก์ชันนี้ใช้งาน

ในที่นี้ผู้เรียกใช้ Sub หรือ Function จะเป็นตัวโปรแกรมหลัก หรือโปรแกรมย่อยอื่นๆก็ได้


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

โปรแกรมย่อยชนิด Sub

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

        

ตัวอย่างการใช้งาน Subroutine : ตัวอย่างนี้จะสร้างแอพพลิเคชันแบบระบบลงทะเบียนซึ่งจะมีการใช้งาน Subroutine ที่เราเขียนขึ้นมา

1. ออกแบบหน้าตาแอพพลิเคชัน และตั้งชื่อคอนโทรลต่างๆ ดังนี้

2. ดับเบิลคลิกที่ฟอร์มเพื่อเขียนโค้ดใน Even Load โดยจะเริ่มแนะนำให้ผู้ใช้งานทราบวิธีการทำงานโดยจะเรียก Sub ที่ชื่อว่า InformUser

3. ให้หน้าต่างโค้ดของ Sub InformUser โดยเขียนต่อท้ายไปได้เลย
4. ดับเบิลคลิกที่ปุ่ม ลงทะเบียน แล้วเขียนโค้ดเพื่อตรวจสอบความครวถ้วนถูกต้องของข้อมูลที่ป้อนเข้าไป ถ้าเรียบร้อยถือว่าลงทะเบียนได้ แต่ถ้าไม่เรียนร้อยแจ้งให่ผู้ใช้ทราบ

5 . สำหรับ Sub CheckPassword นั้นมีหลักการตรวจสอบความถูกต้องอยู่ 3 ข้อ ดังรายละเอียดที่แสดดงในโค้ดต่อไปนี้

6 . ดับเบิลคลิกปุ่ม เคลียร์ แล้วเขียนโค้ดเพื่อเคลียร์ค่าข้อมูลใน TexBox ต่างๆ ดังนี้

7 . กดปุ่ม F5 เพื่อทดสอบการทำงานของแอพพลิเคชัน ได้ผลดังนี้

โปรแกรมย่อยชนิด Function

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

ตัวอย่างการใช้งาน Function : ตัวอย่างนี้จะสร้างแอพพลิเคชันที่คำนวณผลตอบแทนจากการฝากเงินซึ่งผู้ใช้จะต้องกรอกเงินต้น อัตราดอกเบี้ย และจำนวนปีที่ฝาก

1. ออกแบบหน้าตาแอพพลิเคชัน และตั้งชื่อคอนโทรลต่างๆ ดังนี้


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

3. สำหรับฟังก์ชัน CheckInput จำทำหน้าที่ตรวจสอบว่า ข้อมูลที่ผู้ใช้งานกรอกมาเหมาะสมหรือไม่โดยต้องเป็นตัวเลขที่มากกว่า 0 ทุกตัว และถ้าเป็น ดอกเบี้ยให้มีค่าระหว่าง 0 ถึง 100 โดยฟังก์ชันนี้จะรีเทิร์นค่าเป็น True หรือ False

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

6. ทดสอบการทำงานของแอพพลิเคชัน ได้ผลดังนี้






ฟังก์ชันในภาษา  C
            สำหรับเนื้อหาในบทนี้จะกล่าวถึงฟังก์ชันในภาษา  C  โดยจะประกอบไปด้วยเนื้อหาหลัก ๆ  คือ  เรื่องที่หนึ่ง  ฟังก์ชันมาตรฐาน  เป็นฟังก์ชันที่บริษัทที่ผลิตภาษา  C  ได้เขียนขึ้นและเก็บไว้ใน  header  file  ภาษา  C  คือเก็บไว้ในแฟ้มที่มีนามสกุล  *.h  ต่าง ๆ  ส่วนเรื่องที่สอง  เป็นฟังก์ชันที่เขียนขึ้นหรือเรียกอีกอย่างว่าโปรแกรมย่อย  ที่ผู้เขียนโปรแกรมเขียนขึ้นมาใช้งานอย่างใดอย่างหนึ่งตามความต้องการของงานนั้น ๆ  โดยรายละเอียดของแต่ละฟังก์ชันมีดังต่อไปนี้
ฟังก์ชันมาตรฐาน  (standard  functions)

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

ตัวอย่างที่  7.1  แสดงตัวอย่างฟังก์ชันมาตรฐาน  เช่น  ฟังก์ชัน  pow(x,y)  คือ  ฟังก์ชันที่ใช้หาค่ายกกำลังของ  xy  โดยที่ตัวแปร  x  และตัวแปร  y  มีชนิดเป็น  double  ซึ่งฟังก์ชัน  pow(x,y)  จะถูกเก็บไว้ใน  header  file  ที่ชื่อว่า  math.h  ดังนั้นจึงต้องใช้คำสั่ง  #include<math.h>  แทรกอยู่ในส่วนตอนต้นของโปรแกรมเหนือฟังก์ชัน  main( )  จึงจะสามารถเรียกใช้ฟังก์ชัน  pow(x,y)  มาใช้งานภายในโปรแกรมนี้ได้

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

            เป็นฟังก์ชันที่ใช้สำหรับการคำนวณทางคณิตศาสตร์  และก่อนที่จะใช้ฟังก์ชันประเภทนี้  จะต้องใช้คำสั่ง   #include   <math.h>  แทรกอยู่ตอนต้นของโปรแกรม  และตัวแปรที่จะใช้ฟังก์ชันประเภทนี้จะต้องมีชนิด  (type)  เป็น  double  เนื่องจากผลลัพธ์ที่ได้จากฟังก์ชันประเภทนี้จะได้ค่าส่งกลับของข้อมูลเป็น  double  เช่นกัน

             ฟังก์ชันทางคณิตศาสตร์ที่ควรทราบ  มีดังนี้

acos(x)               asin(x)                atan(x) 
sin(x)                  cos(x)                 tan(x)
sqrt(x)                 exp(x)                pow(x,y)
log(x)                  log10(x)             ceil(x) 
floor(x)                fabs(x)              

               1) ฟังก์ชัน  acos(x)  
            เป็นฟังก์ชันที่ใช้คำนวณหาค่า  arc   cosine  ของ  x  โดยที่  x  เป็นค่ามุมในหน่วยเรเดียน  (radian)
                รูปแบบ

      acos(x);

             2) ฟังก์ชัน  asin(x)  
            เป็นฟังก์ชันที่ใช้คำนวณหาค่า  arc   sine  ของ  x  โดยที่  x  เป็นค่ามุมในหน่วยเรเดียน
                รูปแบบ

      asin(x);

            3) ฟังก์ชัน  atan(x)  
            เป็นฟังก์ชันที่ใช้คำนวณหาค่า  arc   tan  ของ  x  โดยที่  x  เป็นค่ามุมในหน่วย
เรเดียน
                 
                รูปแบบ

      atan(x);

           4) ฟังก์ชัน  sin(x)  
            เป็นฟังก์ชันที่ใช้คำนวณหาค่า  sine  ของ  x  โดยที่  x  เป็นค่ามุมในหน่วยเรเดียน
              รูปแบบ

       sin(x);

           5) ฟังก์ชัน  cos(x)  
            เป็นฟังก์ชันที่ใช้คำนวณหาค่า  cosine  ของ  x  โดยที่  x  เป็นค่ามุมในหน่วย
เรเดียน
                รูปแบบ

       cos(x);

            6) ฟังก์ชัน  tan(x) 
เป็นฟังก์ชันที่ใช้คำนวณหาค่า  tan  ของ  x  โดยที่  x  เป็นค่ามุมในหน่วยเรเดียน
                รูปแบบ

        tan(x);

            เพื่อความเข้าใจการใช้งานฟังก์ชัน  acos(x), asin(x), atan(x), sin(x), cos(x)  และ  tan(x)  มากยิ่งขึ้น  ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่  7.1  แสดงการใช้งานฟังก์ชัน  acos(x), asin(x), atan(x), sin(x), cos(x)  และ  tan(x)


/*             math1.c                 */

#include<stdio.h>                                                                              /*  บรรทัดที่  1  */
#include<math.h>                                                                              /*  บรรทัดที่  2  */
#include<conio.h>                                                                             /*  บรรทัดที่  3  */
void main(void)                                                                                    /*  บรรทัดที่  4  */
{                                                                                                       /*  บรรทัดที่  5  */
      double r, pi = 3.141592654;                                             /*  บรรทัดที่  6  */
      r = pi/180;                                                                             /*  บรรทัดที่  7  */
      clrscr();                                                                                  /*  บรรทัดที่  8  */
      printf("%f\n",asin(r));                                                            /*  บรรทัดที่  9  */
      printf("%f\n",acos(r));                                                           /*  บรรทัดที่  10  */
      printf("%f\n",atan(r));                                                            /*  บรรทัดที่  11  */
      printf("%f\n",sin(r));                                                               /*  บรรทัดที่  12  */
      printf("%f\n",cos(r));                                                             /*  บรรทัดที่  13  */
      printf("%f\n",tan(r));                                                              /*  บรรทัดที่  14  */
      printf("\nPress any key back to program ..."); /*  บรรทัดที่  15  */
      getch();                                                                                  /*  บรรทัดที่  16  */
}                                                                                                         /*  บรรทัดที่  17  */
  

 

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่  7.1  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้


บรรทัดที่  9  คำสั่ง  printf("%f\n",asin(r));  ฟังก์ชันคำนวณหาค่า  arc sin  ของตัวแปร  r โดย  r  เป็นมุมในหน่วยเรเดียน  และแสดงผลลัพธ์ที่ได้ออกจอภาพ
บรรทัดที่ 10 คำสั่ง  printf("%f\n",acos(r));    ฟังก์ชันคำนวณหาค่า  arc cosine  ของตัวแปร  r โดย  r  เป็นมุมในหน่วยเรเดียน  และแสดงผลลัพธ์ที่ได้ออกจอภาพ
บรรทัดที่  11  คำสั่ง  printf("%f\n",atan(r));  ฟังก์ชันคำนวณหาค่า  arc tan  ของตัวแปร  r โดย  r  เป็นมุมในหน่วยเรเดียน  และแสดงผลลัพธ์ที่ได้ออกจอภาพ
บรรทัดที่  12  คำสั่ง  printf("%f\n",sin(r)); ฟังก์ชันคำนวณหาค่า   sine  ของตัวแปร  r โดย  r  เป็นมุมในหน่วยเรเดียน  และแสดงผลลัพธ์ที่ได้ออกจอภาพ
บรรทัดที่  13  คำสั่ง  printf("%f\n",cos(r));  ฟังก์ชันคำนวณหาค่า   cosine  ของตัวแปร  r โดย  r  เป็นมุมในหน่วยเรเดียน  และแสดงผลลัพธ์ที่ได้ออกจอภาพ
บรรทัดที่  14  คำสั่ง  printf("%f\n",tan(r));  ฟังก์ชันคำนวณหาค่า  tan  ของตัวแปร  r โดย  r  เป็นมุมในหน่วยเรเดียน  และแสดงผลลัพธ์ที่ได้ออกจอภาพ
บรรทัดที่  15 และ 16   พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

            7) ฟังก์ชัน  sqrt(x)  
            เป็นฟังก์ชันที่ใช้หาค่ารากที่  2  (square root)  ของค่าคงที่หรือตัวแปร  x  โดยที่  x  จะต้องเป็นค่าคงที่ชนิดตัวเลขหรือตัวแปรที่มีค่าไม่ติดลบ
              รูปแบบ

        sqrt(x); 


            8) ฟังก์ชัน  exp(x)  
            เป็นฟังก์ชันที่ใช้หาค่า  ex  โดยที่  x  เป็นค่าคงที่หรือตัวแปรที่จะใช้เป็นค่ายกกำลังของ  e  โดยที่  e  มีค่าประมาณ  2.718282
                รูปแบบ

        exp(x);          


9) ฟังก์ชัน  pow(x,y)  
เป็นฟังก์ชันที่ใช้หาค่า  xy  
โดยที

  

x  เป็นค่าคงที่หรือตัวแปรที่ใช้เป็นตัวฐานซึ่งจะต้องมีค่ามากกว่าศูนย์
y  เป็นค่าคงที่หรือตัวแปรที่ใช้เป็นค่ายกกำลัง

รูปแบบ 

      pow(x, y);

            เพื่อความเข้าใจการใช้งานฟังก์ชัน  sqrt(x), exp(x)  และ  pow(x, y)  มากยิ่งขึ้นให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่  7.2  แสดงการใช้งานฟังก์ชัน  sqrt(x), exp(x)  และ  pow(x, y)

/*             math2.c   */

#include<stdio.h>                                                                              /*  บรรทัดที่  1  */
#include<math.h>                                                                              /*  บรรทัดที่  2  */
#include<conio.h>                                                                             /*  บรรทัดที่  3  */
void main(void)                                                                                    /*  บรรทัดที่  4  */
{                                                                                                         /*  บรรทัดที่  5  */
      double x = 2.5, y = 7.0, z = 21.5;                                      /*  บรรทัดที่  6  */
      clrscr( );                                                                                 /*  บรรทัดที่  7  */
      printf("%.4f\n",pow(x,y));                                                     /*  บรรทัดที่  8  */
      printf("%.4f\n",sqrt(z));                                                         /*  บรรทัดที่  9  */
      printf("%.4f\n",exp(y));                                                         /*  บรรทัดที่  10  */
      printf("\nPress any key back to program ..."); /*  บรรทัดที่  11  */
      getch();                                                                                  /*  บรรทัดที่  12  */
}                                                                                                    /*  บรรทัดที่  13  */

 ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่  7.2  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้


บรรทัดที่  8  คำสั่ง  printf("%.4f\n",pow(x,y)); ฟังก์ชันคำนวณหาค่า xy โดยที่ x เป็นค่าคงที่หรือตัวแปรที่ใช้ตัวฐานซึ่งจะต้องมีค่ามากกว่าศูนย์  และ y  เป็นค่าคงที่หรือตัวแปรที่ใช้เป็นค่ายกกำลัง  และแสดงผลที่ได้ออกจอภาพ
บรรทัดที่  9  คำสั่ง  printf("%.4f\n",sqrt(z));  ฟังก์ชันคำนวณหาค่ารากที่สอง (square root) ของค่าคงที่หรือตัวแปร  z  โดยที่  z  จะต้องเป็นค่าคงที่ชนิดตัวเลขหรือตัวแปรที่มีค่าไม่ติดลบ  และแสดงผลที่ได้ออกจอภาพ
บรรทัดที่  10  คำสั่ง  printf("%.4f\n",exp(y));  ฟังก์ชันคำนวณหาค่า  ey  โดยที่ y เป็นค่าคงที่หรือตัวแปรที่จะใช้เป็นค่ายกกำลังของ  e  โดยที่  e  มีค่าประมาณ  2.718282  และแสดงผลที่ได้ออกจอภาพ
บรรทัดที่  11 และ 12   พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

            10) ฟังก์ชัน  log(x)  
            เป็นฟังก์ชันที่ใช้หาค่า  log  ฐาน  n  (natural logarithm)  ของค่าคงที่หรือตัวแปร  x  โดยที่  x  เป็นค่าคงที่หรือตัวแปรที่มีค่าเป็นลบไม่ได้
                รูปแบบ

       log(x);

           11) ฟังก์ชัน  log10(x)  
            เป็นฟังก์ชันที่ใช้หาค่า  log  ฐาน  10  ของค่าคงที่หรือตัวแปร  x  โดยที่  x  เป็นค่าคงที่หรือตัวแปรที่มีค่าเป็นลบไม่ได้
              รูปแบบ

       log10(x);

                                                                                                                                                                                                                                                                                                                             

            เพื่อความเข้าใจการใช้งานฟังก์ชัน  log(x)  และ  log10(x)  มากยิ่งขึ้น  ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่  7.3 แสดงการใช้งานฟังก์ชัน  log(x)  และ  log10(x)

/*             math3.c                 */

#include<stdio.h>                                                                              /*  บรรทัดที่  1  */
#include<math.h>                                                                              /*  บรรทัดที่  2  */
#include<conio.h>                                                                             /*  บรรทัดที่  3  */
void main(void)                                                                                    /*  บรรทัดที่  4  */
{                                                                                                      /*  บรรทัดที่  5  */
      double m = 10.0, n = 3.0;                                                  /*  บรรทัดที่  6  */
      clrscr( );                                                                                 /*  บรรทัดที่  7  */
      printf("%.4f\n",log(n));                                                          /*  บรรทัดที่  8 */
      printf("%.4f\n",log10(m));                                                    /*  บรรทัดที่  9  */
      printf("\nPress any key back to program ..."); /*  บรรทัดที่  10  */
      getch();                                                                                  /*  บรรทัดที่  11  */
}                                                                                                    /*  บรรทัดที่  12  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่  7.3  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้


บรรทัดที่  8  คำสั่ง printf(“%.4f\n”,log(n));  ฟังก์ชันที่ใช้หาค่า log ฐาน n (natural logorithm) ของค่าคงที่หรือตัวแปร  n  โดยที่  n  เป็นค่าคงที่หรือตัวแปรที่มีค่าเป็นลบไม่ได้  และแสดงผลที่ได้ออกจอภาพ  
บรรทัดที่  9  คำสั่ง  printf("%.4f\n",log10(m));  ฟังก์ชันที่ใช้หาค่า log ฐาน 10 ของค่าคงที่หรือตัวแปร  m  โดยที่  m  เป็นค่าคงที่หรือตัวแปรที่มีค่าเป็นลบไม่ได้ และแสดงผลที่ได้ออกจอภาพ
บรรทัดที่  10 และ 11 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

            12) ฟังก์ชัน  ceil(x)  
            เป็นฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวแปร  x  ถ้า  x  เป็นตัวเลขจำนวนทศนิยม  แต่ถ้า  x  เป็นเลขจำนวนเต็มจะไม่มีการปัดเศษทศนิยม

               รูปแบบ

       ceil(x);

               13) ฟังก์ชัน  floor(x)  
            เป็นฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวแปร  x  ถ้า  x  เป็นตัวเลขจำนวนทศนิยม  แต่ถ้า  x  เป็นเลขจำนวนเต็มจะไม่มีการตัดเศษทศนิยมทิ้ง

               รูปแบบ

       floor(x);

                           เพื่อความเข้าใจการใช้งานฟังก์ชัน  ceil(x)  และ  floor(x)  มากยิ่งขึ้น  ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่  7.4  แสดงการใช้งานฟังก์ชัน  ceil(x)  และ  floor(x)

/*             math4.c                 */

#include<stdio.h>                                                                              /*  บรรทัดที่  1  */
#include<math.h>                                                                              /*  บรรทัดที่  2  */
#include<conio.h>                                                                             /*  บรรทัดที่  3  */
void main(void)                                                                                    /*  บรรทัดที่  4  */
{                                                                                                      /*  บรรทัดที่  5  */
      clrscr();                                                                                  /*  บรรทัดที่  6  */
      printf("%.4f\n", ceil(9.8765));                                              /*  บรรทัดที่  7  */
      printf("%.4f\n", ceil(-3.7654));                                            /*  บรรทัดที่  8  */
      printf("%.4f\n", ceil(80));                                                      /*  บรรทัดที่  9  */
      printf("%.4f\n", floor(7.9876));                                            /*  บรรทัดที่  10  */
      printf("%.4f\n", floor(-3.321));                                             /*  บรรทัดที่  11  */
      printf("%.4f\n", floor(180));                                                  /*  บรรทัดที่  12  */
      printf("\nPress any key back to program ..."); /*  บรรทัดที่  13  */
      getch();                                                                                  /*  บรรทัดที่  14  */
}                                                                                                    /*  บรรทัดที่  15  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่  7.4  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้


บรรทัดที่  7  คำสั่ง  printf(“%.4f\n”,ceil(9.8765));  ฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวเลข  9.8765  และแสดงผลออกที่จอภาพ
บรรทัดที่  8  คำสั่ง  printf(“%.4f\n”,ceil(-3.7654));  ฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวเลข  -3.7654  และแสดงผลออกที่จอภาพ
บรรทัดที่  9  คำสั่ง  printf(“%.4f\n”,ceil(80));  ฟังก์ชันที่ใช้ในการปัดเศษทศนิยมขึ้นของตัวเลข  80  และแสดงผลออกที่จอภาพ
บรรทัดที่  10  คำสั่ง  printf(“%.4f\n”,floor(7.9876));  ฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวเลข  7.9876  และแสดงผลออกที่จอภาพ
บรรทัดที่  11  คำสั่ง  printf(“%.4f\n”,floor(-3.321)); ฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวเลข  -3.321  และแสดงผลออกที่จอภาพ
บรรทัดที่  12 คำสั่ง  printf(“%.4f\n”,floor(180)); ฟังก์ชันที่ใช้ในการตัดเศษทศนิยมทิ้งของตัวเลข  180  และแสดงผลออกที่จอภาพ
บรรทัดที่  13  และ  14  พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

            14. ฟังก์ชัน  fabs(x)  
            เป็นฟังก์ชันที่ใช้หาค่าสัมบูรณ์  (absolute value)  ของค่าคงที่หรือตัวแปร  x  โดยที่  x  เป็นค่าคงที่หรือตัวแปรที่เก็บค่าตัวเลขจุดทศนิยมที่มีค่าบวกหรือลบก็ได้

               รูปแบบ

       fabs(x);

               เพื่อความเข้าใจการใช้งานฟังก์ชัน  fabs(x)  มากยิ่งขึ้น  ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่  7.5  แสดงการใช้งานฟังก์ชัน  fabs(x)

/*             math5.c                 */

#include<stdio.h>                                                                              /*  บรรทัดที่  1  */
#include<math.h>                                                                              /*  บรรทัดที่  2  */
#include<conio.h>                                                                             /*  บรรทัดที่  3  */
void main(void)                                                                                    /*  บรรทัดที่  4  */
{                                                                                                        /*  บรรทัดที่  5  */
      double x = 123.4567, y = -891.2345;                              /*  บรรทัดที่  6  */
      clrscr();                                                                                  /*  บรรทัดที่  7  */
      printf("Absolute value of x = %.5f\n",fabs(x)); /*  บรรทัดที่  8  */
      printf("Absolute value of y = %.5f\n",fabs(y));  /*  บรรทัดที่  9  */
      printf("\nPress any key back to program ..."); /*  บรรทัดที่  10  */
      getch();                                                                                  /*  บรรทัดที่  11  */
}                                                                                                          /*  บรรทัดที่  12  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่  7.5  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้


บรรทัดที่  8  และ  9  ใช้ฟังก์ชัน  fabs( )  หาค่าสัมบูรณ์ (absolute value) ของค่าคงที่หรือตัวแปร  x  และ  y  และแสดงผลออกที่จอภาพ  ตามลำดับ
บรรทัดที่  10  และ 11 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

 ฟังก์ชันเกี่ยวกับตัวอักษร (character  functions)

             เป็นฟังก์ชันที่ใช้กับข้อมูลที่มีชนิดเป็น  single   char  (ใช้เนื้อที่  1  byte)  เท่านั้น  และก่อนที่จะใช้ฟังก์ชันประเภทนี้จะต้องใช้คำสั่ง #include<ctype.h> แทรกอยู่ตอนต้นของโปรแกรม  จึงจะสามารถเรียกใช้ฟังก์ชันประเภทนี้ได้

                  ฟังก์ชันที่เกี่ยวกับตัวอักษรที่ควรทราบ  มีดังนี้

isalnum(ch)                  isalpha(ch)                  isdigit(ch) 
islower(ch)                   isupper(ch)                  
tolower(ch)                   toupper(ch)
isspace(ch)                  isxdigit(ch)

   โดยมีรายละเอียดของฟังก์ชันแต่ละฟังก์ชันดังต่อไปนี้

            1) ฟังก์ชัน  isalnum(ch)  
เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร  ch   เป็นตัวอักษรหรือตัวเลข  (letter   or   digit)  ถ้าข้อมูลที่เก็บไว้เป็นตัวอักษรหรือตัวเลขก็จะส่งค่ากลับที่เป็นจำนวนเต็มที่มีค่าไม่เท่ากับศูนย์มายังฟังก์ชัน  และถ้าข้อมูลที่เก็บไว้ในตัวแปร  ch  ไม่ได้เก็บตัวอักษรหรือตัวเลขก็จะส่งค่ากลับที่มีค่าเป็นศูนย์มายังฟังก์ชัน
             รูปแบบ

    isalnum(ch);

            2) ฟังก์ชัน  isalpha(ch)  
            เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร   ch  เป็นตัวอักษร  (letter)  หรือไม่  ถ้าใช่ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์   ถ้าไม่ใช่ฟังก์ชันนี้จะให้ค่าส่งกลับมาเป็นเลขศูนย์  (0)
รูปแบบ

    isalpha(ch);

            3) ฟังก์ชัน  isdigit(ch) 
            เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร  ch  เป็นตัวเลข  0  ถึง  9  หรือไม่  ถ้าใช่ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์  ถ้าไม่ใช่ฟังก์ชันนี้จะไม่มีการส่งค่ากลับ
                 รูปแบบ

     isdigit(ch);

                  เพื่อความเข้าใจการใช้งานฟังก์ชัน  isalnum(ch), isalpha(ch)  และ  isdigit(ch)  มากยิ่งขึ้น  ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่  7.6  แสดงการใช้งานฟังก์ชัน  isalnum(ch), isalpha(ch)  และ  isdigit(ch)

/*             char1.c                  */
#include<stdio.h>                                                                              /*  บรรทัดที่  1  */
#include<ctype.h>                                                                             /*  บรรทัดที่  2  */
#include<conio.h>                                                                             /*  บรรทัดที่  3  */
void main(void)                                                                                    /*  บรรทัดที่  4  */
{                                                                                                         /*  บรรทัดที่  5  */
      char  ch1 = '6', ch2 = 'K', ch3 = '*';                                 /*  บรรทัดที่  6  */
      clrscr( );                                                                                 /*  บรรทัดที่  7  */
      printf("%d\n",isalnum(ch1));                                              /*  บรรทัดที่  8  */
      printf("%d\n",isalnum(ch2));                                              /*  บรรทัดที่  9  */
      printf("%d\n",isalnum(ch3));                                              /*  บรรทัดที่  10  */
      printf("%d\n",isalpha(ch1));                                               /*  บรรทัดที่  11  */
      printf("%d\n",isalpha(ch2));                                               /*  บรรทัดที่  12  */
      printf("%d\n",isalpha(ch3));                                               /*  บรรทัดที่  13  */
      printf("%d\n",isdigit(ch1));                                                 /*  บรรทัดที่  14  */
      printf("%d\n",isdigit(ch2));                                                 /*  บรรทัดที่  15  */
      printf("%d\n",isdigit(ch3));                                                 /*  บรรทัดที่  16  */
      printf("\nPress any key back to program ..."); /*  บรรทัดที่  17  */
      getch();                                                                                  /*  บรรทัดที่  18  */
}                                                                                                      /*  บรรทัดที่  19  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่  7.6  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้


บรรทัดที่  8  ถึง  10  ใช้ฟังก์ชัน  isalnum( )  ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร  ch1, ch2 และ  ch3  ตามลำดับ  เป็นตัวอักษรหรือตัวเลข ซึ่งถ้าข้อมูลที่เก็บไว้เป็นตัวอักษรหรือตัวเลขจะส่งค่ากลับที่เป็นจำนวนเต็มที่มีค่าไม่เท่ากับศูนย์มายังฟังก์ชัน  แต่ถ้าข้อมูลในตัวแปรไม่ได้เก็บตัวอักษรหรือตัวเลขจะส่งค่าศูนย์กลับมายังฟังก์ชัน  แล้วแสดงผลที่ได้ออกมาจอภาพ
บรรทัดที่  11  ถึง  13  ใช้ฟังก์ชัน  isalpha( )  ใช้ตรวจสอบว่าข้อมูลในตัวแปร  ch1, ch2  และ  ch3  ตามลำดับ  เป็นตัวอักษรหรือไม่ ถ้าใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ ถ้าไม่ใช่ฟังก์ชันจะให้ค่ากลับเป็นศูนย์ แล้วแสดงผลที่ได้ออกจอภาพ
บรรทัดที่  14  ถึง  16  ใช้ฟังก์ชัน  isdigit( )  ใช้ตรวจสอบว่าข้อมูลที่เก็บในตัวแปร  ch1, ch2  และ  ch3 ตามลำดับ  เป็นตัวเลข  0  ถึง  9  หรือไม่  ถ้าใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์  ถ้าไม่ใช่ฟังก์ชันจะไม่มีการส่งค่ากลับ
บรรทัดที่  17  และ  18  พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

            4) ฟังก์ชัน  islower(ch)  
            เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร  ch  เป็นตัวอักษรตัวเล็กหรือไม่  ถ้าใช่ให้ส่งค่ากลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์  ถ้าไม่ใช่ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลขศูนย์  (0)
   รูปแบบ

    islower(ch);

            5) ฟังก์ชัน  isupper(ch)  
            เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลที่เก็บไว้ในตัวแปร  ch  เป็นตัวอักษรตัวใหญ่หรือไม่  ถ้าใช่ให้ส่งค่ากลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์  ถ้าไม่ใช่ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลขศูนย์  (0)
 รูปแบบ

isupper(ch);

  

            6) ฟังก์ชัน  tolower(ch)  
            เป็นฟังก์ชันที่ใช้เปลี่ยนตัวอักษรตัวใหญ่ที่เก็บไว้ในตัวแปร  ch  ให้เป็นอักษรตัวเล็ก
    รูปแบบ

    tolower(ch);

            7) ฟังก์ชัน  toupper(ch) 
            เป็นฟังก์ชันที่ใช้เปลี่ยนตัวอักษรตัวเล็กที่เก็บไว้ในตัวแปร  ch  ให้เป็นอักษรตัวใหญ่
  รูปแบบ

    toupper(ch);

            เพื่อความเข้าใจการใช้งานฟังก์ชัน  islower(ch), isupper(ch), tolower(ch)  และ  toupper(ch)  มากยิ่งขึ้น  ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่  7.7  แสดงการใช้งานฟังก์ชัน   islower(ch), isupper(ch), tolower(ch)  และ  toupper(ch)

/*             char2.c                  */

#include<stdio.h>                                                                              /*  บรรทัดที่  1  */
#include<ctype.h>                                                                             /*  บรรทัดที่  2  */
#include<conio.h>                                                                             /*  บรรทัดที่  3  */
void main(void)                                                                                    /*  บรรทัดที่  4  */
{                                                                                                         /*  บรรทัดที่  5  */
      char ch1 = 'm', ch2 = 'N';  clrscr( );                                 /*  บรรทัดที่  6  */
      printf("%d\t%d\n",islower(ch1),islower(ch2));                                /*  บรรทัดที่  7  */
      printf("%d\t%d\n",isupper(ch1),isupper(ch2));             /*  บรรทัดที่  8  */
      printf("%c\t%c\n",tolower(ch1),toupper(ch2));              /*  บรรทัดที่  9  */
      printf("\nPress any key back to program ..."); /*  บรรทัดที่  10  */
      getch();                                                                                  /*  บรรทัดที่  11  */
}                                                                                                           /*  บรรทัดที่  12  */

 

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่  7.7 
สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้

บรรทัดที่  7  ใช้ฟังก์ชัน  islower( )  ตรวจสอบตัวอักษรที่เก็บไว้ในตัวแปร  ch1  และ  ch2  เป็นตัวอักษรตัวพิมพ์เล็กหรือไม่  ถ้าใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์  ถ้าไม่ใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขศูนย์  แล้วแสดงผลออกที่จอภาพ
บรรทัดที่  8  ใช้ฟังก์ชัน  isupper( )  ตรวจสอบตัวอักษรที่เก็บไว้ในตัวแปร  ch1  และ  ch2  เป็นตัวอักษรตัวพิมพ์ใหญ่หรือไม่  ถ้าใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์  ถ้าไม่ใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขศูนย์  แล้วแสดงผลออกที่จอภาพ
บรรทัดที่  9  ใช้ฟังก์ชัน  tolower( )  ใช้เปลี่ยนตัวอักษรตัวพิมพ์ใหญ่ที่เก็บไว้ในตัวแปร  ch1  ให้เป็นตัวอักษรตัวพิมพ์เล็ก  และใช้ฟังก์ชัน  toupper( )  ใช้เปลี่ยนตัวอักษรตัวพิมพ์เล็กที่เก็บไว้ในตัวแปร  ch2  ให้เป็นตัวอักษรตัวพิมพ์ใหญ่  แล้วแสดงผลออกจอภาพ
บรรทัดที่  10  และ  11 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

            8) ฟังก์ชัน  isspace(ch)  
         
   เป็นฟังก์ชันที่ใช้ตรวจสอบว่าค่าข้อมูลที่อยู่ในตัวแปร ch  มีค่าเป็น  whitespace  หรือไม่  (whitespace)  ได้แก่  space, tab, vertical tab, formfeed, carriage return  และ  new  line  ถ้าเป็น  whitespace  เพียงแค่ตัวใดตัวหนึ่ง  ฟังก์ชันนี้จะให้ค่าส่งกลับที่เป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์ถ้าไม่ป็น  whitespace  ฟังก์ชันนี้จะให้ค่าส่งกลับเป็นเลขศูนย์  (0)

                รูปแบบ

    isspace(ch);

            9) ฟังก์ชัน  isxdigit(ch)  
          
  เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลตัวเลขที่อยู่ในตัวแปร    ch   เป็นตัวเลขฐานสิบหก  (0-9, A-F, หรือ a-f)  หรือไม่  ถ้าใช่ฟังก์ชันนี้จะมีการส่งค่ากลับตัวเลขที่ไม่เท่ากับศูนย์มายังฟังก์ชัน   ถ้าไม่ใช่ฟังก์ชันนี้จะส่งค่าเป็นตัวเลขศูนย์กลับมายังฟังก์ชัน
   รูปแบบ

    isxdigit(ch);

                                        เพื่อความเข้าใจการใช้งานฟังก์ชัน  isspace(ch)  และ  isxdigit(ch)  มากยิ่งขึ้น  ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่  7.8  แสดงการใช้งานฟังก์ชัน  isspace(ch)  และ  isxdigit(ch)

/*             char3.c                  */

#include<stdio.h>                                                                              /*  บรรทัดที่  1  */
#include<ctype.h>                                                                             /*  บรรทัดที่  2  */
#include<conio.h>                                                                             /*  บรรทัดที่  3  */
void main(void)                                                                                    /*  บรรทัดที่  4  */
{                                                                                                       /*  บรรทัดที่  5  */
      char ch1 = '\0', ch2 = '\n', ch3 = '\t', ch4 = 'J' ;             /*  บรรทัดที่  6  */
      clrscr( );                                                                                 /*  บรรทัดที่  7  */
      printf("%d\t%d\n",isspace(ch1),isspace(ch2));            /*  บรรทัดที่  8  */
      printf("%d\t%d\n",isspace(ch3),isxdigit(ch4));              /*  บรรทัดที่  9  */
      printf("\nPress any key back to program ..."); /*  บรรทัดที่  10  */
      getch();                                                                                  /*  บรรทัดที่  11  */
}                                                                                                        /*  บรรทัดที่  12  */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่  7.8  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้

บรรทัดที่  8  ใช้ฟังก์ชัน  isspace( )  ตรวจสอบว่าข้อมูลที่อยู่ในตัวแปร  ch1  และ  ch2  มีค่าเป็น  whitespace  หรือไม่  ถ้าเป็นฟังก์ชันจะให้ค่ากลับที่เป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์  ถ้าไม่ใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขศูนย์  แล้วแสดงผลที่ได้ออกจอภาพ
บรรทัดที่  9   ใช้ฟังก์ชัน  isspace( )  ตรวจสอบว่าข้อมูลที่อยู่ในตัวแปร  ch3   มีค่าเป็น  whitespace  หรือไม่  ถ้าเป็นฟังก์ชันจะให้ค่ากลับที่เป็นเลขจำนวนเต็มที่ไม่เท่ากับศูนย์  ถ้าไม่ใช่ฟังก์ชันจะให้ค่ากลับเป็นเลขศูนย์  แล้วแสดงผลที่ได้ออกจอภาพ  และใช้ฟังก์ชัน  isxdigit( )  ตรวจสอบว่าข้อมูลตัวเลขที่อยู่ในตัวแปร  ch4  ว่าเป็นตัวเลขฐานสิบหกหรือไม่  ถ้าใช่ฟังก์ชันจะส่งค่ากลับเป็นตัวเลขที่ไม่เท่ากับศูนย์  ถ้าไม่ใช่ฟังก์ชันจะส่งตัวเลขศูนย์กลับมายังฟังก์ชัน
บรรทัดที่  10  และ  11 พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

 ฟังก์ชันเกี่ยวกับสตริง  (string  functions)

            เป็นฟังก์ชันที่ใช้กับข้อมูลชนิดสตริง  (string)  โดยก่อนที่จะใช้ฟังก์ชันประเภทนี้จะต้องใช้คำสั่ง #include<string.h> แทรกอยู่ตอนต้นของโปรแกรมเสียก่อน จึงจะเรียกใช้ฟังก์ชันประเภทนี้ได้

                 ฟังก์ชันที่เกี่ยวข้องกับสตริงที่ควรทราบ  มีดังนี้ 

                            strlen(s)                  strcmp(s1,s2)

                            strcpy(s)                strcat(s1,s2)

                สำหรับรายละเอียดของฟังก์ชันแต่ละฟังก์ชันได้เคยกล่าวมาแล้วในบทที่  5  เกี่ยวกับ  array  และ  string  จึงไม่ขอกล่าวซ้ำอีก

ฟังก์ชันทั่วไปที่ใช้งานบ่อย ๆ 

             จะกล่าวเฉพาะฟังก์ชันที่ใช้บ่อย ๆ  เท่านั้น  ซึ่งมีฟังก์ชันดังนี้

             1) ฟังก์ชัน  clrscr( )  
เป็นฟังก์ชันที่ใช้ในการลบข้อมูลออกจากจอภาพแบบ  text  mode 

                รูปแบบ

        clrscr(  );

            2) ฟังก์ชัน  gotoxy(x,y)  
            เป็นฟังก์ชันที่ใช้คำสั่งให้ตัวชี้ตำแหน่ง  (cursor)  เคลื่อนที่ไปยังตำแหน่งที่ระบุไว้บนจอภาพ

                 รูปแบบ

gotoxy(x,y );

  โดยที่  

 คือ  ตำแหน่ง  column  บนจอมีค่าตั้งแต่  1  ถึง  79  ส่วน column  ที่   80  สงวนไว้
y  คือ  ตำแหน่ง  row  บนจอภาพมีค่าตั้งแต่  1  ถึง  24  ส่วน  row  ที่       25  สงวนไว้


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

             รูปแบบ

      clreol(  );

            4) ฟังก์ชัน  deline( )  
            เป็นฟังก์ชันที่ใช้ลบข้อความทั้งบรรทัดที่มีตัว  cursor  อยู่   จากนั้นก็เลื่อนข้อความในบรรทัดที่อยู่ข้างล่างขึ้นมาแทนที่

               รูปแบบ

deline(  );

               5) ฟังก์ชัน  insline( )  
            เป็นฟังก์ชันที่ใช้แทรกบรรทัดว่าง  1  บรรทัด  โดยแทรกอยู่ใต้บรรทัดที่มี  cursor  อยู่

             รูปแบบ

insline(  );

            6) ฟังก์ชัน  sizeof(x)  
            เป็นฟังก์ชันที่ใช้ตรวจสอบขนาดของตัวแปร  x  ว่ามีขนาดกี่  Byte

             รูปแบบ

sizeof(x);
หรือ sizeof(type);

โดยที่ 

 เป็นชื่อตัวแปรที่ต้องการตรวจสอบขนาด
type  เป็นชนิดของตัวแปร  เช่น  int, float, char, double  เป็นต้น

            7) ฟังก์ชัน  system( ) 
            เป็นฟังก์ชันที่ช่วยให้สามารถเรียกใช้คำสั่งที่อยู่ใน  MS-DOS  มาใช้งานได้

            รูปแบบ

      system(“dos-command”);

โดยที่ 

dos-command  คือคำสั่ง  dos  ที่ต้องการใช้  เช่น  cls, dir, date, time, etc.  เป็นต้น

            8) ฟังก์ชัน  abort( )  
            เป็นฟังก์ชันที่ใช้ยกเลิกการทำงานของโปรแกรมโดยทันที่ทันใดไม่ว่าจะทำงานเสร็จหรือไม่  และจะมีข้อความบอกว่า  “Abnormal program termination”  แสดงออกทางจอภาพด้วย

              รูปแบบ

abort(  );

               9) ฟังก์ชัน  abs(x)  
            เป็นฟังก์ชันที่ใช้ค่าสัมบูรณ์ของ  x  โดยที่  x  เป็นตัวแปรที่เก็บตัวเลขจำนวนเต็มเท่านั้น
รูปแบบ

       abs(x);

                             เช่น            int  x = -65;
                              printf(“%d”, abs(x));
                              ผลลัพธ์ที่ได้  คือค่า  65

            10) ฟังก์ชัน  labs(x)  
            เป็นฟังก์ชันที่ใช้หาค่าสมบูรณ์ของ  x  โดยที่  x  เป็นตัวแปรที่เก็บตัวเลขชนิด  long integer

                 รูปแบบ

      labs(x);

            11) ฟังก์ชัน  atoi(s) 
            เป็นฟังก์ชันที่เปลี่ยนค่า  string  ให้เป็นตัวเลขจำนวนเต็ม  (integer)  ที่สามารถนำไปคำนวณได้

            รูปแบบ

atoi(s);

ตัวอย่างที่  7.2  แสดงการใช้ฟังก์ชัน  atoi( ) 

char  numstr[20]  = “1000”;  int  d;
d = atoi(numstr);
printf (“%d”, d);
ผลลัพธ์ที่ได้คือค่าตัวเลข  1000

             12) ฟังก์ชัน atof(s)  
เป็นฟังก์ชันที่ใช้เปลี่ยนค่า  string ให้เป็นตัวเลขจำนวนทศนิยม  (floating point)  ที่สามารถนำไปคำนวณได้
รูปแบบ

atof(  );

 ตัวอย่างเช่นที่  7.3  แสดงการใช้ฟังก์ชัน  atof  

  
char  numstr[ 20 ] = “10.45” ;  float  f;
f = atof (numstr);
printf( “% .2f”, f );
 ผลลัพธ์ที่ได้คือค่าตัวเลข  10.45

             13) ฟังก์ชัน atol(s)  
            เป็นฟังก์ชันที่ใช้เปลี่ยนค่า  string  ให้เป็นตัวเลขจำนวนเต็มชนิด  long  integer  ที่สามารถนำไปใช้คำนวณได้
            รูปแบบ

      atol(s);

เพื่อความเข้าใจการใช้งานฟังก์ชัน   atoi( ),  atof( )   และ   atol( )  มากยิ่งขึ้น  ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่  7.9  แสดงการใช้งานฟังก์ชัน  atoi( ), atof( )  และ  atol( )

/*             atoifl.c                    */

#include<stdio.h>                                                                              /*  บรรทัดที่  1  */
#include<stdlib.h>                                                                             /*  บรรทัดที่  2  */
#include<conio.h>                                                                             /*  บรรทัดที่  3  */
void main(void)                                                                                    /*  บรรทัดที่  4  */
{                                                                                                        /*  บรรทัดที่  5  */
      char s1[5] = "123";                                                               /*  บรรทัดที่  6  */
      char s2[10] = "14.573";                                                       /*  บรรทัดที่  7  */
      char s3[15] = "1234567891";                                            /*  บรรทัดที่  8  */
      int as1;   float fs2;   long  ls3;                                             /*  บรรทัดที่  9  */
      clrscr( );                                                                                 /*  บรรทัดที่  10  */
      as1 = 2 * atoi(s1);                                                                /*  บรรทัดที่  11  */
      fs2 = 2 * atof(s2);                                                                 /*  บรรทัดที่  12  */
      ls3 = atol(s3);                                                                       /*  บรรทัดที่  13  */
      printf("AS1 = %d\n",as1);                                                    /*  บรรทัดที่  14  */
      printf("FS2 = %f\n",fs2);                                                       /*  บรรทัดที่  15  */
      printf("LS3 = %ld\n",ls3);                                                    /*  บรรทัดที่  16  */
      printf("\nPress any key back to program ..."); /*  บรรทัดที่  17  */
      getch();                                                                                  /*  บรรทัดที่  18  */
}                                                                                                       /*  บรรทัดที่  19  */

 

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม 
            จากโปรแกรมตัวอย่างที่  7.9  สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ  ได้ดังนี้

บรรทัดที่  11  ใช้ฟังก์ชัน  atoi( )  เปลี่ยนค่าสตริง  s1  ให้เป็นตัวเลขจำนวนเต็มที่สามารถนำไปคำนวณได้  ซึ่งในคำสั่งนี้จะใช้คูณกับเลข  2  เก็บไว้ที่ตัวแปร  as1
บรรทัดที่  12  ใช้ฟังก์ชัน  atof( )  เปลี่ยนค่าสตริง  s2  ให้เป็นตัวเลขทศนิยมที่สามารถนำไปคำนวณได้  ซึ่งในคำสั่งนี้จะใช้คูณกับเลข  2  เก็บไว้ที่ตัวแปร  fs2
บรรทัดที่  13  ใช้ฟังก์ชัน  atol( )  เปลี่ยนค่าสตริง  s3  ให้เป็นตัวเลขจำนวนเต็มชนิด  long  integer เก็บไว้ที่ตัวแปร  ls3
บรรทัดที่  14  ถึง  16  แสดงค่าของตัวแปร  as1,  fs2  และ  as3  ตามลำดับ แสดงผลที่ได้ออกจอภาพ
บรรทัดที่  17 และ  18  พิมพ์ข้อความให้กดคีย์ใด ๆ เพื่อกลับสู่โปรแกรม  และหยุดรอรับค่าใด ๆ  เช่น  กด  enter  จะกลับเข้าสู่โปรแกรม

Embed gadget