การเขียนโปรแกรมภาษา C เบื้องต้น (Introduction to C Programming)

ต้องเข้าใจโครงสร้าง (Structure) ของภาษา C

ภาษาซี ประกอบไปด้วยฟังก์ชัน 2 ประเภท คือ

1.ฟังก์ชันหลัก (Main Function) 1 ฟังก์ชัน
2.ฟังก์ชันย่อย (Sub Function) ตั้งแต่ 1 ฟังก์ชันขึ้นไป
ภายในของฟังก์ชัน ประกอบไปด้วย 2 ส่วน คือ
1.ส่วนที่เป็นการประกาศ (Declaration Part) ค่าต่างๆ ได้แก่ การประกาศตัวแปร การประกาศค่าคงที่ การกำหนดประเภทของข้อมูล เป็นต้น
2.ส่วนที่เกี่ยวข้องกับคำสั่งการใช้งาน เช่น คำสั่งในการกำหนดค่าคงที่ คำสั่งในการแสดงผล คำสั่งในการรับข้อมูล คำสั่งเงื่่อนไข และคำสั่งที่ใช้วนรอบในการทำงาน
………ต้องเข้าใจรู้แบบคำสั่ง และวิธีการใช้คำสั่งที่ถูกต้อง………

คำสั่งเบื้องต้นของภาษา C
1. คำสั่ง scanf() เป็นฟังก์ชันที่รับค่าจากอุปกรณ์นำเข้ามาตรฐาน และนำค่าที่ได้เก็บไว้ในตัวแปรในโปรแกรม รูปแบบคำสั่ง

   เมื่อโปรแกรมทำงานถึงฟังก์ชันนี้จะหยุดเพื่อให้ป้อนข้อมูล โดยข้อมูลที่ป้อนจะแสดงบนจอภาพ เมื่อป้อนข้อมูลเสร็จกด Enter ข้อมูลทั้งหมดจะเก็บในตัวแปร var ชนิดของข้อมูลที่กำหนดให้กับตัวแปร var จะถูกกำหนดโดยตัวกำหนดชนิดข้อมูลซึ่งระบุในส่วนของ format code ตัวกำหนดชนิดข้อมูลของฟังก์ชัน scanf() จะเหมือนกับของฟังก์ชันprintf() ฟังก์ชัน scanf() จะทำให้เคอร์เซอร์ ขึ้นบรรทัดใหม่หลังจากกด Enter
ตัวอย่าง
#include “stdio.h”
#include “conio.h”
void main()
{
int a,b,c;
clrscr();
printf(“Enter three integer numbers : “);
scanf(“%d%d%d”,&a,&b,&c);
printf(“a = %d b = %d c = %d \n”,a,b,c);
}
เป็นการป้อนเลขจำนวนเต็ม 3 ตัวให้กับตัวแปร a,b และ c ในการป้อนตัวเลขให้เว้น ช่องว่างระหว่างตัวเลขแต่ละชุดซึ่ง scanf() จะข้อมช่องว่างไปจนกระทั่งพบตัวเลขจึงจะอ่านข้อมูลอีกครั้ง
    2. ฟังก์ชั่น printf()
เป็นฟังก์ชันใช้ พิมค่าข้อมูลไปยังหน้าจอคอมพิวเตอร์

    control string อาจจะเป็นตัวอักษร ข้อความหรือตัวกำหนดชนิดข้อมูล (specifier) ซึ่งใช้กำหนดชนิดข้อมูลที่จะพิมพ์ ตัวกำหนดชนิดข้อมูล
ตัวกำหนดชนิดข้อมูล
%c แทนตัวอักษร
%d แทนเลขจำนวนเต็ม
%e แทนเลขในรูปเอกซ์โพเนนเชียล (exponential form)
%f แทนเลขทศนิยม
%0 แทนเลขฐานแปด
%s แทนสตริงก์
%u แทนเลขจำนวนเต็มไม่คิดเครื่องหมาย
%x แทนเลขฐานสิบหก
%p แทนข้อมูลแบบพอยน์เตอร์ (pointer)
%% แทนเครื่องหมาย %
     สามารถดัดแปลงเพื่อใช้เป็นตัวกำหนดชนิดข้อมูลอื่นๆได้โดย โมดิฟายเออร์ (modifier) l,h และL โมดิฟายเออร์ l จะสามารถใช้กับตัวกำหนดชนิดข้อมูล %d, %o , %u และ %x เพื่อใช้กับข้อมูลชนิดยาวเช่น %ld หมายถึงข้อมูลชนิดเลขจำนวนเต็มยาวโมดิฟายเออร์ h จะใช้ในลักษณะเดียวกันกับข้อมูลชนิดสั้น เช่น %hd หมายถึง ข้อมูลชนิดเลขจำนวนเต็มสั้นสำหรับข้อมูลชนิดทศนิยมจะมีโมดิฟายเออร์ l และ L โดย l จะหมายถึงข้อมูลชนิดเลขจำนวนจริงละเอียด 2 เท่า ส่วน L จะหมายถึงข้อมูลชนิดเลขจำนวนจริงรายละเอียด 2 เท่า เช่น %lf หมายถึงข้อมูลชนิดเลขจำนวนจริงละเอียด 2 เท่า
ตัวอย่าง
#include
#include void main(void)
{
int n;clrscr();
n=100;printf(“Number = %d”,n);
getch();
}

   3. ฟังก์ชัน getchar() ฟังก์ชัน getchar() ใช้สำหรับป้อนตัวอักษรผ่านทางแป้นพิมพ์โดยจะรับตัวอักษรเพียง 1 ตัวเท่านั้น และแสดงตัวอักษรบนจอภาพ รูปแบบคำสั่ง

   เมื่อโปรแกรมทำงานถึงคำสั่งนี้จะหยุดเพื่อให้ป้อนตัว อักษร 1 ตัว หลังจากนั้นกด Enter ตัวอักษรที่ป้อนจะถูกเก็บไว้ในตัวแปร ch ซึ่งเป็นชนิดตัวอักษรและเคอร์เซอร์จะขึ้นบรรทัดใหม่ ฟังก์ชัน getchar() กำหนดในไฟล์ stdio.h เช่นเดียวกับฟังก์ชัน scanf() ตัวอย่าง
#include void
main()
{
char ch;
printf(“Type one character “);
ch = getchar();
printf(“The character you type is %c \n”,ch);
printf(“The character you typed is “);
putchar(ch);
}
การใช้ฟังก์ชัน putchar() แทน printf() จะพิมพ์ตัวอักษร 1 ตัว และเคอร์เซอร์จะไม่ขึ้นบรรทัดใหม่
4. คำสั่ง getche(); และ getch();คำสั่ง getche(); จะรับตัวอักษร 1 ตัวที่ป้อนทางแป้นพิมพ์
รูปแบบคำสั่ง getche();

   ความหมาย ch หมายถึง ตัวแปรชนิดตัวอักษร
แสดงตัวอักษรบนจอภาพ เมื่อป้อนข้อมูลเสร็จไม่ต้องกด Enter และเคอร์เซอร์จะไม่ขึ้นบรรทัดใหม่ ฟังก์ชัน getch() จะคล้ายกับฟังก์ชัน getche() ต่างกันตรงที่จะไม่แสดงตัวอักษรขณะป้อนข้อมูล ฟังก์ชัน getche() และ getch() กำหนดในไฟล์ conio.h ดังนั้นจะต้องระบุไฟล์ดังกล่าวในโปรแกรม
ตัวอย่าง คำสั่ง getche();
#include “stdio.h”
#include “conio.h”
void main(void)
{
char answer;
clrscr();
printf(“Enter A Character : “);
answer=getche();
printf(“\n”);
printf(“A Character is : %c\n”,answer);
getch();
}

คำสั่งgetch(); คือฟังก์ชันที่ใช้สำหรับรับข้อมูลชนิดตัวอักษร ผ่านแป้นพิมพ์ 1 ตัวอักษร

รูปแบบคำสั่ง getch();

จะไม่แสดงตัวอักษรบนจอภาพ เมื่อป้อนตัวอักษรเสร็จแล้ว ไม่ต้องกด Enter และเคอร์เซอร์จะไม่ขึ้นบรรทัดใหม่ และเป็นฟังก์ชันที่กำหนดอยู่ในไฟล์ conio.h รูปแบบคำสั่ง ความหมาย
ตัวอย่าง คำสั่ง getch();
#include
#include
void main(void)
{
char answer;
clrscr();
printf(“Enter A Character : “);
answer=getch();
printf(“\n”);
printf(“A Character is : “);
putchar(answer);
getch();
}
5. ฟังก์ชัน gets() ฟังก์ชัน gets() ใช้สำหรับข้อมูลชนิดสตริงก์หรือข้อความซึ่งป้อนทางแป้นพิมพ์ รูปแบบคำสั่ง

เมื่อโปรแกรมทำงานถึงคำสั่งนี้จะหยุดเพื่อให้ป้อนข้อความ เมื่อป้อนเสร็จแล้วกด Enter ข้อความ ทั้งหมดจะถูกเก็บไว้ในอาร์เรย์สตริงก์ str โดย carriage return (จากการกด Enter) จะแทนด้วยสตริงก์ศูนย์ ฟังก์ชัน gets() จะทำให้เคอร์เซอร์ขึ้นบรรทัดใหม่ หลังจากกด Enter กำหนดในไฟล์ stdio.h
ตัวอย่าง
#include”stdio.h”
main()
{
char message[50];
printf(“ Enter a message(less than 49 characters)\n”);
gets(message);printf(“ The message you entered is %s\n”,message);
}

ฟังก์ชันสตริง

สตริง (string) หรืออะเรย์ตัวอักษร คือ ข้อมูลที่ประกอบไปด้วยตัวอักษรที่มีการเรียงต่อเนื่องกันไป โดยมีจุดสิ้นสุดของข้อมูลสตริงที่ตัวอักษร NULL character เขียนด้วย ‘’

ในภาษาซีรูปแบบข้อมูลประเภทสตริงไม่มีการกำหนดไว้ การประกาศตัวแปรแบบสตริงทำได้ 2 วิธี คือ ในรูปของอะเรย์ กับในรูปของพอยน์เตอร์

ตัวอย่างการประกาศตัวแปรสตริง

char p[9] = “ I think !” ;
ฟังก์ชันมาตรฐานที่เกี่ยวกับสตริงที่ภาษาซีเตรียมไว้ให้เรียกใช้ ดังนี้

l gets( ) เป็นฟังก์ชันใช้รับค่าสตริง

l puts( ) เป็นฟังก์ชันที่ใช้แสดงผลสตริง

l strcat( ) เป็นฟังก์ชันที่ใช้ต่อสตริง 2 ตัวเข้าด้วยกัน

l strcmp( ) เป็นฟังก์ชันที่ใช้เปรียบเทียบสตริง 2 ตัว

l strcpy( ) เป็นฟังก์ชันที่ใช้ก๊อปปี้สตริง

l strlen( ) เป็นฟังก์ชันที่ใช้เพื่อหาความยาวของสตริง
   ฟังก์ชัน ภาษา c
    ในการทำงานบางอย่างจำเป็นต้องใช้คำสั่งมากกว่า 1 คำสั่งเพื่อทำงานนั้นให้สำเร็จ ซึ่งคำสั่งที่เขียนรวมกันไว้ใช้งานจะเรียกว่าฟังก์ชัน (Function)
    ฟังก์ชัน (Function) คือ การเขียนคำสั่งรวมกันไว้เป็นกลุ่มของคำสั่งเพื่อทำงานให้สำเร็จ โดยกลุ่มของคำสั่งที่เราเขียนจะอยู่ภายในเครื่องหมาย { } เพื่อบอกขอบเขต และมีการตั้งชื่อให้กับกลุ่มคำสั่งนั้น เพื่อความสะดวกในการเรียกใช้งาน
ข้อดีของการสร้างฟังก์ชันขึ้น มาใช้งาน คือ ถ้าเราต้องการทำงานที่ซ้ำซ้อน หรือทำงานใดซ้ำกันหลายครั้ง เช่น หากต้องการหาพื้นที่ของรูปสี่เหลี่ยมทั้งหมด 10 รูป เราต้องเขียนคำสั่งหาพื้นที่ทั้งหมด 10 ครั้ง ดังนั้นหากเราสร้างฟังก์ชันหาพื้นที่รูปสามเหลี่ยมก็จะสามารถเรียกใช้ ฟังก์ชันดังกล่าวเมื่อใดก็ได้
ฟังก์ชันมาตรฐานหรือไลบราลีฟังก์ชัน

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

lไลบราลีฟังก์ชันภาษา C จะเก็บอยู่ในไฟล์นามสกุล .h หรือที่เรียกว่า header file ยกตัวอย่างเช่น ฟังก์ชันเกี่ยวกับการคำนวณจะเก็บอยู่ในไฟล์ชื่อ math.h หรือฟังก์ชันเกี่ยวกับการจัดการข้อความอยู่ในไฟล์ชื่อ string.h เป็นต้น

1. ฟังก์ชันมาตรฐานหรือไลบราลีฟังก์ชัน

lในการเรียกใช้งานฟังก์ชันต้องเขียนรูปแบบการใช้คำสั่ง คือ

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

     1 ฟังก์ชันมาตรฐาน (standard functions)
เป็นฟังก์ชันที่บริษัทที่ผลิตภาษา C ได้เขียนขึ้นและเก็บไว้ใน header file ภาษา C คือเก็บไว้ในแฟ้มที่มีนามสกุล *.h ต่าง ๆ เมื่อต้องการใช้ฟังก์ชันใด จะต้องรู้ว่าฟังก์ชันนั้นอยู่ใน header file ใดจากนั้นจึงค่อยใช้คำสั่ง #include<header file.h> เข้ามาในส่วนตอนต้นของโปรแกรม จึงจะสามารถใช้ฟังก์ชันที่ต้องการได้ ซึ่งฟังก์ชันมาตรฐานเป็นฟังก์ชันที่บริษัทผู้ผลิต C   compiler เขียนขึ้นเพื่อให้ผู้ใช้นำไปช่วยในการเขียนโปรแกรมทำให้การเขียนโปรแกรม สะดวกและง่ายขึ้น บางครั้งเราอาจจะเรียกฟังก์ชันมาตรฐานว่า ”ไลบรารีฟังก์ชัน” (library functions)
         ตัวอย่างที่  1  แสดงตัวอย่างฟังก์ชันมาตรฐาน เช่น ฟังก์ชัน pow(x,y) คือ ฟังก์ชันที่ใช้หาค่ายกกำลังของ xy โดยที่ตัวแปร x และตัวแปร y มีชนิดเป็น double ซึ่งฟังก์ชัน pow(x,y) จะถูกเก็บไว้ใน header file ที่ชื่อว่า math.h ดังนั้นจึงต้องใช้คำสั่ง #include<math.h> แทรกอยู่ในส่วนตอนต้นของโปรแกรมเหนือฟังก์ชัน main( ) จึงจะสามารถเรียกใช้ฟังก์ชัน pow(x,y) มาใช้งานภายในโปรแกรมนี้ได้
สำหรับฟังก์ชันมาตรฐานที่จะกล่าวถึงในหัวข้อนี้จะกล่าว เฉพาะฟังก์ชันมาตรฐานที่จำเป็น และเรียกใช้งานบ่อย ๆ   เท่านั้น ซึ่งมีดังต่อไปนี้
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) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้
โปรแกรมตัวอย่างที่  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) มากยิ่งขึ้นให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้
โปรแกรมตัวอย่างที่  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) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้
โปรแกรมตัวอย่างที่  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) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้
โปรแกรมตัวอย่างที่  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) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้
โปรแกรมตัวอย่างที่  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 จะกลับเข้าสู่โปรแกรม
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) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้
โปรแกรมตัวอย่างที่ 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  แสดงการใช้งานฟังก์ชัน   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) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้
โปรแกรมตัวอย่างที่  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 = ”, 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 จึงไม่ขอกล่าวซ้ำอีก
     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( );
ตัวอย่างเช่นที่ 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( ) มากยิ่งขึ้น ให้ศึกษาโปรแกรมตัวอย่างต่อไปนี้

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

เริ่มต้นกับภาษา c

1. บทนำเกี่ยวกับภาษาซีที่นำมาใช้ในหลักสูตรการเขียนโปรแกรม

       จากหลักสูตรการเขียนโปรแกรม 1  ผู้สอนจะต้อง เลือกใช้ภาษาใดภาษาหนึ่งในการเรียนเขียนโปรแกรมภาคปฏิบัติ เพื่อให้นักเรียนได้มีความเข้าใจมากยิ่งขึ้นนอกเหนือจากการเรียนทฤษฎีในห้อง เรียน   สามารถนำทฤษฎีการเขียนโปรแกรมไปประยุกต์ใช้และปฏิบัติได้จริงจนเกิด ผลงานหรือโครงงานเขียนโปรแกรมคอมพิวเตอร์  ดังนั้นผู้สอนจึงเลือกภาษาซีมา ใช้ในการเรียนการสอน  ด้วยเหตุผลหลักๆ ดังนี้    (ดูหลักสูตรด้านคอมพิวเตอร์ในประเทศไทยที่เว็บไซ ด์ www.comsci.info )
1. ภาษาซี  เป็นภาษาคอมพิวเตอร์ระดับสูง  เหมาะสำหรับการเรียนรู้เบื้องต้น ฝึกคิดวิเคราะห์ แก้ปัญหาอย่างเป็นระบบ
2. * ภาษาซี  มีการจัดอันดับความนิยมในการใช้ภาษาคอมพิวเตอร์(อดีต -2550) พบว่า ภาษาซี เป็นภาษาอันดับ 2-3 ของโลก
( จัดอันดับดังนี้ 1. Java    2. C++    3. C     4. PHP    5. Perl     6.Python    7. C#    8. JavaScript   9. VB     10. Delphi
อ้างอิงจาก   http://www.jroller.com/page/matsh?entry=java_history_was_made_today  )
3.  ภาษาซี  เป็นพื้นฐานในการเรียนต่อระดับสูงต่างๆ   เช่น Java, Visual Basic , Flash animation (script) , Authorware ฯลฯ
4.  ภาษาซี  มักใช้แก้ปัญหาเชิงคณิตศาสตร์  วิทยาศาสตร์ (ฟิสิกส์ เคมี ชีววิทยา)  ที่ซับซ้อนได้ดี รวมทั้งสาขาอื่นๆ ด้วย
5.  ในปีการศึกษา 2551  พบว่าสาขาวิทยาการคอมพิวเตอร์ วิศวกรรมคอมพิวเตอร์ นำภาษาซี หรือ Java มาใช้ในการเรียน…
6.  บริษัท Microsoft นำภาษาซีมาใช้ในการเริ่มต้นสร้างระบบปฏิบัติการ Windows  ซึ่งให้มูลค่าหลายพันล้านบาท
7.  ภาษาซี   ได้รับความนิยมแพร่หลายไปทั่วโลกมาแล้ว 23 ปี  ตั้งแต่ปี ค.ศ. 1985    และประโยชน์เหตุผลอื่นๆ  อีกมากมาย

1.1  การคอมไพล์และรันโปรแกรม
-  ภาษาซีเป็นภาษาโปรแกรมระดับสูง  ใช้สำหรับเขียนโปรแกรมประยุกต์ ต่างๆ  สร้างและพัฒนาระบบปฏิบัติการ  มีความสามารถที่เด่นกว่าภาษา คอมพิวเตอร์อื่นๆ คือ  เน้นควบคุมฮาร์ดแวร์ (Hardware) ซึ่งการใช้คำสั่งต้องใช้มาตรฐานของ ANSI  C
- การคอมไพล์และรันโปรแกรมภาษาซีมีขั้นตอนการดำเนินการของโปรแกรมแปลภาษาซีดังนี้
Editor  –>  Preprocessor  –>  Compiler  –>  Linker  –>  Loader
-  Source code หรือ รหัสต้นฉบับ คือ  ข้อความที่เขียนขึ้นโดยใช้ภาษาคอมพิวเตอร์
-  Object code คือ  รหัสเครื่องประกอบด้วยตัวเลข 0 และ 1 ที่ถูกสร้างขึ้นจากโปรแกรมรหัสต้นฉบับ
-  Compiler   คือ  ดำเนินกระบวนการแปลง Source code ให้เป็น  Object code

1.2  โครงสร้างพื้นฐานของโปรแกรมภาษาซี

//   ==========   ส่วนที่ 1  ส่วนหัวของฟังก์ชัน  =========================
#include <stdio.h>               //  คือ    การเรียกอ่านแฟ้มส่วนหัว (header file) เพื่อให้ถูกประมวลผล -
#include <conio.h>             //            ร่วมกับโปรแกรมแปลภาษาซี   เช่น เรียกอ่าน file ชื่อ stdio.h  -
//            ซึ่งภายในจะบรรจุคำสั่งที่ใช้ในภาษาซี เช่น printf() , scanf()  เป็นต้น
void main( )                          //   คือ ฟังก์ชันหลักที่มีค่าว่าง หรือ ไม่มีการส่งค่าข้อมูลไปและไม่รับค่ากลับมา
{                                              //   คือจุดเริ่มต้นของฟังก์ชัน     (ในทางอัลกอริทึ่ม คือ  เริ่มต้นการทำงาน)

//   ==========  ส่วนที่ 2   ส่วนการประกาศตัวแปร  =========================
int  number  ;                     //   คือ ส่วนประกาศตัวแปรชนิดต่างๆ  เพื่อเก็บข้อมูลระหว่างการประมวลผล  -
//         เช่น   int  number;   คือ การประกาศตัวแปร number ให้เป็นชนิดตัวเลขจำนวนเต็ม

//   ==========   ส่วนที่ 3  ส่วนคำสั่งต่างๆ   =========================
printf(“Display”);                // คือ ส่วนของคำสั่งต่างๆ  เช่น printf คือ คำสั่งแสดงข้อมูล  เป็นต้น
clrscr();                                 //   คือ คำสั่งล้างจอภาพ  (Clear  Screen)  ต้องใช้ header file  ชื่อ   conio.h
}                                              //   คือจุดสิ้นสุดของฟังก์ชัน       (ในทางอัลกอริทึ่ม คือ  จบการทำงาน)
จุดประสงค์ที่  9.  มีความรู้และสามารถเขียนโปรแกรมโดยใช้คำสั่งรับข้อมูลและแสดงผลลัพธ์ข้อมูล  ( 5 คะแนน)

สรุปหลักเนื้อหาบางส่วนของบทที่ 1

1.3 ทฤษฎีการแสดงผลลัพธ์ของภาษาซีเบื้องต้น (ดูหลักการเพิ่มเติมของ Computer Science ที่เว็บไซด์ www.comsci.info )
* ฟังก์ชัน printf( ) เป็นฟังก์ชันที่ใช้ในการแสดงผลลัพธ์ออกทางจอภาพ ซึ่งจะต้องมี argument อยู่ด้วยเสมอ

* รูปแบบการใช้  คือ               printf ( “argument” ,  list ) ;                     (อาจจะไม่มี list ก็ได้)

argument  คือ  ข้อความ  หรือรหัสรูปแบบข้อมูล (format code)  หรือ รหัสควบคุมการพิมพ์ข้อมูล
(control code)  ซึ่งในหนังสือแบบเรียน สสวท. จะเรียกว่า อักขระหลีก      โดยสามารถใช้ร่วมกันได้ภายในเครื่องหมาย “   ”  (double quote) โดยที่ข้อความและรูปแบบของข้อมูลจะถูกพิมพ์ออกมาทางจอภาพ    ซึ่ง รหัสพื้นฐานต่างๆ ที่ควรรู้  มีดังนี้

รหัสรูปแบบข้อมูล (format code)	ความหมาย (ใช้กับข้อมูลชนิด… )	รหัสควบคุมหรืออักขระหลีก (control or escape code)	ความหมาย
%d	ตัวเลขจำนวนเต็ม (int)	\n	ขึ้นบรรทัดใหม่
%c	อักขระตัวเดียว (char)	\t	เว้นช่องว่าง 6 อักขระ
%f	เลขทศนิยม (float)	\b	ลบทีละ 1 อักขระ
%s	ข้อความ (char var[] )	\’ หรือ \”	แสดงอักขระ ‘ หรือ ”

list คือ ค่าคงที่ หรือ ตัวแปร หรือนิพจน์ก็ได้ ถ้ามีมากกว่า 1 ค่าให้ใช้เครื่อง หมาย , (comma) คั่นระหว่างค่าแต่ละค่า ซึ่งฟังก์ชัน printf( ) อาจจะไม่มีส่วน list ก็ได้ เช่น printf(“M. %d/%d num = %d” , id1, id2, num);

สรุปหลักเนื้อหาบางส่วนของบทที่ 2

2.1 ทฤษฎีการรับข้อมูลของภาษาซีเบื้องต้น (ดูหลักการเพิ่มเติมของ Computer Science ที่เว็บไซด์ www.comsci.info )
* ฟังก์ชัน scanf( ) เป็นฟังก์ชันที่ใช้ในการรับข้อมูลจากคีย์บอร์ดเข้าไปเก็บไว้ในตัวแปรที่กำหนดไว้

รูปแบบการใช้เบื้องต้น  คือ                scanf ( “format code”  ,  &variable ) ;

format  code   เช่น   %d   %c  %f  %s  เป็นต้น   สำหรับคำอธิบายให้ดูคำสั่ง printf
variable  คือ   ชื่อตัวแปรที่ใช้เก็บข้อมูล  โดยจะต้องใช้เครื่องหมาย & (ampersand)  นำหน้าชื่อตัวแปร
เช่น      scanf(“%d”, &decimal);    เป็นต้น

จุดประสงค์ที่  11    มีความรู้เกี่ยวกับคำสั่งควบคุมการทำงานของโปรแกรมเบื้องต้น

สรุปเนื้อหาหลักในหนังสือเรียนภาษาซี บทที่ 3 โครงสร้างควบคุม

                ตามข้อกำหนดมาตรฐานของสถาบัน  ANSI (American  National Standards Institute)  กำหนดให้ภาษา C มีคำสั่งควบคุมการทำงานของโปรแกรม   ซึ่งมี อยู่  3  กลุ่มคำสั่งดังนี้


     คำสั่งกลุ่มที่ 1  คำสั่งวนลูปหรือทำงานซ้ำ
คำสั่งวนลูป (Loop)  เป็นคำสั่งที่สามารถควบคุมโปรแกรมให้ทำงานเป็นจำนวน รอบตามที่เรากำหนดไว้  หรือทำงานจนกว่าเงื่อนไขที่กำหนดไว้เป็นเท็จ   จึงจะ ออกจากคำสั่งวนลูปได้

คำสั่งและความหมายของคำสั่ง	ตัวอย่าง Source code	ผลลัพธ์เมื่อแสดงบนจอภาพ
3.1 for เป็นคำสั่งที่สั่งให้โปรแกรมมีการทำงานซ้ำๆ วน loop จนกว่าเงื่อนไขที่กำหนดไว้เป็นเท็จ	for (number = 1; number <= 4 ; number++)printf(“%d ”, number );	1 2 3 4
3.2 while เป็นคำสั่งที่มีลักษณะการทำงานคล้ายกับคำสั่ง for แต่ต้องมีเงื่อนไขที่เป็นเท็จจึงจะออกจาก loop	int n = 1;while ( n < 4 ) { n = n + 1 ; printf(“%d ”, n); }	1 2 3
3.3 do while เป็นคำสั่งที่มีลักษณะการทำงานคล้ายกับคำสั่ง while แต่จะทดสอบเงื่อนไขหลังจากที่ได้ทำงานตามคำสั่งภายใน loop ไปแล้ว 1 รอบ	int n = 1;do { n = n + 1 ; printf(“%d ”, n); } while ( n < 4 );	1 2 3
3.4 break เป็นคำสั่งที่สั่งให้ออกจากคำสั่งfor หรือ while หรือ do while หรือ คำสั่งswitch	for (num = 1; num <= 10 ; num++){ printf(“%d ”, num ); if( num == 5) break; }	1 2 3 4 5
3.5 continue เป็นคำสั่งที่สั่งให้กลับไปทำงานที่คำสั่งแรกของลูปคำสั่ง for หรือwhile หรือ do while ทำให้มีการทำงานในรอบต่อไป	for (num = 1; num <= 10 ; num++){ printf(“%d ”, num ); if( num == 5) { num = num+2; continue; } }	1 2 3 4 5 8 9 10

   คำสั่งกลุ่มที่ 2  คำสั่งทดสอบเงื่อนไขเพื่อการตัดสินใจ (decision statements)
คำสั่งทดสอบเงื่อนไขเพื่อการตัดสินใจ  เป็นคำสั่งที่มีการทดสอบเงื่อนไขก่อนที่จะทำงานตามคำสั่ง
ที่กำหนดไว้  ซึ่งมีรายละเอียดแต่ละคำสั่งดังนี้

คำสั่งและความหมายของคำสั่ง	ตัวอย่าง Source code	ผลลัพธ์
3.6 if เป็นคำสั่งที่ใช้ทดสอบ เงื่อนไข โดยมีการตัดสินใจแบบ 1 ทางเลือกถ้าเงื่อนไขเป็นจริงให้ทำตามคำ สั่งที่อยู่ภายใน if ถ้าเป็นเท็จให้ทำคำสั่งถัดไป	if (num == 9){ printf(“Yes = 9”); }	input number = 9 :Yes = 9
3.7 if else คำสั่งที่ใช้ทดสอบเงื่อนไข โดยมีการตัดสินใจแบบ 2 ทางเลือก	if (num == 9) { printf(“Yes = 9”); }else { printf(“Not 9”); }	input number = 7 : Not 9input number = 9 : Yes= 9
3.8 if else if หรือ หรือ nested if หรือ ifเชิงซ้อนคือ คำสั่งที่ใช้ทดสอบเงื่อนไข โดยมีการตัดสินใจที่ซับซ้อนมากกว่า 2 ทางเลือกขึ้นไป	if (num == 9) { printf(“Yes = 9”); }else if (num == 8) { printf(“Yes = 8”); } else { printf(“Not 9 and Not 8”); }	input number = 8 : Yes = 8input number = 9 : Yes= 9 input number = 7 : Not 9 and Not 8
3.9 switch คำสั่งที่ใช้ทดสอบ เงื่อนไขคล้ายๆกับคำสั่ง if else if และสำหรับตัดสินใจมากกว่า 2 ทางเลือกขึ้นไป แต่มีรูปแบบการใช้คำสั่ง ง่ายกว่าและสดวกในการแก้คำสั่งเมื่อมีข้อผิดพลาดเกิดขึ้น 3.9.1 case คือ คำสั่งที่ใช้ร่วมกับคำสั่งswitch เพื่อใช้ตรวจสอบเงื่อนไข 3.9.2 default คำสั่งที่ใช้ร่วมกับคำสั่งswitch ใช้ในกรณีที่นิพจน์หรือค่าคงที่ไม่ตรงกับเงื่อนไขใดๆ เลย	printf(“Enter Grade :\n”);scanf(“%c”, &grade); switch ( grade ) { case ‘a’ : num = 4; break; case ‘b’ : num = 3; break; case ‘c’ : num = 2; break; case ‘d’ : num = 1; break; default : num = 0; } printf(“Number = %d \n\n”, num);	Enter Grade : bNumber = 3 Enter Grade : a Number = 4 Enter Grade : z Number = 0

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

กฎในการเขียนภาษา C

1. คำสั่งในภาษา C ต้องเขียนด้วยตัวพิมพ์เล็ก
2. ทุกประโยคเมื่อจบประโยคแล้วต้องใช้เครื่องหมาย “;” แสดงการจบประโยค ยกเว้นฟังก์ชันที่ตามด้วย ( ) ไม่ต้องปิดท้ายด้วย “;”
3. ในหนึ่งโปรแกรมจะมีกี่ฟังก์ชันก็ได้แต่จะต้องมีฟังก์ชันที่ชื่อ main เสมอ
4. การใส่หมายเหตุ (Comment) เพื่อใช้เป็นส่วนที่อธิบายโปรแกรมสามารถกระทำได้ 2 รูปแบบ คือ
4.1 /* และ */ ใช้สำหรับข้อความที่ยาวกว่า 1 บรรทัด โดยโปรแกรมจะถือว่าข้อความที่ตามหลัง /*จะเป็นหมายเหตุจนกว่าจะพบเครื่องหมาย */ จึงจะแสดงว่าจบหมายเหตุแล้ว
5. // เหมาะสำหรับข้อความสั้นๆ 1 บรรทัด โดยถ้าบรรทัดใดขึ้นต้นด้วย // บรรทัดนั้นจะถือว่าเป็น หมายเหตุ
ชุดอักขระภาษา C
ภาษา C ใช้ตัวอักษรได้ทั้งเล็กและใหญ่ ตัวเลข 0-9 และตัวอักขระพิเศษในการสร้างองค์ประกอบพื้นฐานของโปแกรม อักขระพิเศษดังกล่าวมีดังนี้

นอกจากนี้ภาษา C ทุกรุ่นยังยอมให้มีการใช้อักขระอื่นๆ เช่น @ และ $ .ในส่วนที่เป็นสตริงและคำอธิบาย
กฎการตั้งชื่อ
การตั้งชื่อตัวแปรใดๆ ในโปรแกรมจะประกอบด้วยตัวอักษรหรือตัวเลขก็ได้ แต่อักขระตัวแรกจะต้องเป็นตัวอักษรเสมอ การตั้งชื่อตัวแปรสามารถกำหนดเป็นตัวอักษรเล็กหรือใหญ่ก็ได้ แต่ตัวอักษรเล็กและใหญ่ในคำๆ เดียวกันจะมีความหมายต่างกัน เราสามรถใช้ขีดล่าง ( _ )มาตั้งชื่อก็ได้และสามารถกำหนดให้เป็นอักขระตัวแรกของชื่อก็ได้ ตัวอย่างการตั้งชื่อ เช่น

X	y12	sum_1	_temp
name	area	tax_rate	TABLE

*** การตั้งชื่อไม่สามารถตั้งชื่อเหมือนกับคำสงวนได้และไม่สามารถเว้นช่องว่างระหว่างชื่อได้ ***
ตัวอย่างการตั้งชื่อที่ผิด

4ht	ไม่ได้เพราะ	อักขระตัวแรกเป็นตัวเลข
“x”	ไม่ได้เพราะ	ใช้อักขระไม่ถูกต้อง (“)
order-no	ไม่ได้เพราะ	ใช้อักขระไม่ถูกต้อง (-)
error flag	ไม่ได้เพราะ	ใช้อักขระไม่ถูกต้อง (blank)

ลำดับหลีก (escape sequences)
เป็นตัวอักษรที่ไม่สามารถพิมพ์ได้ เช่น ( “ ) ,( ‘ ) หรือ ( \ ) ถ้าต้องการพิมพ์ออกมาเราจะต้องใช้ \ แล้วตามด้วยอักขระที่ต้องการ มีลำดับหลีกที่ใช้ทั่วไป ดังนี้

อักขระ	escape sequences	ค่า ASCII
bell (กระดิ่ง )	\a	007
backspace	\b	008
แท็บตามแนวนอน	\t	009
ขึ้นบรรทัดใหม	\n	010
แท็บตามแนวตั้ง	\v	011
ขึ้นหน้าใหม่	\f	012
ปัดแคร่	\r	013
อัญประกาศ	\”	034
อะโพสโตรฟิ	\’	039
เครื่องหมายคำถาม	\?	063
แบ็กสแลช	\\	092
นัล		000

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

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

คำสั่งในการแสดงผลออกทางหน้าจอ	คำสั่งในการรับข้อมูลจากคีย์บอร์ด
1. คำสั่ง printf()	1. คำสั่ง scanf()
2. คำสั่ง putchar()	2. คำสั่ง getchar() และ getch()
3. คำสั่ง puts()	3. คำสั่ง gets()

แสดงผลออกทางหน้าจอ
การแสดงผลข้อมูลออกทางหน้าจอสามารถทำได้ง่าย โดยเรียกใช้คำสั่งหรือฟังก์ชันมาตรฐานที่ภาษาซีเตรียมไว้ให้ใช้
คำสั่ง printf()
คำสั่ง printf ถือว่าเป็นคำสั่งพื้นฐานที่สุดในการแสดงผลข้อมูลทุกชนิดออกทางหน้าจอ ไม่ว่าจะเป็นจำนวนเต็ม( int ) , ทศนิยม ( float ) , ข้อความ ( string ) หรืออักขระ นอกจากนี้คำสั่งยังมีความยืดหยุ่นสูง โดยเราสามาถกำหนดหรือจัดรูปแบบการแสดงผลให้มีระเบียบหรือเหมาะสมตามความต้อง การได้อีกด้วย รูปแบบการเรียกใช้คำสั่ง printf แสดงได้ดังนี้

printf(“ format ” , variable);

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

รหัสควบคุมรูปแบบการแสดงผลค่าของตัวแปรออกทางหน้าจอ แสดงได้ดังนี้

รหัสควบคุมรูปแบบ	การนำไปใช้งาน
%d	สำหรับแสดงผลค่าของตัวแปรชนิดจำนวนเต็ม ( int, short, unsigned short, long, unsigned long)
%u	สำหรับแสดงผลตัวเลขจำนวนเต็มบวก ( unsigned short, unsigned long )
%o	สำหรับแสดงผลออกมาในรูปแบบของเลขฐานแปด
%x	สำหรับแสดงผลออกมาในรูปแบบของเลขฐานสิบหก
%f	สำหรับแสดงผลค่าของตัวแปรชนิดจำนวนทศนิยม ( float, double, long double )
%e	สำหรับแสดงผลตัวเลขทศนิยมออกมาในรูปแบบของ ( E หรือ e ) ยกกำลัง ( float, double, long double )
%c	สำหรับแสดงผลอักขระ 1 ตัว ( char )
%s	สำหรับแสดงผลข้อความ ( string หรืออักขระมากกว่า 1 ตัว)
%p	สำหรับแสดงผลตัวชี้ตำแหน่ง ( pointer )

ตัวอย่างการใช้คำสั่ง printf แสดงผลข้อความธรรมดาออกทางหน้าจอ

ส่วนตัวอย่างการใช้คำสั่ง printf แสดงผลจากค่าของตัวแปรหรือนิพจน์การคำนวณออกทางหน้าจอ แสดงได้ดังนี้
โดยกำหนดให้

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

อักขระควบคุมการแสดงผล	ความหมาย
\n	ขึ้นบรรทัดใหม่
\t	เว้นช่องว่างเป็นระยะ 1 แท็บ (6 ตัวอักษร)
\r	กำหนดให้เคอร์เซอร์ไปอยู่ต้นบรรทัด
\f	เว้นช่องว่างเป็นระยะ 1 หน้าจอ
\b	ลบอักขระสุดท้ายออก 1 ตัว

การนำอักขระควบคุมการแสดงผลมาใช้ เราต้องเขียนอักขระควบคุมการแสดงผลไว้ภายในเครื่องหมาย “ ” ดังแสดงตัวอย่างต่อไปนี้

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

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

วิธีกำหนดขนาดพื้นที่การแสดงผล ให้ใส่ตัวเลขขนาดของพื้นที่ที่ต้องการไว้หลังเครื่องหมาย % ในรหัสควบคุมรูปแบบ ดังแสดงตัวอย่างต่อไปนี้

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

ควบคุมตำแหน่งตัวเลขหลังจุดทศนิยม
นอกจากนี้ในการแสดงผลตัวเลขหลังจุดทศนิยม ตามปกติถ้าไม่ได้กำหนดค่าใด ๆ เพิ่มเติม เมื่อใช้รหัสควบคุมรูปแบบ %f โปรแกรมจะแสดงตัวเลขทศนิยมทั้งหมด 6 ตำแหน่ง ในกรณีที่เราต้องการตัดให้แสดงตัวเลขหลังจุดทศนิยมเท่าที่จำเป็น (เช่น 2 หรือ 3 ตำแหน่ง) ก็สามารถกำหนดค่าเพิ่มไปกับรหัสควบคุมรูปแบบได้ ดังต่อไปนี้

% . nf

n : จำนวนตัวเลขหลังจุดทศนิยมที่ต้องการให้แสดงผล

ตัวอย่างการแสดงผลจำนวนทศนิยม โดยที่มีการกำหนดตำแหน่งทศนิยม แสดงได้ดังนี้

คำสั่ง putchar()
ในการแสดงผลตัวอักษรหรืออักขระ ( char ) ออกทางหน้าจอ นอกจากใช้คำสั่ง printf พร้อมกับกำหนดรหัสควบคุมรูปแบบ %c แล้ว เราสามารถเรียกใช้คำสั่งสำหรับแสดงตัวอักษรหรืออักขระโดยเฉพาะได้อีกด้วย โดยคำสั่งนั้นคือ คำสั่ง putchar() ซึ่งมีรูปแบบการเรียกใช้คำสั่ง ดังแสดงต่อไปนี้

putchar(ch);

ch : ตัวอักษรหรืออักขระเขียนอยู่ภายในเครื่องหมาย ‘c’ หรือตัวแปรชนิด char

ตัวอย่างการใช้คำสั่ง putchar() ในการแสดงผลอักขระออกทางหน้าจอ แสดงได้ดังนี้

คำสั่ง puts()
เป็นคำสั่งสำหรับแสดงผลข้อความออกทางหน้าจอ มีรูปแบบการใช้คำสั่งดังนี้

puts(str);

str : ข้อความซึ่งเขียนอยู่ภายในเครื่องหมาย “ ” หรือตัวแปรที่เก็บข้อมูลชนิดข้อความ

ตัวอย่างการใช้งานคำสั่ง puts() ในการแสดงข้อความออกทางหน้าจอ แสดงได้ดังนี้

รับข้อมูลจากคีย์บอร์ด
การทำงานของโปรแกรมส่วนใหญ่มักจะเป็นการเชื่อมโยงกับผู้ใช้แบบ 2 ทิศทาง นั่นก็คือ ทั้งภาคของแสดงผลการทำงานออกทางหน้าจอ และภาคของการรับข้อมูลจากผู้ใช้เข้ามาทางคีย์บอร์ด เพื่อร่วมในการประมวลผลของโปรแกรม ซึ่งในภาคของการรับข้อมูลจากผู้ใช้ ภาษาซีกำหนดคำสั่งและฟังก์ชันมาตรฐานเอาไว้ให้เรียกใช้แล้ว เช่นเดียวกับภาคของการแสดงผล รายละเอียดของคำสั่งเหล่านี้ได้แก่
คำสั่ง scanf()
ในภาษาซี การรับข้อมูลจากคีย์บอร์ดสามารถทำได้โดยการเรียกใช้ฟังก์ชัน scanf() ซึ่งเป็นฟังก์ชันมาตรฐานสำหรับรับข้อมูลจากคีย์บอร์ด โดยสามารถรับข้อมูลได้ทุกประเภท ไม่ว่าจะเป็นจำนวนเต็ม ( int ) , ทศนิยม ( float ) ,อักขระ ( char ) หรือข้อความก็ตาม รูปแบบการเรียกใช้คำสั่ง scanf() คล้ายกับการเรียกใช้คำสั่ง printf() ดังแสดงต่อไปนี้

scanf(“format” , &variable) ;

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

ตัวอย่างการใช้งานคำสั่ง scanf() เพื่อรับข้อมูลจากคีย์บอร์ด แสดงได้ดังนี้

คำสั่ง getchar() และ getch()
ทั้ง 2 คำสั่งนี้ใช้รับข้อมูลประเภทอักขระ( char ) โดยมีรูปแบบการเรียกใช้คำสั่งดังนี้

ch = getchar();
ch = getch();

ch : ตัวแปรชนิด char เพื่อใช้เก็บค่าของอักขระหรือตัวอักษรที่รับเข้ามา

ถึงแม้ว่าทั้งคำสั่ง getchar() และ getch() จะใช้สำหรับรับข้อมูลชนิดอักขระเหมือนกัน แต่ทั้ง 2 คำสั่งนี้มีความแตกต่างกันอยู่ตรงที่ คำสั่ง getchar() เมื่อป้อนอักขระเข้ามาแล้ว ต้องกดปุ่ม <Enter> โปรแกรมจึงจะกลับไปทำงานต่อได้ และตัวอักขระที่เราป้อนจะแสดงขึ้นมาให้เห็นบนหน้าจอด้วย ส่วนคำสั่ง getch() ไม่ต้องกดปุ่ม <Enter> เพียงแค่เราป้อนอักขระเข้ามา 1 ตัว โปรแกรมจะกลับไปทำงานต่อทันที และตัวอักขระที่เราป้อนจะไม่แสดงขึ้นมาให้เห็น

ตัวอย่างการเรียกใช้คำสั่ง getchar() รับตัวอักษรเข้ามาจากคีย์บอร์ด แสดงได้ดังนี้

ผลการทำงานของโปรแกรมสังเกตได้ว่า เราต้องกดปุ่ม <Enter> หลังจากที่ป้อนตัวอักษรแล้ว นอกจากนี้ตัวอักษรที่ป้อนจะแสดงขึ้นมาบนหน้าจอด้วย
จากโปรแกรมเดิม เมื่อเปลี่ยนจากคำสั่ง getchar() เป็น getch()

ผลลัพธ์จากการทำงานแสดงได้ดังนี้

จะสังเกตได้ว่า เมื่อใช้คำสั่ง getch() เราไม่ต้องกดปุ่ม <Enter> ตามหลังการป้อนตัวอักษร และจะไม่เห็นตัวอักษรที่เราป้อนแสดงขึ้นมาบนหน้าจอ
คำสั่ง gets()
นอกจากคำสั่งในการรับข้อมูลชนิดอักขระหรือตัวอักษรแล้ว การรับข้อความจากคีย์บอร์ดก็มีคำสั่งให้เรียกใช้เช่นกัน คือ คำสั่ง gets() ซึ่งมีรูปแบบการเรียกใช้ดังต่อไปนี้

gets(str);

str : ตัวแปรสำหรับเก็บข้อความที่รับเข้ามาจากคีย์บอร์ด ซึ่งจะต้องสร้างเตรียมไว้ก่อนที่จะเรียกใช้คำสั่ง gets()

ตัวอย่างการเรียกใช้คำสั่ง gets() รับข้อความมาจากคีย์บอร์ด แสดงไดังนี้

การเขียนโปรแกรมภาษา C

พื้นฐานโปรแกรมภาษา C

ฝึกฝนและพัฒนาการเขียนโปรแกรมภาษา C Introduction to C Programming การ พัฒนาโปรแกรมคอมพิวเตอร์ บางคนก็ว่ายาก บางคนก็ว่าเป็นเรื่องสนุก หลายคนบอกว่า ขอเป็นแค่ผู้ใช้สนุกที่สุด แต่จะมีซักกี่คนที่จะมีใจรักที่จะก้าวไปบนถนนแห่งการพัฒนาฝีมือและฝึกฝนการ เขียนโปรแกรมด้วยตัวเอง เพื่อให้มีผู้ที่สนใจนำไปใช้งาน และเพิ่มประสิทธิ์ภาพในการทำงาน และ ความสะดวกสบายๆ ต่างๆมากขึ้น ว่าไปแล้วนักโปรแกรมเมอร์เหล่านี้ ก็ไม่แตกต่างจากผู้ที่ปิดทองหลังพระมากนัก เพราะหลายๆ โปรแกรมที่มีให้ใช้งานกันในปัจจุบัน จะมีใครทราบบ้างไหมว่า ผู้เขียนโปรแกรมเหล่านั้นมีใครกันบ้าง ดังนั้น ผู้ที่คิดจะก้าวมาเป็นนักพัฒนาโปรแกรมมืออาชีพ คงต้องอาศัยใจรักที่จะอยากจะพัฒนา และฝึกฝนฝืมือในการเป็นโปรแกมเมอร์มืออาชีพมาเป็นอันดับหนึ่ง สำหรับบทความนี้จะเริ่มต้นด้วยการสอนให้เข้าใจในหลักการพื้นฐานของการการ พัฒนาโปรแกรมในภาษา C ความรู้และความเข้าใจที่จำเป็นต่อการเป็นโปรแกรมเมอร์มืออาชีพในอนาคต เราลองเริ่มมาเรียนรู้กันอย่างคร่าวๆ กันเลยล่ะกัน โดยผู้เขียนจะอธิบายเป็นตอนๆ ทั้งหมด 8 ตอนด้วยกันได้แก่ 1. พื้นฐานโปรแกรมภาษา C (Introduction to C Programming) 2. การเขียนโปรแกรมทางเลือก (Selection Structures) 3. การเขียนโปรแกรมแบบ วนซ้ำ (Repetition & Loop) 4. ฟังก์ชัน และการเขียนโปรแกรมแยกเป็นโมดูล (Functions & Modular Programming) 5. ตารางอาเรย์ (Arrays) 6. ตัวแปรพอยเตอร์ (Pointers) 7. ตัวแปรสตริง (String) 8. โครงสร้างสตักเจอร์ (Structure) 1. พื้นฐานโปรแกรมภาษา C (Introduction to C Programming)ก่อน อื่นของแนะนำพื้นฐานเกี่ยวกับคอมพิวเตอร์กันซักนิด ก่อนที่จะเริ่มเรียนรู้ภาษา C กัน หน่วยสำคัญที่สุดของคอมพิวเตอร์ก็คือ หน่วยประมวลผลหรือที่เรียกกันว่า CPU โดยปกติ CPU จะมีภาษาของตัวเองที่เรียกว่า ภาษาเครื่อง (Machine Language) ซึ่งจะเป็นภาษาที่ประกอบไปด้วยเลขฐานสองมากมาย ดังนั้นการที่จะเขียนโปรแกรมควบคุมการทำงานของคอมพิวเตอร์ โดยใช้ภาษาเครื่องโดยตรงนั้นจึงทำได้ยาก จึงได้มีการพัฒนาตัวแปรภาษาเครื่องที่เรียกว่า โปรแกรมภาษาระดับสูงขึ้นมา หรือที่เรียกว่า High Level Languages โดยภาษาในระดับสูงเหล่านี้ จะมีลักษณะรูปแบบการเขียน (Syntax) ที่ทำให้เข้าใจได้ง่ายต่อการสื่อสารกับผู้พัฒนา และถูกออกแบบมาให้ง่ายต่อการใช้งาน และจะเปลี่ยนคำสั่งจากผู้ใช้งาน ไปเป็นเป็นภาษาเครื่อง เพื่อที่จะควบคุมการทำงานของคอมพิวเตอร์ต่อไป ตัวอย่างของโปรแกรมภาษาระดับสูง ได้แก่ COBOL ใช้กันมากสำหรับโปรแกรมทางด้านธุรกิจ, Fortran ใช้กันมากสำหรับการพัฒนาโปรแกรมด้านวิทยาศาสตร์และวิศวกรรมศาสตร์ เพราะง่ายต่อการคำนวณ, Pascal มีใช้กันทั่วไป แต่เน้นสำหรับการพัฒนาเครื่องมือสำหรับการเรียนการสอน, C & C++ ใช้ทั่วไป ปัจจุบันมีผู้เลือกที่จะใช้กันอย่างแพร่หลาย, PROLOG เน้นหนักไปทางด้านงานประเภท AI และ JAVA ใช้ได้ทั่วไป ปัจจุบันเริ่มมีผู้หันมาสนใจกันมากและเพิ่มขึ้นอย่างรวดเร็ว คราวนี้เราลองมาเตรียมตัวกันซักนิก ก่อนที่จะลงมือพัฒนาโปรแกรมคอมพิวเตอร์ ขั้นแรก เราต้องศึกษารูปแบบความต้องการของโปรแกรมที่จะพัฒนา จากนั้นก็วิเคราะห์ถึงปัญหาตลอดจนวิธีการแก้ปัญหา จากนั้นจึงนำเอาความคิดในการแก้ปัญหาอย่างเป็นขั้นตอน ไปเขียนในรูปแบบของโปรแกรมภาษาในระดับสูง ซึ่งจะอยู่ในรูปแบบของ Source Program หรือ Source Code จากนั้นเราก็จะใช้ Complier ของภาษาที่เราเลือก มาทำการ Compile Source code หรือกล่าวง่ายๆ คือแปลง Source code ของเราให้เป็นภาษาเครื่องนั่นเอง ซึ่งในขั้นตอนนี้ ผลที่ได้ เราจะเรียกว่า Object code จากนั้น Complier ก็จะทำการ Link หรือเชื่อม Object code เข้ากับฟังก์ชันการทำงานใน Libraries ต่างๆ ที่จำเป็นต่อการใช้งาน แล้วนำไปไว้ในหน่วยความจำ แล้วเราก็จะสามารถ Run เพื่อดูผลของการทำงานโปรแกรมได้ หากโปรแกรมมีข้อผิดพลาด เราก็จะทำการแก้ หรือที่เรียกกันในภาษาคอมพิวเตอร์ว่า การ Debug นั่นเอง ภาษา C เป็นโปรแกรมภาษาระดับสูง ถูกพัฒนาขึ้นในปี 1972 ที่ AT&T Bell Lab เราสามารถใช้ภาษา C มาเขียนเป็นคำสั่งต่างๆ ที่คอมพิวเตอร์สามารถเข้าใจได้ และกลุ่มของคำสั่งเหล่านี้ เราก็เรียกกันว่า อัลกอริธึม ได้มีผู้ให้คำจำกัดความของคำว่า อัลกอริธึม ว่าเป็น “A precise description of a step-by-step process that is guaranteed to terminate after a finite number of steps with a correct answer for every particular instance of an algorithmic problem that may occur.” สำหรับ Compiler ภาษา C ที่มีในปัจจุบัน มี 2 ค่ายใหญ่ๆ ที่มีผู้คนสนใจใช้กันมากได้แก่ Microsoft และ Borland การใช้งาน Compiler ทั้งสองตัวนี้ สามารถเรียนรู้ได้ไม่ยากนัก เราจึงจะมาเริ่มต้นที่การเขียนโปรแกรมในภาษา C กันเลย เราลองมาเริ่มจากตัวอย่างการเขียน ภาษา C แบบ ง่ายๆ กันก่อนกับโปรแกรม Hello World #include main() { printf(“Hello World!!!!! “); } บรรทัดแรก #include เป็นการบอกว่าให้ทำการรวม Header file ที่ชื่อว่า stdio.h (.h = header) ซึ่งเป็น header ที่เกี่ยวข้องกับการรับและให้ข้อมูล (Standard Input Output) นอกจาก stdio.h แล้ว ก็ยังมี Header อื่นๆ ที่ผู้พัฒนาสามารถที่จะเรียกใช้งาน Function ที่จำเป็นจาก Header นั้นๆ ได้ อาทิเช่น[[5519]]รู้จัก Header File กันไปล่ะ คราวนี้ เราลองมาดูบรรทัดถัดไปกัน ก็คือ ฟังก์ชัน main() จะเป็นจุดเริ่มต้นของโปรแกรม และโปรแกรมทุกโปรแกรมในภาษา C จะต้องมี Function main() นี้ โดยส่วนมาก เราจะใช้ Function main() ในการกำหนดค่าเริ่มต้นต่างๆ ของโปรแกรม จากนั้นจึงเข้าสู่ Function ต่างๆ ที่ผู้พัฒนา ได้กำหนดขึ้นไว้ บรรทัดถัดมาจะเป็นเครื่องหมาย { ซึ่งเป็นเครื่องหมายบ่งบอกขอบเขตของ Function โดยขอบเขตของฟังก์ชัน จะเปิดและปิดโดยใช้เครื่องหมายเปิด { และเครื่องหมายปิด } ตามลำดับ ภายใน Function main() จะมีคำสั่ง (Statement) printf(“Hello World!!!!! “); ซึ่ง printf เป็น Function ในภาษา C ทำหน้าที่ให้โปรแกรม ทำการแสดงผลออกทางหน้าจอว่า Hello World!!!!! และทุกครั้ง ผู้พัฒนาจะต้องทำการจบคำสั่งหรือ Statement ด้วยเครื่องหมาย semi-colon ; ดังนั้นรูปแบบของการเขียนโปรแกรม จึงเขียนออกมาในรูปแบบดังนี้ // ข้อความที่อยู่ข้างหลังเครื่องหมาย // จะเป็นคำอธิบายโปรแกรม #include void main() { constant declarations; // การกำหนดค่าคงที่ต่างๆ variable declarations; // การกำหนดตัวแปรต่างๆ executable statements; // คำสั่งการทำงานของโปรแกรม } การอ่านข้อมูลและการแสดงผล (Input & Output) รูป แบบการใช้งานฟังก์ชัน printf จะทำการพิมพ์ในรูปแบบที่ เริ่มต้นด้วย Format ที่ต้องการจะพิมพ์ และตามด้วยตัวแปรที่ต้องการพิมพ์ ดังนี้ printf( const char *format [, argument]… ); สำหรับการนำข้อมูลเข้าก็เช่นกัน จะใช้ฟังก์ชัน scanf ซึ่งจะเป็นฟังก์ชันสำหรับอ่านข้อมูลจากคีย์บอร์ด และจะนำข้อมูลที่ User ทำการพิมพ์ไปเก็บไว้ใน argument โดยแต่ละ argument จะต้องเป็นตัวแปรที่เรียกว่า pointer (รายละเอียดจะได้กล่าวต่อไป) และมีชนิดที่ตัวแปรที่สัมพันธ์กับที่ได้กำหนดไว้ใน Format รูปแบบการใช้งานของฟังก์ชัน scanf สามารถเขียนได้ดังนี้ scanf( const char *format [,argument]… );หน้าที่ 2 – ตัวแปร (Variables)
ตัวแปร (Variables) ตัวแปรจะเป็นชื่อที่ใช้ในการบอกจำนวนหรือปริมาณ ซึ่งสามารถที่จะทำการเปลี่ยนแปลงจำนวนได้ด้วยโปรแกรมคอมพิวเตอร์ การตั้งชื่อตัวแปร จะต้องตั้งชื่อให้แตกต่างไปจากชื่อของตัวแปรอื่นๆ ยกตัวอย่างชื่อของตัวแปร ได้แก่ x, y, peter, num_of_points และ streetnum เป็นต้น โดยปกติการเขียนโปรแกรมที่ดี ควรจะตั้งชื่อตัวแปรให้สอดคล้องกับการทำงานหรือหน้าที่ของตัวแปรนั้นๆ เพราะเมื่อถึงเวลาต้องมาทำการปรับปรุงแก้ไขโปรแกรม จะสามารถทำได้โดยไม่ยากนัก ในภาษา C หรือ C++ ได้มีกฏในการตั้งชื่อตัวแปรที่สามารถใช้งานได้ดังนี้ – ชื่อตัวแปรจะต้องขึ้นต้นด้วยตัวอักษร – ชื่อตัวแปรจะประกอบไปด้วย ตัวอักษร ตัวแลข และ _ ได้เท่านั้น – ชื่อตัวแปรจะต้องไม่ใช่ชื่อ reserved word (ชื่อที่มีการจองไว้แล้ว) ตัวอย่างของชื่อตัวแปรที่สามารถนำมาใช้ตั้งชื่อได้ ได้แก่ length, days_in_year, DataSet1, Profit95, Pressure, first_one และตัวอย่างของชื่อ ที่ไม่สามารถนำมาใช้เป็นชื่อตัวแปรได้ ยกตัวอย่างเช่น day-in-year, 1data, int, first.val เป็นต้น reserved word (ชื่อที่มีการจองไว้แล้ว) Reserved words หรือตัวแปรที่ได้จองไว้แล้วนั้น จะประกอบไปด้วยตัวอักษรตัวเล็กทั้งหมด และจะมีความสำคัญสำหรับภาษา C++ และจะไม่นำมาใช้ด้วยวัตถุประสงค์อื่นๆ ตัวอย่างของ Reserved words ได้แก่ and, bool, break, case, catch, char, class, continue, default, delete, do, double, if , else, enum, export, extern เป็นต้น นอกจากนี้ในภาษา C หรือ C++ ชื่อตัวแปร ที่ประกอบไปด้วยอักษรเล็ก หรือใหญ่ ก็มีความแตกต่างกัน หรือที่เรียกว่า Case sensitive ยกตัวอย่างเช่น ‘X’ และ ‘x’ เป็นตัวแปรต่างกัน ‘peter’ และ ‘Peter’ เป็นตัวแปรต่างกัน ‘bookno1’ และ ‘bookNo1’ เป็นตัวแปรต่างกัน ‘XTREME’ และ ‘xtreme’ เป็นตัวแปรต่างกัน ‘X1’ และ ‘x1’ เป็นตัวแปรต่างกัน ‘int’ และ ‘Int’ เป็นตัวแปรต่างกัน การกำหนดชนิดของตัวแปร (Declaration of Variables) ใน ภาษา C หรือ C++ (และโปรแกรมในภาษาอื่นๆ) ตัวแปรทุกตัวที่จะมีการเรียกใช้ในโปรแกรมจำเป็นต้องมีการกำหนดชนิดของตัวแปร นั้นๆ ก่อนที่จะทำการเรียกใช้ตัวแปร การกำหนดชนิดของตัวแปรมีวัตถุประสงค์หลัก 2 ประการได้แก่ – เป็นการบอกชนิด และตั้งชื่อตัวแปรที่จะเรียกใช้ ชนิดของตัวแปรจะทำให้คอมไพเลอร์สามารถแปลคำสั่งได้อย่างถูกต้อง (ยกตัวอย่างเช่น ใน CPU คำสั่งที่ใช้ในการบวกตัวเลขจำนวนเต็ม 2 จำนวน ย่อมแตกต่างจากคำสั่งที่จะบวกจำนวนจริง 2 จำนวนเข้าด้วยกัน) – ชนิดของตัวแปร ยังเป็นบ่งบอกคอมไพเลอร์ให้ทราบว่าจะต้องจัดเตรียมเนื้อที่ให้กับตัวแปรตัว นั้นมากน้อยเท่าใด และจะจัดวางตัวแปรนั้นไว้แอดเดรส (Address) ไหนที่สามารถเรียกมาใช้ใน code ได้ สำหรับในบทความนี้จะพิจารณาชนิดตัวแปร 4 ชนิดที่ใช้กันมากได้แก่ int, float, bool และ char int ชนิดตัวแปร ที่สามารถแทนค่าจำนวนเต็มได้ทั้งบวกและลบ โดยปกติสำหรับคอมพิวเตอร์ทั่วไป คอมไพเลอร์ จะจองเนื้อที่ 2 ไบต์ สำหรับตัวแปรชนิด int จึงทำให้ค่าของตัวแปรมีค่าตั้งแต่ -32768 ถึง +32768 ตัวอย่างของค่า int ได้แก่ 123 -56 0 5645 เป็นต้น floatชนิดของตัวแปรที่เป็นตัวแทนของ จำนวนจริง หรือตัวเลขที่มีค่าทศนิยม ความละเอียดของตัวเลขหลังจุดทศนิยมขึ้นอยู่กับระบบคอมพิวเตอร์ โดยปกติแล้ว ตัวแปรชนิด float จะใช้เนื้อที่ 4 ไบต์ นั่นคือจะให้ความละเอียดของตัวเลขหลังจุดทศนิยม 6 ตำแหน่ง และมีค่าอยู่ระหว่าง -1038 ถึง +1038 ตัวอย่างของค่า float ได้แก่ 16.315 -0.67 31.567 bool ชนิดของตัวแปรที่สามารถเก็บค่าลอจิก จริง (True) หรือ เท็จ (False) ตัวแปรชนิดนี้ เป็นที่รู้จักกันอีกชื่อคือ ตัวแปรบูลีน (Boolean) ตัวอย่างของตัวแปรชนิด bool ได้แก่ 1 0 true false (เมื่อ 1 = true และ 0 = false) char เป็นชนิดตัวแปรที่เป็นตัวแทนของ ตัวอักษรเพียงตัวเดียว อาจเป็นตัวอักษร ตัวเลข หรือตัวอักขระพิเศษ โดยปกติตัวแปรชนิดนี้จะใช้เนื้อที่เพียง 1 ไบต์ ซึ่งจะให้ตัวอักษรในรูปแบบที่แตกต่างกันได้ถึง 256 ค่า การเขียนรูปแบบของ char หลายๆ ตัว โดยปกติ จะอ้างอิงกับ American Standard Code for Information Interchange (ASCII) ตัวอย่างของตัวแปรชนิด char ได้แก่ ‘+’ ‘A’ ‘a’ ‘*’ ’7′ การกำหนดชนิดของตัวแปร สามารถเขียนได้อยู่ในรูป type identifier-list; เมื่อ type บ่งบอกชนิดของตัวแปร ส่วน identifier-list เป็นการกำหนดชื่อของตัวแปร ซึ่งอาจจะมีมากกว่า 1 ตัวแปร และจะแยกตัวแปรแต่ละตัวออกจากกันด้วยเครื่องหมาย comma (,) ตัวอย่าง รูปแบบของการกำหนดชนิดของตัวแปร ได้แก่

int i, j, count;
 float sum, product;
 char ch;
 bool passed_exam;

มาถึงตอนนี้ เราก็จะสามารถปรับปรุงการเขียนโปรแกรมแบบง่ายๆ ได้ดังนี้

#include 
main()
{
   int its_price;
   printf("How much is that ? ");
   scanf("%d", &its_price);
   printf("oh! %d ?, hmmm...., too expensivenn",its_price);
}

จาก code ข้างบน ผู้อ่านจะเห็น %d เมื่อมีการเรียกใช้ฟังก์ชัน scanf และ printf ทั้งนี้ %d จะเป็น format ที่ใช้บ่งบอกชนิดของตำแหน่ง (Place Holders) ที่จะมีการส่งข้อมูล โดยในที่นี้ %d หมายถึงตำแหน่งของจำนวนเต็ม หรือ int นั่นเอง ตัวอย่างของ Place Holders อื่นๆ สามารถแสดงได้ดังตาราง คราวนี้ลองมาดูตัวอย่างของการใช้ Place Holders

printf("C=%f, F=%f",cel,fah);
printf("He wants to score %d goals today",9);

เมื่อ % เป็นการบ่งบอกตำแหน่งเริ่มต้นของ Place Holder จากนั้น ตัวอักษร f ตัวแรก จะบ่งบอกถึง ตัวแปรcel ว่ามีค่าเป็นจำนวนจริง (Float) ส่วน f ตัวทีสอง จะบ่งบอกคอมไพเลอร์ว่า ตัวแปร fah ก็มีค่าเป็นจำนวนจริงเช่นกัน นอกจากนี้ Place holder %d และ %f ยังสามารถใช้กับการกำหนดตำแหน่งตัวเลขตามต้องการได้ ยกตัวอย่างเช่น สมมุติให้ x=235; และ y=6.54321;[[5520]]การให้กำหนดค่าตัวแปร (Variable Assignment) เรา สามารถกำหนดค่าให้กับตัวแปรได้ ด้วยเครื่องหมาย = ยกตัวอย่างเช่น int name; // กำหนดตัวแปร name ที่เก็บค่าจำนวนเต็ม name = 23; // กำหนดให้ตัวแปร name มีค่าเป็น 23 ในขณะเดียวกัน เราสามารถใช้เครื่องหมาย = ระหว่างตัวแปรกับตัวแปร หรือตัวแปรกับจำนวนใดๆ ได้ อาทิเช่น

change = x1 - x2;
mean = (x1 + x2)/2;
x = x + 1;

ตอนนี้เราลองมาเขียนโปรแกรมอย่างง่าย เพื่อทำการแก้ปัญหาทางคณิตศาสตร์ ด้วยการแปลงค่า อุณหภูมิ ในหน่วยของ ฟาเรนไฮต์ เป็น เซลเซียส เมื่ออุณหภูมิในหน่วยฟาเรนไฮต์ มีค่า = 85 และเป็นที่ทราบกันดีว่า ความสัมพันธ์ระหว่าง องศาฟาเรนไฮต์ และ เซลเซียส สามารถเขียนได้อยู่ในรูปของสมการ[[5521]]การเขียนโปรแกรม เพื่อแก้ปัญหา การแปลงค่า 85 ฟาเรนไฮต์ให้เป็นเซลเซียส สามารถเขียนได้ดังนี้

#include 
void main()
{
     float F;
 float C;

 F = 85;
 C = 5*(F-32)/9;
 printf("the result is %f",C);
}

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

#include 
void main()
{
    int N1, N2, Sum;

 printf("please input an integer number : ");
 scanf("%d",&N1);
 printf("please input another integer number : ");
 scanf("%d",&N2);

 Sum = N1 + N2;
 printf("so, %d + %d = %d",N1,N2,Sum);
}

จากตัวอย่างการเขียนโปรแกรมข้างต้น จะเห็นว่ามีการคำนวณทางคณิตศาสตร์เข้ามาเกี่ยวข้อง คราวนี้เราลองมาดู การคำนวณในภาษา C กันว่าจะเขียนกันได้อย่างไรบ้าง[[5522]]
หน้าที่ 3 – การเปรียบเทียบ แบบมีทางเลือก (Selection Structures)
2.การเขียนโปรแกรมแบบมีทางเลือก (Selection Structures) การเขียน โปรแกรมแบบมีทางเลือก จะสามารถทำให้โปรแกรมสามารถตัดสินใจหรือเปรียบเทียบ จากนั้นก็จะเลือกดำเนินการไปในทิศทางหนึ่งจากสองทิศทาง ขึ้นอยู่กับผลที่ได้จากการเปรียบเทียบนั้น เงื่อนไข (Condition) - เป็นตัวกำหนดเงื่อนไขที่ผู้พัฒนาโปรแกรมได้สร้างขึ้นมา – ผลลัพธ์ที่ได้จากเงื่อนไข จะมีค่า จริงหรือ เท็จ โครงสร้างของเงื่อนไข (Condition Control Structures) ประโยค เงื่อนไขสามารถที่จะเขียนให้อยู่ในรูปภาษา C จะเขียนได้ดังนี้ if condition then A else B ซึ่งหมายความว่า ถ้าเงื่อนไข (condition) มีค่าเป็นจริง ก็จะดำเนินการทำคำสั่ง A มิเช่นนั้นก็จะทำคำสั่ง B ตัวอย่างของการเขียนโครงสร้างทางเลือกในภาษา C สามารถเขียนได้ดังนี้

if (x < y)
 a = x * 2;
else
 a = x + y;

ความหมายของ code ดังกล่าว หมายความว่า ถ้า ค่า x มีค่าน้อยกว่า y แล้ว a = x*2 แต่ถ้า x มีค่ามากกว่าหรือเท่ากับ y แล้ว a = x+y นั่นเอง รูปแบบของเงื่อนไข ส่วนใหญ่จะอยู่ในรูป “ตัวแปร โอเปอเรเตอร์ ตัวแปร” โอเปอเรเตอร์ที่กล่าวถึงนี้จะมีอยู่ 2 แบบ ด้วยกันคือ โอเปอเรเตอร์สัมพันธ์ (Relational Operator) และ โอเปอเรเตอร์ลอจิก (Logical Operator) โอเปอเรเตอร์สัมพันธ์ที่ใช้ในภาษา C มีดังต่อไปนี้[[5523]]

if ( condition1 ) 
   statement1 ; 
else 
      if ( condition2 ) 
           statement2 ; 
           . . . 
        else if ( condition-n ) 
                  statement-n ; 
                else 
                  statement-e ;

ยกตัวอย่างของโปรแกรม Nested if สามารถเขียนได้ดังนี้

if (x < 0.25)
  count1++;
else if (x < 0.5)
           count2++;
        else if (x < 0.75)
                  count3++;
                else
                    count4++;

นอกจากรูปแบบของ if-else แล้ว เรายังสามารถใช้เครื่องหมาย ? มาประยุกต์ในการเขียน code เพื่อให้ได้ความหมายเดียวกันกับ if-else ดังแสดงให้เห็นดังนี้

if (x < y)
 a = x * 2;
else
 a = x + y;

สามารถเขียนได้ในอีกรูปแบบหนึ่งคือ a = x < y ? x*2: x+y ; // ซึ่งจะให้ความหมายเดียวกันกับ code ข้างบนนั่นเอง ในบางครั้งที่เราต้องเขียนโปรแกรมแบบมีทางเลือก โดยบางครั้งเราต้องการให้มีทางเลือกมากว่า 2 ทาง Nested if เป็นวิธีหนึ่งที่สามารถใช้แก้ปัญหาได้ แต่เพื่อให้ง่ายขึ้น ในภาษา C เราจึงสามารถใช้คำสั่ง switch ได้ โดยรูปแบบการเขียน คำสั่ง switch สามารถเขียนให้อยู่ในรูป

switch (selector) 
      {
      case label1: statement1;
          break;
      case label2: statement2;
          break;
          ...
      case labeln: statementn;
          break;
      default: statementd; // optional
          break;
      }

โดยที่ selector จะต้องเป็นจำนวนเต็ม ตัวอักษร หรือผลลัพธ์ของการกระทำที่ให้เลขจำนวนเต็มหรือตัวอักษร ตัวอย่างของการเขียน code โดยมีการเรียกใช้คำสั่ง switch สามารถเขียนได้ดังนี้ switch (i) { case 1 : grade = ‘A’; break; case 2 : grade = ‘B’; break; case 3 : grade = ‘c’; break; default : printf(“%c not in range”, i); break; } โดยหลักการของ switch คือ compiler จะทำการเปรียบเทียบค่าของ selector เทียบกับ label ถ้าไม่ตรงกับ label ใดๆ ก็จะเข้าไปทำในคำสั่งของ default นอกจากนี้ การใส่คำสั่ง break หรือไม่มีคำสั่ง break ก็จะให้ผลลัพธ์ที่แตกต่างกัน ดังแสดงให้เห็นดังตัวอย่างต่อไปนี้ (ทดลอง Run แล้วจะเห็นความแตกต่าง)[[5524]][[5525]]การเปรียบเทียบตัวอักษร คุณ ผู้อ่านทราบกันหรือไม่ว่า ตัวอักษรสามารถเปรียบเทียบค่ากันได้ เบื้องต้นเราต้องทราบก่อนว่า ตัวอักษรมีค่าอย่างไรกันบ้าง  ตัวอักษรตัวเล็ก ‘a’ มีค่า 97 ไปจนถึง ‘z’ มีค่า 122  ตัวอักษรตัวใหญ่ ‘A’ มีค่า 65 ไปจนถึง ‘Z’ มีค่า 90 ตัวอย่างของการเปรียบเทียบตัวอักษร สามารถแสดงให้เห็นได้ดังนี้  ‘9’ >= ‘0’ มีค่าเป็นจริง (1)  ‘a’ < ‘e’ มีค่าเป็นจริง (1)  ‘B’ <= ‘A’ มีค่าเป็นเท็จ (0)  ‘a’ <= ‘A’ ขึ้นอยู่กับระบบ แต่ส่วนใหญ่ เป็นเท็จ  ‘a’ <= ‘c’ && ‘c’ <= ‘z’ มีค่าเป็นจริง คราวนี้เราลองมาดูโจทย์กัน สมมุติว่า เราจะเขียนโปรแกรม เพื่ออ่านค่าตัวอักษร 4 ตัว แล้ว เราต้องการที่จะเปลี่ยนตัวอักษรแต่ละตัว ให้เป็นตัวอักษรใหญ่ หรือเล็กที่ตรงข้ามกับค่าที่รับเข้าไป ยกตัวอย่างเช่น PooH ให้เปลี่ยนเป็น pOOh เราจะเขียนโปรแกรมอย่างไร คำตอบ วิธีหนึ่งที่สามารถทำได้ คือใช้ Nested-if ดังนี้ #include void main() { char A, B, C, D; printf(“Input 4 charactersn”); scanf(“%c %c %c %c”, &A, &B, &C, &D); if((A <= 90)&&(A >= 65)) A = (A – 65) + 97; else if ((A >= 97)&&(A <= 122)) A = (A-97) + 65; else A = A; if((B <= 90)&&(B >= 65)) B = (B – 65) + 97; else if ((B >= 97)&&(B <= 122)) B = (B-97) + 65; else B = B; if((C <= 90)&&(C >= 65)) C = (C – 65) + 97; else if ((C >= 97)&&(C <= 122)) C = (C-97) + 65; else C = C; if((D <= 90)&&(D >= 65)) D = (D – 65) + 97; else if ((D >= 97)&&(D <= 122)) D = (D-97) + 65; else D = D; printf(“The answer is %c %c %c %cn”, A, B, C, D);
หน้าที่ 4 – การเขียนโปรแกรมแบบ วนซ้ำ (Loop)
3.การเขียนโปรแกรมแบบ วนซ้ำ (Repetition & Loop) กระบวนการหนึ่ง ที่สำคัญในการออกแบบอัลกอริทึม ก็คือความสามารถในการวนลูปของการทำงานของกลุ่มคำสั่งตามที่นักพัฒนาต้องการ ดังนั้นสำหรับตอนนี้ ก็จะนำเสนอการพัฒนาโปรแกรมเพื่อให้บางส่วนของคำสั่งสามารถมีการวนซ้ำได้หลาย ครั้ง สำหรับคำสั่งที่สามารถใช้ในการเขียนโปรแกรมแบบวนซ้ำในภาษา C ได้แก่ While, Do-while และ For ตัวอย่างของการใช้คำสั่ง while, for และ do-while สามารถเขียนให้เห็นได้ดังตาราง ซึ่งผลลัพทธ์ของโปรแกรมทั้ง 3 ข้างต้นจะให้ผลลัพท์ที่เหมือนกัน คือจะแสดงผลบนหน้าจอเป็น i = 0 i = 1 i = 2 i = 3 i = 4 i = 5 i = 6 คราวนี้เราลองมาดูโครงสร้างของการใช้งานแต่ละคำสั่งกัน while ( condition ) // เมื่อ เงื่อนไข (condition) เป็นจริง ก็จะทำการวนซ้ำ ใน statement ถัดไป statement ยกตัวอย่างเช่น

sum = 0.0;
x = 5;
while (x > 0.0)
   {
    sum += x;
    x = x – 1;
   }

ในที่นี้จะเห็นว่า ค่า x มีค่าเริ่มต้นเท่ากับ 5 ซึ่ง 5 > 0 เงื่อนไขของคำสั่ง while เป็นจริง จึงทำคำสั่งถัดมาคือ sum += x; หมายความว่า sum = sum + x = 5 จากนั้นค่า x ก็มีค่าลดลงไป 1 เหลือ 4 ก็จะทำการ check เงื่อนไขว่า 4 > 0 หรือไม่ เมื่อเงื่อนไขเป็นจริง ก็จะทำการวนซ้ำ sum ก็จะมีค่าเป็น 5 + 4 = 9 และ x ก็จะมีค่าลดลงเหลือ 3 และดำเนินการวนซ้ำเช่นนี้จนกระทั่ง x มีค่าเป็น 0 ซึ่งค่า 0 ไม่ได้มีค่ามากกว่า 0.0 เงื่อนไขจึงเป็นเท็จ โปรแกรมจึงจะจบการวนซ้ำ คราวนี้เราลองมาดูตัวอย่างของการใช้คำสั่ง while ในการเขียนโปรแกรมแบบวนซ้ำ และผลลัพท์ที่ได้

x=0;
while( x <=2 ){
   printf("%d %dn",x, x*2);
}

ผลลัพท์ที่ได้จะได้ดังนี้
 0 0
 0 0
 0 0
 :   :
 0 0  (infinite loop)

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

scanf(“%d”,&n);
a = 10;
while (a > n) {
   printf(“%dn”,a);
   a = a-1;
}

ผลลัพท์ของโปรแกรมจะสามารถแสดงให้เห็นได้ดังนี้

คราวนี้เราลองมาแก้โจทย์ปัญหา การหาค่า ห.ร.ม (หารร่วมมาก) ของตัวเลข 2 ตัวใดๆ โดยอัลกอริทึม Euclidean โดยอัลกอริทึมดังกล่าว จะทำการแปลงค่าตัวเลข 2 ตัวเลขบวกใดๆ (m, n) เป็นค่า (d, 0) โดยการนำตัวเลขที่มีค่ามาก นำมาหารด้วยตัวเลขที่มีค่าน้อยกว่า นำค่าเศษที่หารได้มาแทนตัวเลขที่มีค่ามากกว่า ทำเช่นนี้จนกระทั่งได้ค่าเศษจากการหารมีค่าเป็น 0 ตัวเลขอีกตัวก็จะเป็นค่า ห.ร.ม. ยกตัวอย่างเมื่อเราทำการ Run โปรแกรม จะได้ผลดังนี้ Enter two positive integers: 532 112 The g.c.d. of 532 and 112 is 28 คราวนี้เราลองมาดูการเขียนโปรแกรมเพื่อแก้ปัญหาดังกล่าวข้างต้น สามารถเขียนได้ดังนี้

#include 
void main()
{
 int A, B, start;
     printf("Enter two positive intergers: ");
 scanf("%d %d", &A, &B);
 if(A < B) start = A;
 else start = B;
 while(((A%start) != 0)||((B%start) != 0))
 {
  start = start-1; 
 }
 printf("The g.c.d of %d and %d is %dn", A, B, start);
}

การดำเนินการทางคณิตศาสตร์ สามารถเขียนให้อยู่ในรูปแบบสั้นๆ ได้ ดังตัวอย่างในตารางดังนี้[[5526]]ความแตกต่างระหว่าง i++ และ ++i i++ และ ++i จะมีความหมายใกล้เคียงกันมาก จะแตกต่างเพียง การจัดลำดับในการคำนวณ เมื่อต้องนำไปใช้กับตัวแปรตัวอื่น A = 10; C = A++; // A= 11, C = 10 A = 10; C = ++A; // A = 11, C = 11 A = 10; C = A–; // A = 9, C = 10 A = 10; C = –A; // A = 9, C = 9โครงสร้างการเขียนโปรแกรมแบบวนซ้ำโดยใช้คำสั่ง For คำ สัง for สามารถเขียนให้อยู่ในรูปแบบได้ดังนี้ for ( เริ่มต้น ; เงื่อนไข ; เปลี่ยนแปลง ) statement; เมื่อเริ่มต้น เป็นการกำหนดค่าตัวแปรเริ่มต้นที่ต้องการ ส่วนเงื่อนไขหากค่าลอจิกมีค่าเป็นจริง ก็จะทำตามในโครงสร้างของการวนซ้ำคือ run คำสั่ง statement แต่ถ้าเป็นเท็จก็จะออกจากโครงสร้างการวนซ้ำ ส่วนเปลี่ยนแปลง จะทำการปรับค่าของตัวแปรที่ต้องการ ยกตัวอย่างเช่น

for ( count=0 ; count < 10 ; count++)
  {
   printf(“count = %dn”,count);
  }

ใน code ข้างต้น ตัวแปร count จะเริ่มต้นจากค่า 0 ซึ่งค่า 0 มีค่าน้อยกว่า 10 ก็จะทำคำสั่ง print ค่าของตัวแปร count จากนั้นค่า count ก็จะเพิ่มค่าเป็น 1 เงื่อนไข count < 10 ก็ยังคงเป็นจริง ก็จะทำการพิมพ์ ค่าของตัวแปร count วนซ้ำเช่นนี้ จนกระทั่ง count มีค่าเพิ่มขึ้นจนเป็น 10 เงื่อนไขก็จะเป็นเท็จ และจบโครงสร้างของการวนซ้ำ การเปลี่ยนแปลงค่าของตัวแปร อาจจะมีการเปลี่ยนแปลงมากกว่า 1 ค่า ยกตัวอย่างเช่น

for ( count=0 ; count < 10 ; count += 2)  // ตัวแปร count มีค่าเปลี่ยนแปลงเพิ่มขึ้นครั้งละ 2
{
   printf(“count = %dn”,count);
}
for ( count=10 ; count > 5 ; count -= 2)   // ตัวแปร count มีค่าเปลี่ยนแปลงลดลงครั้งละ 2
{  
   printf(“count = %dn”,count);
}

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

start = 0; end = 20; step=3;
for ( count=start ; count < end ; count += step)
{
   printf(“count = %dn”,count);
}

คราวนี้ เราลองมาทดลองเขียนโปรแกรม โดยให้โปรแกรม สามารถรับค่าตัวเลขใดๆ และแสดงค่าในรูปแบบดังตัวอย่างต่อไปนี้[[5527]]

Input the number > 4

0
0 1
0 1 2
0 1 2 3
0 1 2
0 1
0

เราสามารถแก้ปัญหาข้างต้น โดยใช้โครงสร้างการเขียนโปรแกรมแบบวนซ้ำดังต่อไปนี้

#include 
void main()
{
 int number, i, j;
     printf("Enter number: ");
 scanf("%d", &number);
 for(j= 0; j< number; j++)
 {
  for(i=0; i<= j; i++)
  {
   printf("%d ", i);
  }
  printf("n");
 }
 for(j= number-1; j>= 0; j--)
 {
  for(i=0; i< j; i++)
  {
   printf("%d ", i);
  }
  printf("n");
 }
}

โครงสร้างการเขียนโปรแกรมแบบวนซ้ำโดยใช้คำสั่ง do-while รูปแบบ ของการเขียน code สำหรับโปรแกรมแบบวนซ้ำที่ใช้ do-while สามารถเขียนให้อยู่ในรูปทั่วไปได้ดังนี้ do statement while ( เงื่อนไข ); ตัวอย่างของโครงสร้าง do-while สามารถเขียนได้ดังนี้

sum = 0.0;
scanf(“%f”, &x);
do {
    sum += x;
    scanf(“%f”, &x);
  }
while (x > 0.0);

โปรแกรมข้างต้นจะทำการอ่านค่าจะ keyboard เมื่อ User พิมพ์ค่าที่มีค่ามากกว่าศูนย์ ก็จะทำการบวกค่าเหล่านี้ไปที่ตัวแปร sum จนกระทั่ง User พิมพ์ ตัวเลข 0 หรือค่าที่น้อยกว่า ศูนย์ ทำให้เงื่อนไขเป็นเท็จ และโปรแกรมจึงจะออกจากโครงสร้าง do-while คราวนี้เราลองมาเขียนโปรแกรมที่ใช้โครงสร้าง do-while โดยโจทย์กำหนดให้ว่า ให้โปรแกรมสามารถรับค่าตัวเลขใดๆ (X) และ แสดงผลของตัวเลข ระหว่าง 0 ถึง X ที่สามารถหารด้วย 4 ลงตัว

#include 
void main()
{  
 int number, i;
 printf("enter the numbern");
 scanf("%d", &number);
            i = 0;
 do
 {
  if((i % 4) == 0) printf("%d ", i);
                       i++;
 }
            while(i <= number);
}

ตอนนี้ผู้อ่านก็คงจะรู้จัก การเขียนโปรแกรมแบบวนซ้ำกันแล้วนะ ต่อไป เราก็จะไปเรียนรู้เกี่ยวกับการเขียนโปรแกรมแบบแยกเป็นโมดูลกัน
หน้าที่ 5 – ฟังก์ชัน (Functions) และ โปรแกรมแยกเป็นโมดูล (Modular Programming)
4.ฟังก์ชัน และการเขียนโปรแกรมแยกเป็นโมดูล (Functions & Modular Programming) สำหรับ นักพัฒนา ที่ได้ทำการพัฒนาโปรแกรมมามากๆ บางครั้ง จำเป็นต้องเขียนโปรแกรมที่มีขนาดใหญ่และมีความสลับซับซ้อน จึงจำเป็นต้องหาวิธีในการพัฒนาโปรแกรมที่ดี ซึ่งสามารถทำได้ด้วยการ แตกปัญหาใหญ่ออกเป็นปัญหาย่อยๆ แล้วแก้ปัญหาย่อยออกไปที่ละส่วนจนกว่าจะหมด ซึ่งจะช่วยให้แก้ปัญหาใหญ่ๆ ได้สำเร็จนั่นเอง ซึ่งเราเรียกกันว่า วิธีแบ่งแยกแล้วพิชิต (Divide and Conquer) ซึ่งจะเป็นแนวการแก้ปัญหาแบบจากบนลงล่าง (Top down approach) ดังแสดงให้เห็นดังภาพที่ 4.1[[5529]]การแตกปัญหาออกเป็นฟังก์ชันย่อยๆ มีข้อดีดังนี้ 1) การแยกปัญหาที่จะใช้ในการเขียนโปรแกรมออกเป็นฟังก์ชันย่อยๆ จะช่วยให้เขียนโปรแกรมได้ง่ายขึ้นเพราะปัญหามีความซับซ้อนน้อยลง 2) การแยกปัญหาที่จะใช้ในการเขียนโปรแกรมออกเป็นฟังก์ชันย่อยๆ สามารถแก้ปัญหาตามที่โปรแกรมต้องทำ โดยมีโอกาสที่จะผิดพลาดน้อยลงเนื่องจากได้ทดสอบแก้ไขข้อผิดพลาดภายใน ฟังก์ชันย่อยๆ ก่อนรวมกันเป็นโปรแกรมใหญ่แล้ว 3) การแยกปัญหาออกเป็นฟังก์ชันย่อยนั้นมีประโยชน์ ที่ทำให้เราสามารถใช้ฟังกชันย่อยๆ เหล่านี้กลับไปใช้กับโปรแกรมอื่นๆ ได้ด้วย 4) การนำฟังกชันย่อยๆ เหล่านี้กลับมาใช้อีก จะช่วยลดขนาดของโปรแกรมลง และยังช่วยลดเวลาและค่าใช้จ่ายในการพัฒนาและการซ่อมบำรุงโปรแกรมได้อีกด้วย เพราะไม่ต้องเสียเวลาในการเขียนฟังก์ชันซ้ำ นอกจากฟังก์ชันย่อยที่ยังไม่ได้เขียนมาก่อน ตัวอย่างการเขียนโปรแกรมออกเป็นโมดูลต่างๆ จะแสดงให้เป็นดังผังในภาพที่ 4.2 ซึ่งในภาพดังกล่าวได้แยกโปรแกรม Main ออกเป็นส่วนๆ คือ[[5530]]1) ส่วนรับข้อมูล (Input) ซึ่งจะเป็นไปตามความต้องการของผู้ใช้ เช่นการป้อนข้อมุล หรือ การอ่านไฟล์ข้อมูล 2) ส่วนการคำนวณ (CAL) ซึ่งประกอบด้วยฟังก์ชันที่ใช้กับการคำนวณ ได้แก่ i. AVG สำหรับคำนวณค่าเกรดเฉลี่ยสำหรับเทอมปัจจุบัน ii. GPA สำหรับคำนวณเกรดเฉลี่ยสะสม 3) ส่วนการแสดงผล (Display) ซึ่งเป็นการแสดงผลบนจอภาพ หรือจะพิมพ์ผลออกมาก็ได้ตามความต้องการของผู้ใช้โปรแกรม ที่กำหนดให้ผู้เขียนโปรแกรมทำให้สำเร็จตามเป้าหมาย ภาพที่ 4.2: ตัวอย่างการเขียนโปรแกรมคำนวณค่าเกรดเฉลี่ย และ เกรดเฉลี่ยสะสมออกเป็นโมดูล ส่วนในการตั้งชื่อฟังก์ชันนั้น ก็มีข้อกำหนดดังนี้ 1) ห้ามขึ้นต้นด้วยตัวเลข 2) ห้ามเอาชื่อตารางอาเรย์ ชื่อตัวแปร หรือ คำสำคัญ (keywords) มาตั้งชื่อฟังก์ชันโดยเด็ดขาด 3) ในการใช้งานจริง นั้น ไม่ควรตั้งชื่อฟังก์ชันโดยไม่สื่อความหมายถึงการทำงานของฟังก์ชัน เพราะจะทำให้ลำบากในการซ่อมบำรุงโปรแกรม โดยทั่วไปแล้วในการประกาศฟังก์ชันนั้น จะต้องมีการกำหนด type ให้ตัวแปรร่วมภายในฟังก์ชันด้วยเสมอ ดังตัวอย่างต่อไปนี้ ชนิดของฟังก์ชัน[function-type] ชื่อฟังก์ชัน [function-name] (บัญชีตัวแปรร่วม [parameter-list])

{
  การประกาศตัวแปรเฉพาะที่; [local-definitions declaration;]
  กลไกการทำงานของฟังก์ชัน; [function-implementation;]
  การคืนค่าถ้าชนิดฟังก์ชันไม่เป็น void; [return statement if function type NOT void]
}

ยกตัวอย่างเช่น

float distance(float x, float y) // float คือ ชนิดของฟังก์ชัน ส่วน distance คือ ชื่อฟังก์ชัน
{    // float x, float y คือ บัญชีตัวแปรร่วม
 float dist;  // float dist คือ การประกาศตัวแปรเฉพาะที่;
 dist = sqrt(x*x+y*y); // dist = ระยะห่างระหว่างพิกัด (x,y) ไป (0,0) 
 return dist ;
}

ก่อนจะทำการเรียกใช้ฟังก์ชัน จำเป็นต้องมี การกำหนดฟังก์ชัน (function prototype) ซึ่ง เป็น copy ของ function heading และมีข้อกำหนดดังนี้ 1) ตัวแปรร่วมในฟังก์ชัน ที่ประกาศไว้ และ ตัวแปรร่วมขณะเรียกใช้ฟังกชันนั้นต้องมีจำนวนเท่ากันและต้องมี type ตรงกัน มิฉะนั้นจะเกิด error ขึ้น 2) ต้องกำหนดการทำงานของฟังก์ชันก่อนการเรียกใช้ฟังก์ชัน ใน main function เพื่อให้ตัวแปรภาษารู้ว่าฟังก์ชันนี้ทำงานอย่างไร 3) แม้ฟังก์ชันที่ใช้จะไม่มีค่าตัวแปรร่วม ก็ต้องใส่วงเล็บ [ ( ) ] ไว้หลังชื่อฟังก์ชันเสมอ 4) การกำหนดฟังก์ชัน จะต้องกำหนดก่อนการใช้ Main function เพื่อให้ Main function ได้รับรู้ว่าฟังก์ชันดังกล่าวมีอะไรเป็นตัวแปรร่วม และ จะคืนค่าอะไรออกมา 5) กลไกการทำงานเต็มของฟังก์ชันย่อยจะแสดงหลังจากที่เรียก Main function แล้ว หรืออยู่ในไฟล์ที่แยกต่างหาก ซึ่งจะมีการแปรออกมาแล้วเชื่อมต่อกับ Main function การกำหนดฟังก์ชันจะมีลักษณะดังนี้

float distance(float, float); // การกำหนดฟังก์ชัน [function prototype]

 void main()
 {
  float x0 = ….,y0 = …;
 float dist1 = distance(x0,y0); 
}
float distance(float x, float y) // float คือ ชนิดของฟังก์ชัน distance คือ ชื่อฟังก์ชัน
{    // float x, float y คือ บัญชีตัวแปรร่วม
 float dist;  // float dist คือ การประกาศตัวแปรเฉพาะที่;
 dist = sqrt(x*x+y*y); 
 return dist ;
}

ในการส่งผ่านตัวแปรเข้า ฟังก์ชัน (Passing argument) นั้นมีการ เรียกได้ 2 แบบ คือ 1) ส่งผ่านตามค่า (Pass by Value) ซึ่งส่งผ่านค่า ลงในตัวแปรร่วมของฟังก์ชันโดยตรง 2) ส่งผ่านตามการอ้างอิง (pass by Reference) ซึ่งส่งผ่านค่า address ในหน่วยความจำของตัวแปร ให้กับตัวแปรร่วมของฟังก์ชัน ถ้ามีการเปลี่ยนแปลงข้อมูล ณ ตำแหน่งหน่วยความจำดังกล่าว ค่าที่ส่งให้ตัวแปรร่วมของฟังก์ชันก็จะเปลี่ยนด้วย ตัวแปรที่เกี่ยวข้องกับฟังก์ชันคือ 1) ตัวแปรเฉพาะที่ (Local variables) เป็นตัวแปรที่อยู่และเปลี่ยนแปลงเฉพาะภายในฟังก์ชันที่เรียกใช้ตัวแปรดัง กล่าว การเปลี่ยนแปลงภายนอกฟังก์ชันที่เรียกใช้ตัวแปรเฉพาะที่จะไม่มีผลต่อตัวแปร เฉพาะที่ดังกล่าว ดังตัวอย่างต่อไปนี้

void test_locvar(int num)
{
 int myvar; // Local variable fro this function
 myvar = num;
}
void main()
{
 int myvar, myvar_before, myvar_after; //Local variable for this function 
 myvar = 5;
 myvar_before = myvar; // myvar_before = 5;
 test_locvar(100); // call function
 myvar_after = myvar; // myvar_after = 5;
}

2) ตัวแปรส่วนกลาง (Global variables) เป็นตัวแปรที่อยู่นอกฟังก์ชันซึ่งสามารถเปลี่ยนแปลงค่าภายในตัวแปรได้ตลอด เวลาเมื่อตัวแปรได้รับการเปลี่ยนแปลงโดยฟังก์ชัน ดังตัวอย่างต่อไปนี้

int myvar; // Global varible
void test_locvar(int num)
{
 myvar = 20;
}

void main()
{
 int myvar_before, myvar_after;  //Local variable fro this function 
 myvar = 5;
 myvar_before = myvar; // myvar_before == 5;
 test_locvar(100); // call function
 myvar_after = myvar; // myvar_after == 20;
}

ฟังก์ชันมีหลายประเภทได้แก่ 1) ฟังก์ชันที่ไม่มี อาร์กิวเมนต์ และ ไม่คืนค่า เช่น ฟังก์ชัน void main() 2) ฟังก์ชันที่มี อาร์กิวเมนต์ แต่ ไม่คืนค่า เช่นฟังก์ชัน void do_something(float x, float y) ซึ่งจะทำงานตามที่ต้องการโดยอาศัยค่าอาร์กิวเมนต์ (ตัวแปร x,y) โดยไม่คืนค่าออกมา ฟังก์ชันดังกล่าวจะมีกลไกการับข้อมูลเข้าต่างหาก โดยไม่ต้องใช้ตัวแปรที่เป็น อาร์กิวเมนต์ 3) ฟังก์ชันที่ไม่มี อาร์กิวเมนต์ แต่ก็คืนค่า เช่น ฟังก์ชัน float do_something2() ค่าที่คืนมาได้จาก ตัวแปรเฉพาะที่และกลไกการคำนวณภายในฟังก์ชันดังกล่าว 4) ฟังก์ชันที่มี อาร์กิวเมนต์ และ คืนค่า เช่นฟังก์ชัน float distance(float x, float y) ฟังก์ชันดังกล่าว สามารถคืนค่า โดยไม่จำเป็นต้องใช้ตัวแปรเฉพาะที่ทำหน้าที่เป็นตัวแปรชั่วคราวในการคืนค่า ตัวอย่างเช่น

float distance3D(float x, float y, float z)
{
  return sqrt((x*x)+(y*y)+(z*z));
}

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

Type ArrayName[size];    // Format of Blank array 
Type ArrayNameInitialized[size] = {…};  // Format of initialized array 
int a[5] = {0,0,0,0,0};
double air[5];
char vowel[] = {’A’,’E’,’I’,’O’,’U’};

ในกรณีใช้ตัวแปรดัชนี้ชี้ตำแหน่งข้อมูลในตาราง ค่าของตัวแปรที่จะชี้จะต้องอยู่ในช่วงระหว่าง 0 กับ N-1 โดยที่ N คือขนาดตารางอาเรย์ ดังตัวอย่างที่แสดงในภาพที่ 5.1[[5531]]ถ้าค่าดัชนีน้อยกว่า 0 หรือมากกว่า N – 1 แล้วโปรแกรมจะทำงานผิดพลาดหรือหยุดทำงาน การแยกแยะช่องตาราง (Array subscription) ทำได้โดย การใช้ชื่อตัวแปรอาเรย์ ตามด้วย วงเล็บเหลี่ยมที่มีค่าดัชนี (เช่น Data[i], i = 0, 1, 2, … N-1 ) การประกาศค่าตั้งต้นให้ตัวแปรอาเรย์สามารถทำได้โดยใช้เครื่องหมายปีกกา ( { } ) หรือจะยกประกาศค่าตั้งต้นที่ละช่องตารางก็ได้ตามความต้องการของผู้ใช้ โดยส่วนที่ ไม่ได้ใส่ค่าตั้งต้นจะมีค่าเป็นศูนย์ (กรณีตารางอาเรย์แบบ int, double, หรือ float) หรือเป็นค่าว่าง ดังตัวอย่างต่อไปนี้

int a[4] = {9, 8, 7}; ซึ่งจะได้ค่าออกมาตรงกัย a[0] = 9; a[1] = 8; a[2] = 7; และ a[3] = 0;

 กรณีที่ตารางมีหลายมิติ จะมีการเรียกใช้ตามรูปแบบตารางมิติเดียวต่อไปนี้ 
ตาราง 2 มิติ: type arrayname2D[size1][size2];
ตาราง 3 มิติ: type arrayname3D[size01][size02][size03];

 การค้นข้อมูลในตารางอาเรย์นั้น สามารถเข้าถึงได้อย่างรวดเร็วไม่ว่าตารางจะใหญ่เพียงไหน เช่น

 const int SIZE = 100; // #define SIZE 100 for C
 float A[SIZE],B[SIZE],C[SIZE];
for(i = 0; i <= SIZE-1; i++)
 {
  C[i] = B[i] – A[i];
}

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

void main()
{
float X[10], X[0] = 123.23, X[1] = 24.56, X[2] = 45.67; 
float total = sum_element(X[0],X[1],X[2]);
 … 
}
float sum_element(float A, float B, float C)
{
 return (A+B+C);
}

2) กรณีที่ใช้ข้อมูลทั้งตารางอาเรย์ การส่งผ่านข้อมูลในตารางลงในฟังก์ชันจะเป็นดังนี้

void main()
{
float X[10], X[0] = 123.23, X[1] = 24.56, X[2] = 45.67; 
float total = sum_element_array(X)
 … 
}
float sum_element_array(float A[])
{
 int index; float Sum = 0;
 for(index =0; index <= 3-1; index++)
{
  Sum +=A[index];
}
return Sum;
}

3) กรณีที่ใช้ข้อมูลทั้งตารางเพื่อให้ได้ผลลัพธ์ออกมาเป็นตารางอาเรย์ให้ทำดังนี้

void add_arrays(float ar1[],  // input array 1
  float ar2[],  // input array 2
  float ar_sum[],  // Output array
  int N)  // Array Size
{
 for(int i = 0; i <= N-1; i++)
 {
  ar_sum[i] = ar1[i] + ar[2];
}
}

การค้นหาข้อมูลในตาราง (Array searching) ในการค้นข้อมูลนั้นมักใช้ linear search หาข้อมูลในตารางตามที่ต้องการ โดยกำหนดเงื่อนไขว่า 1) ถ้าหาข้อมูลพบ ให้แสดงดัชนีของค่าที่ค้นพบ ก่อนออกจากวงรอบการค้นหา 2) ถ้าหาข้อมูลไม่พบ ให้ออกจากโปรแกรมแล้วคืนค่า ที่อยู่นอก ขอบเขต 0 – N-1, N คือ ขนาดตารางอาเรย์ (โดยมากให้คืนค่า -1) การสับเรียงข้อมูลในตาราง (Array Sorting) การสับเรียงข้อมูลมีหลายวิธี ซึ่งจะกล่าวถึงในที่นี้พอสังเขปดังนี้ 1) Bubble Sort ซึ่งเขียนใช้งานง่ายแต่ สับตำแหน่งข้อมูลได้ผลช้าที่สุด ซึ่งมีกลไกดังนี้

void BubbleSort(float list[], int N)
{
 int i,j;
 float temp;
 for(i = N-1; i>=0; i--)
 {
  for(j = 1; j <=i; j++)
  {
   if(list[j-1] > list[j])
   {
    temp = list[j-1];
    list[j-1] = list[j];
    list[j] = temp;
}
}

}
}

2) Selection Sort ซึ่งจะเลือกค่าที่ยังไม่ได้สับเปลี่ยนที่น้อยที่สุดเป็นหลัก ในการสลับที่

void SelectSort(float list[], int N)
{
 int i,j, MinIndex;
 float temp;
 for(i = 0; i<=N-2; i--)
 {
  MinIndex = I;

for(j = i+1; j <=N-1; j++)
  {

   if(list[j] < list[MinIndex])
   {
    minIndex = j 
} 

   temp = list[j-1];
   list[j-1] = list[j];
   list[j] = temp;
}
}
}

3) Insertion Sort ซึ่งจะเติมข้อมูลลงในตำแหน่งที่เหมาะสมในขั้นสุดท้าย ซึ่งจะต้องมีตัวแปรอาเรย์ อย่างน้อย 2 ตัว โดยที่อาเรย์ตัวแรกทำหน้าที่ เป็น List เก็บข้อมูล ต้นฉบับ (Source List) และอาเรย์ตัวหลังทำหน้าที่รับข้อมูลที่ผ่านการสับตำแหน่งแล้ว (Sorted List) ในการสับที่กันนั้น จะให้ข้อมูลปัจจุบันเคลื่อนผ่านข้อมูลที่ผ่านการสับตำแหน่งแล้ว จากนั้นจึงลงมือสลับข้อมูลอีกครั้งจนกว่าข้อมูลทั้งหมดจะเข้าที่

void insert_sort(float data[], int Size)
{
 int i,j;
 float DatElement;
 for(i=1;i<=Size-1;i++)
 {
  DatElement = data[i];
  j = i;
  while((j >= 1) && data[j-1] >DatElement)
  {
   data[j-1] = data[j];
   j = j-1;
}
data[j] = DatElement;
}
}

หน้าที่ 7 – ตัวแปรพอยเตอร์ (Pointers)
6. ตัวแปรพอยเตอร์ (Pointers) Pointer คือตัวแปรดัชนีที่ เก็บค่าตำแหน่งแอดเดรสของหน่วยความจำ ซึ่งตัวแปรพอยเตอร์นั้น จะมีเครื่องหมายดอกจันทร์ (*) นำหน้าเสมอ ดังตัวอย่างต่อไปนี้ int *Num; float *GreatNum; char *Name; ตัวแปรพอยเตอร์มีประโยชน์ในการลดปริมาณหน่วยความจำที่ต้องใช้ในการเขียน โปรแกรม โดยการส่งข้อมูลในรูปพอยเตอร์ เข้าไปในฟังก์ชันที่โปรแกรมเรียกพร้อมกันหลายฟังก์ชัน แทนการส่งข้อมูลในรูปตัวแปรธรรมดา ซึ่งต้องใช้ตัวแปรหลายตัว ตัวแปรพอยเตอร์มีลักษณะคล้ายตัวแปรตารางอาเรย์ แต่ที่แตกต่างกันคือ ตัวแปรตารางอาเรย์จะเก็บเฉพาะค่าต่างๆ ที่เป็นชนิดกันเดียวกับตัวแปรอาเรย์แต่ ตัวแปรพอยเตอร์จะเก็บเฉพาะค่าตำแหน่ง Address
ตัวแปรเท่านั้น โดยไม่ได้มีการจัดเตรียมหน่วยความจำแบบไดนามิกส์ (Dynamic Memory Allocation) ไว้ การเข้าถึงตำแหน่งแอดเดรสทำได้โดย ใช้เครื่องหมายแอมเปอร์แซนด์ (&) ซึ่งจะแสดงให้เห็นดังตัวอย่างต่อไปนี้ ในที่นี้กำหนดให้ตัวแปร Andy อยู่ในตำแหน่ง Address ที่ 1776 ดังตังอย่างในภาพที่ 6.1[[5533]]Andy = 25; // Assigning Value 25 to Andy Fred = Andy; // Assigning Value 25 (Value of Andy) to Fred Ted = &Andy // Assigning Value 1776 (Address of Andy) to Ted via & อย่างไรก็ดี ถ้าต้องการให้ตัวแปร Ted สามารถ ดึงค่า จากตัวแปร Andy ได้ ให้ ใช้สัญลักษณ์
ตัวอ้างอิงโดยอ้อม (Indirect operand) ซึ่งเป็นนำเครื่องหมายดอกจันทร์ (*) นำหน้าตัวแปรที่เก็บค่าแอดเดรสตัวแปร ดังตัวอย่างในภาพที่ 6.2[[5534]]Beth = *Ted // Beth มีค่าเท่ากับ ค่าที่ตัวแปร Ted ชี้ซึ่งเท่ากับ 25 ตัวพอยเตอร์จะใช้กับตัวแปรชนิดใดก็ได้โดยที่ ตัวแปรพอยเตอร์ดังกล่าวจะได้รับการกำหนดหน่วยความจำตามลักษณะชนิดตัวแปรด้วย เช่น ตัวแปรพอยเตอร์ประเภท int จะได้รับการกำหนดหน่วยความจำไว้ที่ 4 ไบต์ ตัวอย่างการกำหนด ค่า Pointer จะแสดงให้เห็นดังนี้ โดยผลการกำหนดค่าจะแสดงให้เห็นในภาพที่ 6.3 สังเกตให้ดีจะพบว่า ตำแหน่งแอดเดรสหน่วยความจำเลื่อนไป 4ไบท์ ระหว่างตัวแปร j กับ k และ ตัวแปร k กับ ptr[[5535]]จากตัวแปรพอยเตอร์สู่ตัวแปรอาเรย์ (Pointer to Array) ตัว แปรอาเรย์มีความเกี่ยวข้องสัมพันธ์กับตัวแปรพอยเตอร์คือ ชื่อตัวแปรอาเรย์ (Array identifier) จะมีค่าเทียบได้กับตำแหน่งแอดเดรสของตารางช่องแรกซึ่งเทียบได้กับตำแหน่งแรก ตัวแปรพอยเตอร์ จะมีค่าเท่ากับแอดเดรสของตัวแปรแรกที่ตัวแปรพอยเตอร์ชี้ ดังตัวอย่างต่อไปนี้

int Num[20]; int *Ptr;

 การกำหนดค่าต่อไปนี้ถือว่าใช้ได้เหมือนกัน
 Ptr = Num; มีลักษณะเท่าเทียมกับ Ptr = &Num[0];

ความแตกต่างจะเกิดขึ้นเมื่อ มีการกำหนดค่าตัวต่อไป โดยที่เราสามารถกำหนดค่าแอดเดรสใหม่ให้ตัวแปร Ptr ได้ทันที ขณะที่ ตัวแปร Num จะชี้ไปที่ตำแหน่งแรกของตัวแปรจำนวนเต็ม ซึ่งมี 20 ตำแหน่งเสมอ ดังนั้น ตัวแปร Ptr จึงเป็นตัวแปรพอยเตอร์ที่เปลี่ยนตำแหน่งการชี้ได้ (Variable Pointer) ขณะที่ตัวแปร Num หรือชื่อตัวแปรอาเรย์เป็นตัวแปรพอยเตอร์ที่ตำแหน่งการชี้คงที่ตายตัว (Constant pointer) ดังตัวอย่างต่อไปนี้

int Num[20]; int *y; int *Ptr;
 Ptr = Num;
 *(Ptr+1) จะแสดงค่า Num[1];
 *(Ptr+i) จะแสดงค่า Num[i];
 y = &Num[0];
 y++;  // ตัวแปรนี้จะชี้ไปที่ Num[1] เท่านั้น

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการ ใช้ตัวแปรพอยเตอร์ชี้ไปที่ตัวแปรตารางอาเรย์ ซึ่งผลที่ได้จะแสดงให้เห็นในภาพที่ 6.4[[5536]]ให้ผู้อ่านลองเปลี่ยนคำสั่งในบรรทัด B เป็น printf(“ptr + d = %dn“”, i.*ptr++); ก่อนการทดสอบครั้งต่อไป เพื่อดูว่าโปรแกรมจะให้ผลออกออกมาผิดจากโปรแกรมเดิม
เมื่อทดสอบแล้ว ให้ ลองแก้บรรทัด B อีกครั้งโดยแก้เป็น printf(“ptr + d = %dn“”, i.*(++ptr));
ในการกำหนดค่าให้ตารางอาเรย์แต่ละช่องโดยใช้ตัวแปรพอยเตอร์ นั้นทำได้โดยการใช้วงเล็บครอบตัวแปรอาเรย์ที่ตามด้วยเครื่องหมายบวกและตัว เลขแสดงดัชนีพร้อมใช้เครื่องหมายดอกจันทร์ (*) นำหน้า เนื่องจากวิธีดังกล่าวจะเหมือนกับการใช้เครื่องหมาย [] และเลขดัชนี เพื่อเข้าถึงข้อมูลในตัวแปรอาเรย์ดังตัวอย่างต่อไปนี้ *(array+5) = 50 จะมีค่าเทียบเท่ากับ array[5] = 50; ส่วนในการกำหนดและเปลี่ยนแปลงค่าโดยใช้ตัวแปรพอยเตอร์นั้นทำได้ดังโปรแกรม ต่อไปนี้

void main(void)
{
 int i, j=1,k=2;
 int *ptr1, *ptr2; // Declare both variables as integer pointers
 float value[100], result[100];
 float *ptr3, *ptr4; // Declare both variables as integer pointers

 prt1 = &j;  // Defining ptr1 pointing to j 
ptr2 = &k;  // Defining ptr2 pointing to k
 ptr3 = value;  // ptr3 contain the address for the 1st element of value
 ptr4 = &value[0]; //  ptr4 contain the address for the 1st element of value

 // Value manipulation
*ptr1 = *ptr1+2  /* การบวกค่าที่ตัวแปรพอยเตอร์ ptr ชี้ไป อีก 2 */
*ptr2 = *ptr1  /* กำหนดให้ค่าที่ ตัวแปร ptr2 ชี้ เท่ากับค่าที่ตัวแปร prt1 ชี้ */
k = *ptr2  /* กำหนดให้ k มีค่าเท่ากับ ค่าที่ตัวแปร ptr2 ชี้ */ 
}

การเปลี่ยนแปลง ตัวแปรพอยเตอร์ด้วยวิธีการทางคณิตศาสตร์ สามารถทำได้ดังตัวอย่างต่อนี้

float *ptr3, *ptr4; float table[100];  float Pi = 3.1415927;
ptr3 = &table[0]; // กำหนดให้ ptr3 เก็บค่าตำแหน่งแอดเดรส ของตาราง table ช่องแรก
ptr3++; // เปลี่ยนค่าตำแหน่งแอดเดรส ใน ptr3 เป็นแอดเดรสตาราง table ช่องที่2 
*ptr3 = Pi;  // ข้อมูลช่องที่ 2 ของตาราง table มีค่าเท่ากับ Pi   
ptr3+=25;  // กำหนดให้ ptr3 ชี้ไปที่ตำแหน่งแอดเดรสตาราง table ช่องที่ 26 
*ptr3 = 2.2222;  // ข้อมูล ตาราง table ช่องที่ 26 มีคาเท่ากีบ 2.2222  

ptr3 = table;  // กำหนดให้ ptr3 ชี้ไปที่ table ช่องแรก
 for(int ii =0; ii < 100; ii++)
 {
  *ptr3++ = 37.0 // กำหนดให้ข้อมูลทุกช่องของ ตาราง table เท่ากับ 37 
}
ptr3 = &table[0]; //  ptr3 contain the address for the 1st element of value
ptr4 = &table[0]; //  ptr4 contain the address for the 1st element of value

ข้อพึงระมัดระวังคือ เครื่องหมาย ++ และ -– นั้นมีลำดับความสำคัญที่สูงกว่า * ดังนั้น *ptr++ มีค่าเท่ากับ *(ptr++) ซึ่งตัวแปรทั้ง 2 หมายถึงการเพิ่มตัวเลขตำแหน่ง แอดเดรส ไม่ใช้เพิ่มค่าที่ตัวพอยเตอร์ชี้ ส่วนกรณี *p++ = *q++ นั้น การกำหนดให้ค่าที่ตัวแปรพอยเตอร์ p มึค่าเท่ากับ ค่าที่ตัวแปรพอยเตอร์ q ชี้ จากน้นจึงมีการเลื่อนตำแหน่งแอดเดรสของตัวแปรพอยเตอร์ทั้ง 2 ไปอีก 1 ช่วง ดังตัวอย่างต่อไปนี้ *p = *q; p++; q++; ในการเตรียมพื้นที่ตารางแบบไดนามิกให้ตัวแปรพอยเตอร์นั้นทำได้ดังนี้ กรณี C: int *ptr; Ptr = (int *)malloc(6* sizeof(int)); กรณี C++: int *ptr; ptr = new int[6]; ส่วนการคืนหน่วยความจำเมื่อสิ้นสุดการทำงานของโปรแกรมทำได้ดังนี้ ซึ่งต้องทำทุกครั้งเมื่อใช้คำสั่งออกจากโปรแกรม มิฉะนั้นเครื่องคอมพิวเตอร์ จะเกิดอาการค้าง (Hang) เมื่อปิดโปรแกรมเพราะไม่ได้คืนหน่วยความจำอย่างที่ควรจะทำ กรณี C: free(ptr); กรณี C++: delete[] ptr; ตัวแปรพอยเตอร์และการเรียกฟังก์ชัน การ เรียกฟังก์ชันมีหลายแบบ ได้แก่ 1) ฟังก์ชันที่ ไม่มีตัวแปรร่วมเป็นอาร์กิวเมนต์ และ ไม่คืนค่า (function with no parameter and no return value) ฟังกชันพวกนี้เพีบงแต่มีหน้าที่ทำงานอะไรบางอย่างตามที่ผู้เขียนโปรแกรมต้อง การ เช่นกรณีฟังก์ชัน void skip3(void) เพื่อการกระโดดไปครั้งละ 3 บรรทัดเป็นต้น 2) ฟังก์ชันที่มีตัวแปรร่วมแต่ไม่คืนค่า ฟังก์ชันนี้จะทำงานตามค่าที่ตัวแปรร่วมกำหนด เช่นกรณีฟังก์ชัน void skip(int num) ซึ่งจะกระโดดครั้งละกี่บรรทัดตามจำนวนที่กำหนดลงในตัวแปร num 3) ฟังก์ชันที่ไม่มีตัวแปรร่วมแต่มีการคืนค่า ฟังก์ชันนี้มักจะให้ผู้ใช้โปรแกรมป้อนข้อมูลให้ฟังก์ชันจัดการประมวลผล ก่อนที่จะคืนค่าออกมา เช่นกรณีฟังก์ชัน float input(void) ที่จะคืนค่าหลังจากผู้ใช้โปรแกรมได้ป้อนข้อมูลให้ตามที่ฟังก์ชันสั่งให้ทำ แล้ว 4) ฟังก์ชันที่มีตัวแปรร่วมและมีการ คืนค่า เช่นกรณีฟังก์ชัน float diff(float x, float y) ที่จะคืนค่าเป็นผลต่างระหว่างตัวแปร x และ ตัวแปร y ส่วนฟังก์ชันที่มีการใช้ตัวแปรร่วม นั้น มีวิธีการเรียกอยู่ 2 แบบคือ 1) กรณี เรียกตามค่า (Call by Value) กรณีนี้การเปลี่ยนค่าตัวแปรร่วมที่เกิดขึ้นในฟังก์ชัน จะไม่มีผลต่อ ค่าตัวแปรร่วมตั้งต้นดังตัวอย่างต่อไปนี้

void skipline(int num)
{
 int i ;
 for(i = 0 ; i <=num-1 ; i++)
 {
  printf(“n”);
}
num = 100;
}
void main(void)
{
 int num1 = 60;
 printf(“%d”,num1);
 skipline(num1) ;
}

กรณี เรียกตามค่านี้ ค่า num มีการเปลี่ยนแปลง แต่ไม่มีผลต่อค่า num1 ใน main function ตัวแปรร่วมในฟังก์ชันจะถือว่าเป็นกรณีเรียกตามค่า เมื่อการใช้ตัวแปรร่วมเป็นไปตามเงื่อนไขต่อไปนี้ • ตัวแปรร่วมนั้นแค่ส่งผ่านข้อมูลไปให้ฟังก์ชัน • ตัวแปรร่วมดังกล่าวจะไม่เป้นตัวแปรที่คืนค่าหลังสิ้นสุดการทำงานของฟังก์ชัน 2) กรณี เรียกตามการอ้างอิง (Call by Reference) ซึ่งต้องมีการเรียกใช้ตัวแปรพอยเตอร์กรณีนี้การเปลี่ยนค่าตัวแปรร่วมที่เกิด ขึ้นในฟังก์ชัน จะมีผลต่อ ค่าตัวแปรร่วมตั้งต้นดังตัวอย่างต่อไปนี้

void flip(int *x, int *y)
{
 int temp;
 temp = *x;
 *x = *y;
 *y = temp; 
}

ในการเรียกใช้ฟังก์ชัน flip นั้น จะต้องเรียกจาก แอดเดรสตัวแปร ดังนี้ flip(&a,&b) มีบางกรณีที่มีการ เรียกตามค่าและเรียกตามการอ้างอิงในฟังก์ชันเดียวกันเช่นการแก้สมการกำลัง 2

bool quardsolve(float a, float b, float c, float *root1, float *root2)
{
 float disc = (b*b) – (4*a*c);
 if(disc < 0.0)
 {
  return false;
} 
else
{
 *root1 = (-b + sqrt(disc))/(2*a);
 *root2 = (-b – sqrt(disc))/(2*a);
 return true;
}
}

ตัวแปรดัชนี root1 และ root2 ทำหน้าที่เป็นตัวแปรร่วม Output ที่เรียกโดยการใช้อ้างอิง (Call by Reference) และ ตัวแปร a b c เป็นตัวแปรร่วม Input ที่ใช้กับการเรียกตามค่า (Call by Value) ถ้า การแก้สมการกำลัง 2 มีคำตอบให้คืนค่าเป็น true และ ค่า root1 และ root2 เป็นจำนวนจริง มิฉะนั้นให้ฟังก์ชันคืนค่า false ออกมาแทน เนื่องจาก ค่า root1 และ root2 นั้นได้รับการประกาศให้เป็น ตัวแปรร่วมอ้างอิง (Reference parameter) มีผลทำให้ฟังก์ชันต้นแบบ (Function Prototype) มีลักษณะเป็น bool quardsolve(float, float, float, float *, float *) เมื่อเรียกใช้งานฟังก์ชัน quardsolve ให้เรียกใช้งานฟังก์ชันดังนี้ float x1, y1; float test = quardsolve(1.0,2.0,1.0,&x,&y); ซึ่งการเรียกใช้ฟังก์ชันดังกล้าวคล้ายคลึงกับการเรียกใช้คำสั่ง scanf int number; scanf(“%d”, &number); ตัวอย่างการเรียกใช้ฟังก์ชันที่มีตัวแปรพอยเตอร์จะแสดงให้เห็นดังตัวอย่าง ต่อไปนี้ 1) ฟังก์ชันที่ มี ตัวแปรพอยเตอร์ที่แสดงในภาพที่ 6.5 นั้น จะอยู่ที่ฟังก์ชัน cal_cum โดยในฟังก์ชัน cal_sum มี ตัวแปร a และ b เป็น ตัวแปร input ขณะที่ตัวแปรพอยเตอร์ *r เป็นตัวแปร output เวลาเรียกใช้งานฟังก์ชัน cal_sum ในฟังก์ชัน main จะเรียกใช้งานดังนี้ double num1 = 2.4, num2 = 1.2,result; cal_cum(num1,num2,&result); แอดเดรสของตัวแปร result (&result) จะมีค่าเท่ากับชื่อตัวแปรพอยเตอร์ แม้ว่าตัวแปร result จะไม่ใช่ตัวแปรพอยเตอร์ก็ตาม 2) ฟังก์ชันที่มี ตัวแปรพอยเตอร์ที่แสดงในภาพที่ 6.6 นั้น จะอยู่ที่ฟังก์ชัน order ซึ่งใช้ตัวแปรพอยเตอร์ เป็น input และ output ทั้งคู่ ฟังก์ชัน order จะทำหน้าที่ จากเล็กไปหาใหญ่ โดยที่ ถ้า ค่าที่ตัวแปรพอยเตอร์ *small ชี้ขนาดใหญ่กว่าค่าที่ตัวแปรพอยเตอร์ *big ชี้ ให้ลงมือสับตำแหน่งการชี้ค่า[[5537]]
หน้าที่ 8 – ตัวแปรสตริง
7. ตัวแปรสตริง (String) ตัวแปร string หรือแถวตารางอาเรย์ของตัวหนังสือนั้น ภาษา C ไม่มีกลไกที่จะสนับสนุนได้โดยตรง ถ้าต้องการให้ภาษา C สามารถรองรับข้อมูลที่เป็นตัวหนังสือแล้ว จะต้องมีการเตรียมพื้นที่หน่วยความจำให่เหมาะสมหรือการใช้สตริงค่าคงที่ (strong constant) ซึ่งจะทำให้โปรแกรมภาษา C เข้าถึงข้อมูลสตริงซึ่งจะเป็นทั้งข้อมูลที่เข้ามาในโปรแกรมและเปป็นข้อมูล ที่ออกจากโปรแกรมได้ โดยทั่วไปแล้วโปรแกรมภาษา C จะสนับสนุนข้อมูลที่เป็นอักษรโดยกำหนดให้อักษรแต่ละตัว ในรูปแบบตัวแปรประเภท char และข้อมูลสตริงนั้นโปรแกรมที่เขียนด้วยภาษา C จะถือว่าเป็นชุดข้อมูลตัวหนังสือที่เรียงกันตามลำดับ ขณะที่โปรแกรมที่เขียนด้วยภาษา C++ จะถือว่าสตริงเป็นตารางอาเรย์ข้อมูลประเภทตัวหนังสือ (Array of char) โดยตัวหนังสือจะอยู่ในตารางแต่ละช่อง และ ณ ตำแหน่งสิ้นสุดของตารางอาเรย์ที่เก็บตัวแปรสตริงนั้นจะมีสัญลักษณ์ “{PBODY}” (ตัวสิ้นสุดสตริง หรือ ตัว NULL) บรรจุอยู่ ดังนั้น ในการเตรียมเนื้อที่สำหรับตัวแปรสตริงที่ประกอบด้วยตัวหนังสือ n ตัวนั้นจะต้องเตรียมตารางไดนามิกขนาด n+1 ช่องเสมอ ดังตัวอย่างต่อไปนี้ 1) ตัวหนังสือ ‘a’ เป็นตัวแปร char จะใช้เนื้อที่ 1 ไบต์ แต่ “a” เป็นตัวแปร string แล้ว จะต้องใช้เนื้อที่ขนาด 2 ไบต์เพื่อจุตัวอักษร ‘a’ และ ตัวสิ้นสุดสตริง ({PBODY}) 2) ตัวแปรสตริงสามารถประกาศให้อยู่ในรูปตารางต่อไปนี้ได้ a. ตารางอาเรย์ตัวหนังสือ char String1[10] สามารถรองรับตัวหนังสือได้มากที่สุด 9 ตัว และ ตัวสิ้นสุดสตริง b. ตัวแปรพอยเตอร์ตัวหนังสือ char *String2 สามารถรองนับตัวหนังสือได้ตามที่ผู้เขียนโปรแกรมได้เตรียมเนื้อที่ตารางไดนา มิกส์ไว้ ถ้าต้องการทำอะไรกับตัวแปรสตริงแล้วให้เรียกใช้เฮดเดอร์ไฟล์ string.h ซึ่งเป็นไลบรารีไฟล์มาตรฐานสำหรับจัดการกับตัวแปรสตริง เราสามารถตั้งค่าเริ่มต้นให้ตัวแปรสตริงได้ 2 วิธีหลักคือ char S1[] = “Example”; ซึ่งภายในตัวแปรประกอบด้วย S1 |E|x|a|m|p|l|e|{PBODY}| ทั้งนี้เนื่องจากการเตรียมพื้นที่ขนาด 8 ช่องตาราง โดย 7 ช่องตารางแรกเก็บตัวหนังสือ และ ข้อมูลช่องสุดท้ายเก็บตัวสิ้นสุดสตริง char S2[20] = “Another Example”; ซึ่งภายในตัวแปรประกอบด้วย

S2            |A|n|o|t|h|e|r| |E|x|a|m|p|l|e|{PBODY}||?|?|?|?|

ทั้งนี้เนื่องจากการเตรียมพื้นที่ขนาด 20 ช่องตาราง แต่ใช้จริง 16 ช่อง คือตัวหนังสือ 15 ช่องและ ช่องที่ 16 เก็บตัวสิ้นสุดสตริง การตั้งต้นตัวแปรสตริง ดังตัวอย่างต่อไปนี้ถือว่าเป็นการตั้งต้นตัวแปรสตริงที่ถูกต้อง[[5538]]ดัง นั้น สิ่งที่เกี่ยวข้องสตริงสามารถสรุปออกมาได้ดังนี้ – ตัวแปรสตริงคือ ลำดับตัวหนังสือที่อยู่ภายในเครื่องหมายอัญประกาศ หรือเครื่องหมายคำพูด (“ ”) หรือ ตัวแปรสตริงคงที่ (String Constant) – อีกทางหนึ่งตัวแปรสตริงถือว่าเป็นตัวแปรตารางอาเรย์ ของตัวหนังสือ (Array of char) – สามารถใช้คำสั่ง printf scanf และ print ของภาษา C กับตัวแปรสตริงได้ – การประมวลเท็กซ์ คือการประมวลตัวแปรสตริง – หน่วยข้อมูลพื้นฐานของตัวแปรสตริงคือตัวหนังสือหรือ ชุดตัวหนังสือ ไมใช่ตัวเลข – การประยุกต์ใช้ตัวแปรสตริงนั้นคือ Word Processing หรือ Text Editor ตัวอย่างการใช้ตัวแปรสตริงจะแสดงให้เห็นดังนี้
#include void main() { char first[100], last[100]; int i; printf("nEnter your first name:"); scanf("%s", first ); printf("nEnter your last name:"); scanf("%s", last ); printf("nYour full name is: %s %sn", first, last ); printf("First name is: "); for( i=0; (i<100 && first[i] != '{PBODY}') ; i++ ){ printf("%c ",first[i]); } printf("nLast name is: "); for( i=0; (i<100 && last[i] != '{PBODY}') ; i++ ){ printf("%c ",last[i]); } printf("n"); }
ผลที่ได้การเขียนโปรแกรมเติมชื่อและนามสกุลจะแสดงให้เห็นในภาพที่ 7.1[[5539]]การใช้งานตัวแปรสตริงนั้นมีหลักการดังนี้ – เตรียมพื้นที่ตารางอาเรย์ให้ใหญ่พอรับตัวหนังสือแทนคำและ ตัวสิ้นสุดสตริงดังต่อไปนี้ char str1[6] = “Hello”; char str2[] = “Hello”; char *str3 = “Hello”; char str4[6] = {‘H’,’e’,’l’,’l’,’o’,’{PBODY}’}; ตัวแปรสตริงแต่ละตัวถือว่าเป็นตัวแปรคงที่ ดังนั้นจึง Assign ค่าแทนกันเช่นตัวอย่างต่อไปนี้ไม่ได้ Str1 = Str2; // ห้ามทำเช่นนี้กับตัวแปรสตริง เพราะมีวิธีอื่นที่ดีกว่านั้น ตัวอย่างต่อไปนี้แสดงให้เห็น วิธี Assign ตัวแปรสตริงโดยใช้ตัวแปรพอยเตอร์ เข้าช่วย char *S1 = “Hello”, *S2 = “Goodbye”; // ตัวแปร S1 และ S2 แก่ไขเปลี่ยนแปลงไม่ได้ char *S3; S3 = S1; // บังคับให้ S3 ชี้ไปที่ แอดเดรสของตัวแปรพอยเตอร์ S1 S3 = S2; // บังคับให้ S3 ชี้ไปที่ แอดเดรสของตัวแปรพอยเตอร์ S2 อีกตัวอย่างในการ Assign ตัวแปรสตริงสามารถแสดงให้เห็นดังนี้ char Str[6] = “Hello”; // ตั้งต้นตัวแปร Str ด้วยคำว่า Hellow char Str[0] = ‘Y’; char Str[4] = ‘{PBODY}’; // การแก้ไขให้ Str = “Yell” อย่างไรก็ตาม วิธีแก้ไขเปลี่ยนแปลงข้อมูลสตริงในตารางมีเงื่อนไขว่า – ตารางอาเรย์ที่ทำหน้าที่เป็นสตริงจะต้องปิดท้ายด้วย ‘{PBODY}’ เสมอ มิฉะนั้นตัวแปรอาเรย์ที่ทำหน้าที่เป็นสตริงจะไม่มีจุดสิ้นสุดสตริง – สตริงที่แก้ไขต้องมีขนาดน้อยกว่าขนาดของตารางอาเรย์ที่เก็บค่าสตริง การเปลี่ยนแปลงแก้ไขตัวแปรสตริงโดยใช้ไดนามิกอาเรย์นั้นต้องใช้ความระมัด ระวังเป็นอย่างยิ่ง เพราะตารางไดนามิกส์นั้นต้องเตรียมพื้นที่ให้ ตัวสิ้นสุดสตริง (NULL) มิฉะนั้นโปรแกรมจะพิมพ์ข้อมูลสตริงออกมาผิดไปจากที่ต้องการ ดังตัวอย่างต่อไปนี้
char *s; s = (char *)malloc(sizeof(char) * 0); // - WRONG, need to allocate 1 more space strcpy(s, "linux"); printf("%sn", s);
กรณีที่ใช้คำสั่ง strlen เพื่อหา ขนาดอาเรย์ก่อนทำ Dynamic allocation (malloc) นั้น พึงรับทราบว่า คำสั่ง strlen จะมีขนาดเพียงพอสำหรับตัวจำนวนอักษรที่ใช้ในตัวแปรสตริงเท่านั้น แต่ไม่ได้นับตัวแปร NULL ที่ใช้กำหนดจุดสิ้นสุดของสตริงด้วย โดยที่รายละเอียดเกี่ยวกับคำสั่ง strlen จะกล่าวถึงในตอนต่อไป การกำหนดค่าให้ตัวแปรสตริง (String Assignment) ตัวอย่างการกำหนดค่าให้ตัวแปรสตริง
char s[5]="SIIT"; // ใช้ได้, กำหนดค่าตัวแปรสตริงให้ตัวแปรอาเรย์ char dept[5], *d=dept; // ใช้ได้, กำหนดค่าตัวแปรสตริงให้ตัวแปรพอยเตอร์ char name[20]; name = “C. Sinthanayothin"; // ผิด อย่ากำหนดตัวแปรสตริงให้ตัวแปรอาเรย์ด้วยวิธีนี้ strcpy(name,“C. Sinthanayothin"); // ใช้ได้, ให้ก๊อปปี้ค่าสตริงโดยใช้คำสั่ง strcpy strcpy(dept,"IT"); // ใช้ได้, ก๊อปปี้ค่าสตริง ลงในตัวแปร dept printf("%s %s %sn",d,s,dept); // ใช้ได้, แสดงผลค่าสตริงด้ว printf d = strcpy(s,"EE"); // ใช้ได้, นี่คือการคืนค่าตัวแปรสตริง ลงใน ตัวแปร d ด้วยคำสั่ง strcpy printf("%s %s %s %sn",name,d,s,dept); char c1[30], c2[30]=“This is new c1 string”; char s[30] = "c programming "; char str1[30]; // วิธี้ทำให้ตัวแปร str1 ไม่เป็น l-value เพราะเป็น constant array char *str; // วิธี้ทำให้ตัวแปร str เป็น l-value เพราะเป็น ตัวแปรพอยเตอร์ strcpy(c1, c2); // ใช้ได้, ก๊อปปี้ข้อมูลใน c2 ลงใน c1 str = strcat(s,"is great!!"); // ใช้ได้, คือค่าเป็น ตัวแปรพอยเตอร์ประเภท char str1 = strcat(s,"is great!!"); // ผิด, ฟังก์ชัน strcat ตอ้งคืนค่าด้วยตัวแปรพอยเตอร์ประเภท char
ไม่ใช่ตารางอาเรย์ประเภท char
ข้อควรจำคือ: ต้องเตรียมพื้นที่หน่วยความจำไว้ให้พร้อมก่อนการกำหนดค่าให้ตัวแปรสตริงมิ ฉะนั้นอักษรบางตัวก็จะแหว่งหายไป ตัวแปรสตริงนั้นจะใช้ %s เป็นตัว place holder ขณะที่ใช้คำสั่ง sscanf ในการอ่านข้อมูลจำพวกสตริงแล้วจัดการแปลงข้อมูลให้อยู่รูปตามที่กำหนด ดังตัวอย่างต่อไปนี้
int sscanf( const char *buffer, const char *format [, argument ] ... ); char ch, int inum, float fnum; char buffer[100] = “A10 50.0”; sscanf(buffer,”%c%d%f”,&ch,&inum,&fnum); /* puts ‘A’ in ch, 10 in inum and 50.0 in fnum */ sscanf(" 85 96.2 hello","%d%.3lf%s",&num,&val,word); // results: num=85, val = 96.2, word = "hello"
ส่วน sprintf ใช้แสดงผลลัพธ์ที่อยู่ในรูปแบบต่างๆ ให้เป็นตัวแปรสตริงดังตัวอย่างต่อไปนี้
int sprintf( char *buffer, const char *format [, argument] ... ); char buffer[100]; sprintf(buffer,”%s, %s”,LastName,FirstName); if (strlen(buffer) > 15) printf(“Long name %s %sn”,FirstName,LastName);
ถ้าต้องการแปลงตัวเลขให้เป็นข้อมูลสตริงให้ใช้ฟังก์ชัน sprintf และ ตัวแปรดัชนี้ char ทำตามคำสั่งต่อไปนี้
int sscanf(char *buffer, const char *format [, argument ] ... ); char S[10]; int day, month,year; sprintf(S,”%d/%d/%d”, day, month, year); ถ้า day = 23, month = 8, year = 2001 ผลลัพธ์คือ S = “23/8/2001”
ต่อไปนี้คือตัวอย่างการใช้ sprintf กับ sscanf เมื่อเปรียบเทียบกับ printf
#include #include int main() { char s[30]="85 96.2 hello"; int num, mon=8,day=23,year=2001; double val; char word[10]; // can we use: char *word; // make sure your assign the proper address for pointer sscanf(" 85 96.2 hello","%d%lf%s",&num,&val,word); printf("num=%d val=%.3lf word=%sn",num,val,word); sprintf(s,"%d/%d/%d", mon, day, year); printf("s = %sn",s); return 0; }
ข้อทบทวน: ภาษาซี มีฟังก์ชันที่ใช้ดัดแปลงแก้ไขตัวแปรสตริง
หลายแบบตามความต้องการของผู้ใช้ได้แก่: strlen(str) –
คำนวณความยาวสตริง ซึ่งจะมีการนับไปเรื่อยๆ จนกว่าจะพบตัวแปร NULL ถึงจะหยุดโดยไม่มีการนับตัวแปร NULL
ที่สิ้นสุดประโยคเข้าไปด้วย ดังตัวอย่างต่อไปนี้ int strlen(char *str); char str1 = “hello”; strlen(str1)
จะคืนค่าออกเป็น 5 เพราะ มีอักษร 5 ตัว strcpy(dst,src) – ก็อปปี้ข้อมูลจากตัวแปรสตริง src พร้อมตัวสิ้นสุดสตริง NULL
ไปที่ตัวแปรสตริง dst แต่มีเงื่อนไขว่าตัวแปร des ต้องได้รับการเตรียมพื้นที่ให้ใหญ่พอๆกับตัวแปร src
และการเตรียมพื้นที่ ให้ ตัวแปร src และ ตัวแปร dst ต้องไม่ทับซ้อนกันมิฉะนั้นจะให้ผลที่คาดเดาไม่ได้
การประกาศใช้ฟังก์ชัน strcpy จะทำได้ดังนี้ char *strcpy(char *dst, char *src) strncpy(dst,src,n) –
ก็อปปี้ข้อมูลจากตัวแปรสตริง src โดยไม่ก๊อปปี้ตัวสิ้นสุดสตริง NULL
ไปที่ตัวแปรสตริง dst เนื่องจากมีจำนวนตัวอักษร n เป็นตัวจำกัดไว้
แต่มีเงื่อนไขว่าตัวแปร des ต้องได้รับการเตรียมพื้นที่ให้ใหญ่พอๆกับตัวแปร src และการเตรียมพื้นที่
ให้ ตัวแปร src และ ตัวแปร dst ต้องไม่ทับซ้อนกันมิฉะนั้นจะให้ผลที่คาดเดาไม่ได้ การประกาศใช้ฟังก์ชัน strncpy
จะทำได้ดังนี้ char *strncpy(char *dst, char *src, int n) strcmp(str1,str2) – เปรียบเทียบข้อมูลในตัวแปร str1
กับข้อมูลในตัวแปรสตริง str2 โดยใช้อักษรตัวแรกที่เริ่มต่างกันเป็นหลักซึ่งให้ผลดังนี้
น้อยกว่า 0 -- ถ้าค่า ASCII ที่เริ่มแตกต่างใน str1 มีขนาดเล็กกว่า str2 หรือ str1 เริ่มต้นเหมือนกับ str2 แต่ str2
นั้นมีตัวอักษรมากกว่า มากกว่า 0 -- ถ้าค่า ASCII ที่เริ่มแตกต่างใน str1 มีขนาดใหญ่กว่า str2 หรือ str1
เริ่มต้นเหมือนกับ str2
แต่ str1 นั้นมีตัวอักษรมากกว่า 0 ถ้าตัวแปรสตริงทั้ง 2 ตัวนั้นใช้ตัวอักษรเดียวกันและความยาวเท่ากัน
การประกาศใช้ฟังก์ชัน strcmp จะทำได้ดังตัวอย่างต่อไปนี้
int strcmp(char *str1, char *str2)
#include #include void main() { printf("%d n", strcmp("hello","hello")); // returns 0 printf("%d n", strcmp("yello","hello")); //returns value > 0 printf("%d n", strcmp("Hello","hello")); // returns value < 0 printf("%d n", strcmp("hello","hello there")); // returns value < 0 printf("%d n", strcmp("some diff","some dift")); //returns value<0 }
strncmp(str1,str2,n) – เปรียบเทียบข้อมูลในตัวแปร str1 กับข้อมูลในตัวแปรสตริง str2
เป็นจำนวนอักษร n ตัวโดยใช้อักษรตัวแรกที่เริ่มต่างกันเป็นหลัก และ
จะมีการเปรียบเทียบในกรณีที่อักษรในตัวแปรมีจำนวนน้อยกว่า n การประกาศใช้ฟังก์ชัน strncmp
จะทำได้ดังตัวอย่างต่อไปนี้ int strncmp(char *str1, char *str2,int n)
ความแตกต่างระหว่าง strcmp และ strncmp จะแสดงให้เห็นดังตัวอย่างต่อไปนี้
strcmp(“some diff”,”some DIFF”) -- returns value > 0 strncmp(“some diff”,”some DIFF”,4) -- returns 0 strcat(str1,str2) –
ใช้ในการนำข้อมูลในตัวแปร str2 ไปต่อท้ายตัวแปร str1 ซึ่งจะคืนค่าเป็น
str1 ที่ได้รับการต่อให้ยาวขึ้น ตัวอย่างเช่น
char *s1 = “C. “, *s3 = strcat(s1,“Sinthanayothin”); ผลลัพธ์: s1 = s3 = “C. Sinthanayothin”
การประกาศใช้ฟังก์ชัน strcat จะทำได้ดังตัวอย่างต่อไปนี้ char* strcat(char *s1, const char* s2);
strncat(str1,str2,n) –
ใช้ในการนำข้อมูลในตัวแปร str2 จำนวน n อักษรไปต่อท้ายตัวแปร str1 ซึ่งจะคืนค่าเป็น str1 ที่ได้รับการต่อให้ยาวขึ้น
ตัวอย่างเช่น
char s1[10] = "IT "; char *s3 = strncat(s1,"050Basic",3); printf("%s n", s1); printf("%s n", s3);
ผลลัพธ์: s1 = s3 = IT 050 การประกาศใช้ฟังก์ชัน
strncat จะทำได้ดังตัวอย่างต่อไปนี้
char* strncat(char *s1, const char* s2ม int n);
ฟังก์ชันเหล่านี้มีอยู่ในไลบรารีเฮดเดอร์ไฟล์ string.h ซึ่งต้องใช้คำสั่ง #include ถึงจะเรียกใช้ได้
เราสามารถสร้างตารางอาเรย์ให้ตัวแปรสตริง (Array of string) ดังตัวอย่างต่อไปนี้
char month[12][10] = {“January”, “February”, “March”, “April”, “May”, “June”, “July”, “August”, “September”, “October”, “
November”, “December” }; แต่ถ้าต้องการให้ตารางอาเรย์สำหรับตัวแปรสตริง สามารถรองรับข้อมูลสตริงที่มีความยาวต่างกัน
(Ragged array of string)
ให้ดังนี้ char *MonthNames[13]; /* an array of 13 strings */ MonthNames[1] = “January”;
/* String with 8 chars */ MonthNames[2] = “February”; /* String with 9 chars */ MonthNames[3] = “March”;
/* String with 6 chars */ … ตัวอย่างตารางอาเรย์ให้ตัวแปรสตริงแสดงวันทั้ง 7 แบบ Ragged array of string
จะแสดงให้เห็นในตัวอย่างต่อไปนี้
#include #include void main() { char *days[7]; char TheDay[10];int day; days[0] = "Sunday"; days[1] = "Monday"; days[2] = "Tuesday"; days[3] = "Wednesday"; days[4] = "Thursday"; days[5] = "Friday"; days[6] = "Saturday"; printf("Please enter a day: "); scanf("%9s",TheDay); day = 0; while ((day < 7) && (strcmp(TheDay,days[day]))) day++; if (day < 7) printf("%s is day %d.n",TheDay, day); else printf("No day %s!n",TheDay); }
ในการรับและส่งข้อมูลจำพวกสตริงนั้นทำได้หลายวิธี ได้แก่ 1) ในกรณีที่ใช้คำสั่ง printf และ scanf นั้นให้ใช้ %s
ในการอ่านข้อมูลและ แสดงข้อมูลสตริงออกมา 2) ใช้คำสั่ง gets ในการข้อมูลสตริงออกมาทีละบรรทัด ดังตัวอย่างต่อไปนี้
char name1[10], name2[30]; scanf(“%s”,name1); // Input: IT 050 gets(name2);
// Input: C Programming printf(“Course is %sn”,name); // Output: IT 050 printf(“Detail is %sn”,name2);
// C Programming
[[5540]]

การใช้งานคำสั่งกับตัวแปร อักษร (char operators)
นี่คือตัวอย่างการใช้งานฟังก์ชันที่คุมการรับส่งข้อมูลตัวอักษร char ch; ch = getchar(); // Input ch –
ใช้แทน scanf("%c",&ch); putchar(ch); // Output ch – ใช้แทน printf("Character is %cn",ch); ch = 'S';
// ใช้ได้ ตัวอย่างการกำหนดค่าตัวอักษรให้ตัวแปร char putchar(ch); // ผลที่ได้ออกมาคือ S putchar('T');
// ผลที่ได้ออกมาคือ T ฟังก์ชันที่ใช้กำหนดการทำงานให้ตัวแปร char ได้แก่ คำสั่ง: isalpha(ch);
การใช้งาน: คืนค่าเป็น TRUE (จริง) ถ้า ch มีค่าในช่วง A-Z หรือ a-z ตัวอย่าง: c = isalpha(ch);
// คืนค่า TRUE ถ้า ch=‘M’ และ คืนค่า FALSE ถ้า ch=‘5’ คำสั่ง: isdigit(ch);
การใช้งาน: คืนค่าเป็น TRUE (จริง) ถ้า ch มีค่าในช่วง0-9 ตัวอย่าง: d = isdigit(ch);
// คืนค่า FALSE ถ้า ch=‘M’ และคืนค่า TRUE ถ้า ch=‘5’ คำสั่ง: islower(ch);
การใช้งาน: คืนค่าเป็น TRUE (จริง) ถ้า ch มีค่าในช่วง a-z ตัวอย่าง: c = islower(ch);
// คืนค่า FALSE ถ้า ch=‘M’ return false, และคืนค่า TRUE ถ้า ch=‘m’ คำสั่ง: isupper(ch);
การใช้งาน: คืนค่าเป็น TRUE (จริง) ถ้า ch มีค่าในช่วง A-Z ตัวอย่าง: c = isupper(ch);
// คืนค่า TRUE ถ้า ch=‘M’ return false, และคืนค่า FALSE ถ้า ch=‘m’ คำสั่ง: isspace(ch);
การใช้งาน: คืนค่า TRUE ถ้า ch คิอช่องว่างขาว (space, newline, tab ) ตัวอย่าง: c = isspace(ch);
// คืนค่า TRUE ถ้า ch = ‘n’ คืนค่า FALSE ถ้า ch=‘m’ คำสั่ง: tolower(ch);
การใช้งาน: คืนค่าตัวพิมพ์เล็กจากค่าอักษรในตัวแปร ch ถ้าเป็นไปได้ ตัวอย่าง: c = tolower(ch);
// คืนค่า ‘m’ ให้ c ถ้า ch=‘M’ คำสั่ง: toupper(ch);
การใช้งาน: คืนค่าตัวพิมพ์ใหญ่จากค่าอักษรในตัวแปร ch ถ้าเป็นไปได้ คำสั่ง: c = toupper(ch);
// คืนค่า ‘M’ ให้ c ถ้า ch=‘m’ หน้าที่ 9 - โครงสร้างสตรักเจอร์ 8. โครงสร้างสตรักเจอร์ (Structure) สตรักเจอร์ เป็นวิธีการเก็บตัวแปรหลากชนิดให้อยู่เป็นกลุ่มก้อนเดียวกัน
ทำให้สามารถแยกโปรแกรมออกเป็นหน่วย (Modular Programming)
ซึ่งแก้ไขได้ง่ายเพราะสามารถแยกฟังก์ชันและตัวแปรออกเป็นหน่วยๆ ซึ่งก็เป็นประโยชน์ในการสร้างฐานข้อมูลด้วย
การตั้งต้นสร้างสตรักเจอร์ สามารถทำได้หลายรูปแบบดังตัวอย่างต่อไปนี้
1) การใช้ คำสั่ง struct สร้างตัวแปรชนิด student_a ผ่านตัวแปร student struct student
{ char *first; char *last; char SSN[9]; float gpa; char **classes; };
struct student student_a; 2) การใช้ คำสั่ง struct สร้างตัวแปรชนิด student_a โดยตรง struct
{ char *first; char *last; char SSN[10]; float gpa; char **classes; } student_a;
3) การใช้ คำสั่ง typedef struct เพื่อสร้างตัวแปรชนิด student_a ผ่านตัวแปร student typedef struct
{ char *first; char *last; char SSN[9]; float gpa; char **classes; } student; student student_a;
การกำหนดชนิดตัวแปร ทำได้โดยใช้คำสั่ง typedef ตามหลักการใช้งานดังนี้ typedef type name
(typedef ชื่อของชนิดตัวแปร ชื่อที่ใช้เรียกชนิดตัวแปรจริง) ตัวอย่าง:
typedef int INTEGER; INTEGER x; /* x คือตัวแปรตระกูล INTEGER */ typedef char *STRING; STRING sarray[10]; /* sarray คือตารางอาเรย์ ของ char* ซึ่งเทียบได้กับการประกาศว่า char *sarray[10] */
ในโครงสร้างตัวแปรที่อยู่ในรูป structure นั้นประกอบด้วยตัวแปรที่เกี่ยวข้องในลักษณะเดียวกับตารางอาเรย์
แม้จะไม่ใช้ตัวแปรประเภทเดียวกัน โดยจะแบ่งตัวแปรออกเป็น field โดยที่กลุ่มตัวแปรใน structure
จะถือว่าเป็นส่วนหนึ่งของหน่วยใหญ่หน่วยเดียวกันดังที่แสดงในภาพที่ 8.1 ส่วนการเปรียบเทียบความแตกต่างระหว่าง
ตารางอาเรย์และตัวแปร struct ที่มีตัวแปรที่เป็นตารางอาเรย์ จะแสดงให้เห็นในภาพที่ 8.2
[[5542]]
การเรียกใช้งาน สตรักเจอร์ โดยปกติการสร้างสตรักเจอร์ ทำได้โดยใช้คำสั่ง typedef และ struct
ซึ่งโครงสร้างภายในของสตรักเจอร์ จะประกอบด้วยตัวแปรต่างๆ ซึ่งแยกออกเป็น field ตัวแปรชนิดต่างๆ
และในแต่ละ field จะมีการกำหนดพื้นที่หน่วยความจำ จนเพียงพอสำหรับแต่ละ field ดังตัวอย่างต่อไปนี้
typedef struct { Type1 FieldName1; Type2 FieldName2; Type3 FieldName3; /* as needed */ } VarName;
VarName คือชื่อชนิดตัวแปรสตรักเจอร์ทั้งหมด
นี่คือตัวอย่างการประกาศใช้ตัวแปร struct ชนิด student_t เพื่อบันทึกข้อมูลนักเรียน
พร้อมตัวอย่างการกำหนดตัวแปร ชนิด student_t ซึ่งสามารถทำได้อย่างตัวแปรทั่วไป เช่นเดียวกับ int float
#define MAX_LEN 12 /* Length of name */ typedef struct { char name[MAX_LEN]; int id; float gpa; char major[10]; } student_t; student_t s; student_t stu1, stu2, stu3;
การเข้าถึง ตัวแปร field ภายในตัวแปร struct ทำได้โดยการใช้ จุด (.)
แล้วตามด้วยชื่อ field ดังตัวอย่างกรณีการเข้าถึงตัวแปร
ชนิด DATE ที่จะแสดงให้เห็นดังต่อไปนี้ และผลที่ได้จะแสดงให้เห็นในภาพที่
8.3 หลักการเข้าถึงตัวแปร struct: VarName.FieldName typedef struct
{ int month, day, year; } DATE; void main() { DATE d1; d1.month = 12; d1.day = 2; d1.year = 1970; }

* ที่มาจากหนังสือ : ผศ.สมชาย รัตนเลิศนุสรณ์ . การเขียนโปรแกรมคอมพิวเตอร์ด้วยภาษาซี. กรุงเทพฯ , 2545.

การเขียนโปรแกรมภาษา C เบื้องต้น (Introduction to C Programming)

วันพฤหัสบดีที่ 28 สิงหาคม พ.ศ. 2557

หลักการเขียนภาษา C เบื้องต้น ให้เข้าใจ

ต้องเข้าใจโครงสร้าง (Structure) ของภาษา C

ฟังก์ชันสตริง

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

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

คำอธิบายโปรแกรม

คำอธิบายโปรแกรม

คำอธิบายโปรแกรม

เริ่มต้นกับภาษา c

1. บทนำเกี่ยวกับภาษาซีที่นำมาใช้ในหลักสูตรการเขียนโปรแกรม

กฎในการเขียนภาษา C

การเขียนโปรแกรมภาษา C

พื้นฐานโปรแกรมภาษา C

จำนวนการดูหน้าเว็บรวม

จำนวนการดูหน้าเว็บรวม