7.1 ฟังก์ชันมาตรฐาน (standard functions)

บทที่  7
ฟังก์ชันในภาษา  C

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

7.1 ฟังก์ชันมาตรฐาน  (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)  มาใช้งานภายในโปรแกรมนี้ได้
            สำหรับฟังก์ชันมาตรฐานที่จะกล่าวถึงในหัวข้อนี้จะกล่าว เฉพาะฟังก์ชันมาตรฐานที่จำเป็น  และเรียกใช้งานบ่อย ๆ   เท่านั้น  ซึ่งมีดังต่อไปนี้
            7.1.1 ฟังก์ชันทางคณิตศาสตร์  (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  จะกลับเข้าสู่โปรแกรม

            7.1.2 ฟังก์ชันเกี่ยวกับตัวอักษร (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  จะกลับเข้าสู่โปรแกรม

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

strlen(s)                  strcmp(s1,s2)
strcpy(s)                strcat(s1,s2)

              สำหรับรายละเอียดของฟังก์ชันแต่ละฟังก์ชันได้เคยกล่าวมาแล้วในบทที่  5  เกี่ยวกับ  array  และ  string  จึงไม่ขอกล่าวซ้ำอีก
            7.1.4 ฟังก์ชันทั่วไปที่ใช้งานบ่อย ๆ 
            จะกล่าวเฉพาะฟังก์ชันที่ใช้บ่อย ๆ  เท่านั้น  ซึ่งมีฟังก์ชันดังนี้
             1) ฟังก์ชัน  clrscr( ) 
เป็นฟังก์ชันที่ใช้ในการลบข้อมูลออกจากจอภาพแบบ  text  mode 
                รูปแบบ

        clrscr(  );

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

gotoxy(x,y );

    โดยที่ 

x  คือ  ตำแหน่ง  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);

  โดยที่

x  เป็นชื่อตัวแปรที่ต้องการตรวจสอบขนาด
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  จะกลับเข้าสู่โปรแกรม