ฟั้งชันพื้นฐานการเขียนภาษาซี

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

3.1 ฟังก์ชันรับข้อมูล  (input functions)
            ในเนื้อหาฟังก์ชันการับข้อมูลของภาษา  C  มีฟังก์ชันที่ใช้ในการรับข้อมูลจากคีย์บอร์ด  อยู่หลายฟังก์ชันที่จะกล่าวถึง  ดังนี้คือ ฟังก์ชัน  scanf( ), ฟังก์ชัน  getchar( ), ฟังก์ชัน  getch( ), ฟังก์ชัน  getche( )  และฟังก์ชัน  gets( )  ซึ่งแต่ละฟังก์ชันมีรายละเอียดของการใช้งานดังนี้
            3.1.1 ฟังก์ชัน  scanf( )
                        เป็นฟังก์ชันที่ใช้ในการรับข้อมูล จากคีย์บอร์ดเข้าไปเก็บไว้ในตัวแปรที่กำหนดไว ้โดยสามารถรับข้อมูลที่เป็นตัวเลขจำนวนเต็ม  ตัวเลขทศนิยม  ตัวอักขระตัวเดียว หรือข้อความก็ได
้            รูปแบบการใช้งานฟังก์ชัน

scanf(control  string, argument  list);

            โดยที่
                        control  string  คือ  รหัสรูปแบบข้อมูล (format code)  โดยจะต้องเขียนอยู่ภายใต้เครื่องหมาย  “……..”  (double  quotation)
                        argument list คือ  ชื่อตัวแปรที่ใช้เก็บข้อมูลโดยจะต้องใช้เครื่องหมาย  &  (ampersand)  นำหน้าชื่อตัวแปร  ยกเว้นตัวแปรชนิด  string  ไม่ต้องมีเครื่องหมาย  &  นำหน้าชื่อ  ถ้ามีตัวแปรมากกว่า  1  ตัวแปร  ให้ใช้เครื่องหมาย  ,  (comma)  คั่นระหว่างตัวแปรแต่ละตัว

ตารางที่  3.1  แสดงรหัสแบบข้อมูล  ที่สามารถใช้ในฟังก์ชัน  scanf( )

รหัสรูปแบบ (format  code)	ความหมาย
%c	ใช้กับข้อมูลชนิดตัวอักขระตัวเดียว  (single  character :  char)
%d	ใช้กับข้อมูลชนิดตัวเลขจำนวนเต็ม (integer : int)  โดยสามารถใช้กับตัวเลขฐาน  10  เท่านั้น
%e	ใช้กับข้อมูลชนิดตัวเลขจุดทศนิยม  (floating  point : float)
%f, %lf	ใช้กับข้อมูลชนิด  float  และ  double  ตามลำดับ
%g	ใช้กับข้อมูลชนิด  float
%h	ใช้กับข้อมูลชนิด  short  integer
%l	ใช้กับข้อมูลชนิด  int  โดยใช้กับตัวเลขฐาน 8, ฐาน 10 และฐาน 16
%o	ใช้กับข้อมูลชนิด  int  โดยสามารถใช้กับตัวเลขฐาน  8  เท่านั้น
%u	ใช้กับข้อมูลชนิด  unsigned  int  โดยใช้กับตัวเลขฐาน  10  เท่านั้น
%x	ใช้กับข้อมูลชนิด  int  โดยสามารถใช้กับตัวเลขฐาน  16  เท่านั้น
%s	ใช้กับข้อมูลชนิด  string

ที่มา  :  Gottfried, S. Byron, 1990 : 481.
            เพื่อให้เกิดความเข้าใจการใช้งานฟังก์ชัน  scanf( )  ได้ดียิ่งขึ้นควรศึกษาโปรแกรมตัวอย่างที่  3.1, 3.2  และ  3.3  ดังต่อไปนี้
โปรแกรมตัวอย่างที่  3.1  แสดงโปรแกรมการใช้ฟังก์ชัน  scanf( )  ในการรับข้อมูลจากคีย์บอร์ดเข้าไปเก็บไว้ในตัวแปรชนิดจำนวนเต็ม

	/*          scanf1.c             */                                              #include<stdio.h>                                                       /*  บรรทัดที่  1  */ void main(void)                                                            /*  บรรทัดที่  2  */ {                                                                                   /*  บรรทัดที่  3  */       int  a;                                                                             /*  บรรทัดที่  4  */       scanf("%d", &a);                                                           /*  บรรทัดที่  5  */ }                                                                                   /*  บรรทัดที่  6  */

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

บรรทัดที่  1  เป็นคำสั่งเรียกแฟ้มที่ชื่อว่า  stdio.h  ซึ่งภายในจะบรรจุคำสั่งหรือฟังก์ชันที่จำเป็นต้องใช้ในภาษา  C  เช่น  printf( )
บรรทัดที่  2  เป็นฟังก์ชันหลักของโปรแกรม  และบอกให้  C compiler  รู้ว่าฟังก์ชัน 
main( )  ไม่มีการส่งค่าข้อมูลและไม่มีการรับค่าข้อมูลกลับ
บรรทัดที่  3  เป็นการแสดงจุดเริ่มต้นของฟังก์ชัน  main( )
บรรทัดที่  4  เป็นการประกาศตัวแปรชื่อ  a  เป็นชนิดจำนวนเต็ม  หรือ  int
บรรทัดที่  5  ฟังก์ชัน  scanf( )  เพื่อรอรับข้อมูลจากคีย์บอร์ดเข้าไปเก็บไว้ในตัวแปร  a  ซึ่งเป็นชนิดจำนวนเต็ม
บรรทัดที่  6  เป็นการแสดงจุดสิ้นสุดของฟังก์ชัน  main( )

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

	/*          scanf2.c             */ #include<stdio.h>                                                                           /*  บรรทัดที่  1  */    void main(void)                                                                                 /*  บรรทัดที่  2  */ {                                                                                                          /*  บรรทัดที่  3  */       int  a;                                                                                    /*  บรรทัดที่  4  */       scanf("%d", &a);                                                                 /*  บรรทัดที่  5  */       printf("Your enter is ...%d", a);                                         /*  บรรทัดที่  6  */ }                                                                                                          /*  บรรทัดที่  7  */

  

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

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

คำอธิบายโปรแกรม
            ในโปรแกรมตัวอย่างที่  3.2  โปรแกรมจะรับข้อมูลจากคีย์บอร์ด ที่เป็นชนิดจำนวนเต็มเก็บไว้ในตัวแปร และนำค่าของตัวแปรแสดงผลออกจอภาพ  ด้วยคำสั่งบรรทัดที่  6  คือ  printf(“Your enter is…%d”, a);  สำหรับฟังก์ชัน  printf( )  ผู้ใช้สามารถศึกษารายละเอียดเพิ่มเติมก่อนได้ในหัวข้อ  3.2.1 
โปรแกรมตัวอย่างที่  3.3  แสดงโปรแกรมการใช้ฟังก์ชัน  scanf( )  ในการรับข้อมูลจากคีย์บอร์ดเข้าไปเก็บไว้ในตัวแปรชนิดตัวอักษร  เลขจำนวนเต็ม  และเลขทศนิยม  และนำค่าของตัวแปรออกแสดงผลที่จอภาพ

	/*          scanf3.c             */ #include<stdio.h>                                                                           /*  บรรทัดที่  1  */ #include<conio.h>                                                                          /*  บรรทัดที่  2  */ void main(void)                                                                                 /*  บรรทัดที่  3  */ {    char name[50];                                                                         /*  บรรทัดที่  4  */       int  age;                                                                               /*  บรรทัดที่  5  */       float weight, height;                                                          /*  บรรทัดที่  6  */       clrscr( );                                                                               /*  บรรทัดที่  7  */       printf("Enter your Name and Age: ");                              /*  บรรทัดที่  8  */       scanf("%s %d", name, &age);                                         /*  บรรทัดที่  9  */       printf("Enter your Weight and Height : ");                      /*  บรรทัดที่  10 */       scanf("%f %f", &weight, &height);                                   /*  บรรทัดที่  10 */       printf("\nYour name is ...%s.\n",name);                          /*  บรรทัดที่  11 */       printf("You  are %d years old.\n",age);                          /*  บรรทัดที่  13 */       printf("Your weight is ...%f cm.\n",weight);                    /*  บรรทัดที่  14 */       printf("Your height is ...%f cm.\n",height);                     /*  บรรทัดที่  15 */ }                                                                                           /*  บรรทัดที่  16 */

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

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

บรรทัดที่  4  เป็นการชุดชนิด  char  ซึ่งจองไว้  50  ตัวอักษร  (เรื่องตัวแปรชุดได้อธิบายรายละเอียดไว้ในบทที่  5)
บรรทัดที่  7  ฟังก์ชัน  clrscr( )  ใช้ลบข้อความใด ๆ  ออกจากจอภาพ  ซึ่งจะเรียกใช้งานควบคู่กับแฟ้มที่ชื่อ  conio.h  ดังนั้นก่อนฟังก์ชัน  main( )  จึงต้องเรียกใช้  #include <conio.h>  ก่อน  (บรรทัดที่  2)
บรรทัดที่  8  จะแสดงข้อความและรอรับค่า  Name  และ  Age  จากผู้ใช้  ดังนั้นเวลาเติมข้อมูลให้เว้นช่องว่างอย่างน้อย  1  ช่อง  เพื่อแยกข้อมูล  Name  กับ  Age 
บรรทัดที่  9  จะรับข้อมูลจากคีย์บอร์ด  2  ค่า  มาเก็บไว้ในตัวแปร  name  เป็นข้อความ  และเก็บในตัวแปร  age  เป็นตัวเลขจำนวนเต็ม
บรรทัดที่  10  จะทำงานคล้ายกับบรรทัดที่  8  แต่จะรับข้อมูลที่เป็นตัวเลขทศนิยม
บรรทัดที่  11 – 15  จะนำข้อมูลที่เก็บไว้ในตัวแปรต่าง ๆ  ออกมาแสดงผลที่จอภาพตามรหัสรูปแบบข้อมูลต่าง ๆ

            3.1.2 ฟังก์ชัน  getchar( )

                        เป็นฟังก์ชันที่ใช้รับข้อมูลจากคีย์บอร์ดเพียง  1  ตัวอักขระ  โดยการรับข้อมูลของฟังก์ชันนี้จะต้องกดแป้น  enter  ทุกครั้งที่ป้อนข้อมูลเสร็จ  จึงทำให้เห็นข้อมูลที่ป้อนปรากฏบนจอภาพด้วย  ถ้าต้องการนำข้อมูลที่ป้อนผ่านทางคีย์บอร์ดไปใช้งาน  จะต้องกำหนดตัวแปรชนิด  single  character  (char)  ขึ้นมา  1  ตัว  เพื่อเก็บค่าข้อมูลที่รับผ่านทางคีย์บอร์ด  ในทางตรงกันข้ามถ้าไม่ต้องการใช้ข้อมูลที่ป้อนผ่านทางคีย์บอร์ดก็ไม่ต้องกำหนดตัวแปรชนิด  char  ขึ้นมา           
           
            รูปแบบการใช้งานฟังก์ชัน

getchar( ); หรือ         char_var = getchar( );

     
            โดยที่

getchar( )  คือ  ฟังก์ชันที่ใช้รับข้อมูลเพียง  1  ตัวอักขระจากคีย์บอร์ด  โดยฟังก์ชันนี้จะไม่มี  argument ซึ่งอาจจะใช้ getchar(void) แทนคำว่า getchar( ) ก็ได้ แต่นิยมใช้ getchar( ) มากกว่า 
char_var  คือ  ตัวแปรชนิด  char  ซึ่งจะเก็บข้อมูล  1  ตัวอักขระที่ป้อนผ่านทางคีย์บอร์ด

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

	/*          getchar1.c          */ #include<stdio.h>                                                                           /*  บรรทัดที่  1  */ #include<conio.h>                                                                          /*  บรรทัดที่  2  */ void main(void)                                                                                 /*  บรรทัดที่  3  */ {                                                                                                           /*  บรรทัดที่  4  */       char  cha;                                                                              /*  บรรทัดที่  5  */       clrscr( );                                                                                 /*  บรรทัดที่  6  */       printf("Enter a single character : ");                                  /*  บรรทัดที่  7  */       cha = getchar( );                                                                 /*  บรรทัดที่  8  */       printf("You type a character is ...%c \n",cha); /*  บรรทัดที่  9  */ }                                                                                                           /*  บรรทัดที่  10 */

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

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

บรรทัดที่  1  เรียกใช้แฟ้มที่ชื่อ  stdio.h  ซึ่งในโปรแกรมนี้จะใช้คู่กับฟังก์ชัน  printf( )  ในบรรทัดที่  7  และ  9 
บรรทัดที่  2  เรียกใช้แฟ้มที่ชื่อ  conio.h  ซึ่งใช้คู่กับฟังก์ชัน  clrscr( )  เพื่อลบข้อมูลที่จอภาพในบรรทัดที่  6 
บรรทัดที่  5  ประกาศตัวแปรชื่อ  cha  เป็นชนิดตัวอักขระ  หรือ  char
บรรทัดที่  8  รับข้อมูล 1 ตัวอักขระจากคีย์บอร์ด  แล้วนำค่าที่รับมาเก็บไว้ในตัวแปร  cha
บรรทัดที่  9  นำข้อมูลที่เก็บในตัวแปร  cha  มาแสดงตรงตำแหน่ง  %c  และขึ้นบรรทัดใหม่  (\n  คือ  new  line)

            3.1.3 ฟังก์ชัน  getch( )

                        เป็นฟังก์ชันที่ใช้รับข้อมูลเพียง  1 ตัวอักขระเหมือนกับฟังก์ชัน getchar( )  แตกต่างกันตรงที่เมื่อใช้ฟังก์ชันนี้รับข้อมูล  ข้อมูลที่ป้อนเข้าไปจะไม่ปรากฏให้เห็นบนจอภาพและไม่ต้องกดแป้น  enter  ตาม 
            รูปแบบการใช้งานฟังก์ชัน

getch( ); หรือ         char_var = getch( );

     
            โดยที่

getch( )  คือ ฟังก์ชันที่ใช้รับข้อมูลเพียง  1  ตัวอักขระจากคีย์บอร์ด  โดยฟังก์ชันนี้จะไม่มี  argument  ดังนั้นอาจจะใช้  getch(void)  แทนคำว่า  getch( )  ก็ได้  แต่นิยมใช้  getch( )  มากกว่า
char_var  คือ  ตัวแปรชนิด  char  ซึ่งจะเก็บข้อมูล  1  ตัวอักขระที่ป้อนผ่านทางคีย์บอร์ด

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

	/*          getch1.c            */ #include<stdio.h>                                                                           /*  บรรทัดที่  1  */ #include<conio.h>                                                                          /*  บรรทัดที่  2  */ void main(void)                                                                                 /*  บรรทัดที่  3  */ {                                                                                                           /*  บรรทัดที่  4  */       char  ch;                                                                                /*  บรรทัดที่  5  */       clrscr( );                                                                                 /*  บรรทัดที่  6  */       printf("Enter a single character : ");                                  /*  บรรทัดที่  7  */       ch = getch( );                                                                       /*  บรรทัดที่  8  */       printf("\nYou type a character is ...%c \n",ch);                /*  บรรทัดที่  9  */       getch( );                                                                                 /*  บรรทัดที่  10 */ }

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

 

คำอธิบายโปรแกรม
            การทำงานของโปรแกรมตัวอย่างที่  3.5  จะคล้ายกับโปรแกรมตัวอย่างที่  3.4  ต่างกันตรงคำสั่งบรรทัดที่  8  จะเป็นการใช้ฟังก์ชัน   getch( )  คือ  ch = getch( );  ให้นำค่าที่รับมาเก็บไว้ในตัวแปร  ch  ซึ่งเวลาเรารับข้อมูลจากคีย์บอร์ดจะไม่ปรากฎข้อมูลที่เราป้อนเข้าไปให้เห็นบนจอภาพ  และไม่ต้องกด  enter  ตาม  โปรแกรมก็จะไปทำงานคำสั่งบรรทัดที่  9  คือ  นำข้อมูลที่เก็บในตัวแปร  ch  มาแสดงตรงตำแหน่ง  %c  และขึ้นบรรทัดใหม่  ส่วนคำสั่งบรรทัดที่  10  ฟังก์ชัน  getche( );  โปรแกรมก็จะหยุดรอรับค่าใด ๆ  จากคีย์บอร์ด  เช่น  เรากด  enter  ก็จะกลับเข้าสู่โปรแกรม
            3.1.4 ฟังก์ชัน  getche( )

                        เป็นฟังก์ชันที่ใช้รับข้อมูลจากคีย์บอร์ดเพียง  1 ตัวอักขระ เหมือนฟังก์ชัน getch( )  แตกต่างกันตรงที่ข้อมูลที่ป้อนเข้าไป จะปรากฏให้เห็นบนจอภาพด้วย  นอกนั้นมีการทำงาน และลักษณะการใช้งานเหมือนฟังก์ชัน  getch( )  ทุกประการ
รูปแบบการใช้งานฟังก์ชัน

getche( ); หรือ         char_var = getche( );

     
            โดยที่

getche( )  คือ ฟังก์ชันที่ใช้รับข้อมูลเพียง  1  ตัวอักขระจากคีย์บอร์ด  โดยฟังก์ชันนี้จะไม่มี  argument  ดังนั้นอาจจะใช้  getche(void)  แทนคำว่า  getche( )  ก็ได้  แต่นิยมใช้  getche( )  มากกว่า
char_var  คือ  ตัวแปรชนิด  char  ซึ่งจะเก็บข้อมูล  1  ตัวอักขระที่ป้อนผ่านทางคีย์บอร์ด

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

	/*          getche1.c           */ #include<stdio.h>                                                                           /*  บรรทัดที่  1  */ #include<conio.h>                                                                          /*  บรรทัดที่  2  */ void main(void)                                                                                 /*  บรรทัดที่  3  */ {                                                                                                           /*  บรรทัดที่  4  */       char  e;                                                                                  /*  บรรทัดที่  5  */       clrscr( );                                                                                 /*  บรรทัดที่  6  */       printf("Enter a single character : ");                                  /*  บรรทัดที่  7  */       e = getche( );                                                                       /*  บรรทัดที่  8  */       printf("\nYou type a character is ...%c \n",e);                  /*  บรรทัดที่  9  */       getch( );                                                                                 /*  บรรทัดที่  10 */ }                                                                                                           /*  บรรทัดที่  11 */

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

 

คำอธิบายโปรแกรม
            การทำงานของโปรแกรมตัวอย่างที่  3.6  จะคล้ายกับโปรแกรมตัวอย่างที่  3.5  ต่างกันตรงคำสั่งบรรทัดที่  8  จะเป็นการใช้งานฟังก์ชัน  getche( )  คือ  e = getche( );  คำสั่งนี้ให้นำค่าที่รับมาเก็บไว้ในตัวแปร  e  ซึ่งข้อมูลที่เติมเข้าไปจะปรากฎให้เห็นบนจอภาพด้วย  แต่ไม่ต้องกด  enter  ตาม  โปรแกรมก็จะไปทำงานคำสั่งบรรทัดที่  9  คือ  นำข้อมูลที่เก็บในตัวแปร  e  มาแสดงตรงตำแหน่ง  %c  และขึ้นบรรทัดใหม่  ส่วนคำสั่งบรรทัดที่  10  getch( );  โปรแกรมก็จะหยุดรอรับค่าใด ๆ  จากคีย์บอร์ด  เช่น  เรากด  enter  ก็จะกลับเข้าสู่โปรแกรม 
            3.1.5 ฟังก์ชัน  gets( )

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

gets(string_var);

    
            โดย

string_var  คือ  ตัวแปรสตริง  ซึ่งจะใช้เก็บข้อมูลชนิดข้อความ  (string  constant)
gets( )       คือ  ฟังก์ชันที่ใช้รับข้อความจากคีย์บอร์ด  แล้วไปเก็บไว้ในตัวแปรสตริง

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

	/*          gets1.c              / #include<stdio.h>                                                                           /*  บรรทัดที่  1  */ #include<conio.h>                                                                          /*  บรรทัดที่  2  */ void main(void)                                                                                 /*  บรรทัดที่  3  */ {                                                                                                         /*  บรรทัดที่  4  */       char pro[50];                                                                        /*  บรรทัดที่  5  */       clrscr( );                                                                                 /*  บรรทัดที่  6  */       printf("Enter your province : ");                                           /*  บรรทัดที่  7  */       gets(pro);                                                                              /*  บรรทัดที่  8  */       printf("Your province is ...%s\n", pro);                              /*  บรรทัดที่  9  */       getch( );                                                                                 /*  บรรทัดที่  10 */ }                                                                                                         /*  บรรทัดที่  11 */

  

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

คำอธิบายโปรแกรม
            โปรแกรมตัวอย่างที่  3.7  เป็นโปรแกรมที่รอรับการเติมชื่อจังหวัด  แล้วนำไปเก็บไว้ในตัวแปร  pro  ด้วยคำสั่งบรรทัดที่  8  คือ  gets(pro);  แล้วนำค่าที่เก็บไว้ในตัวแปร  pro  ออกมาแสดงตรงตำแหน่ง   %s   และขึ้นบรรทัดใหม่   ส่วนคำสั่งบรรทัดที่  10  getch( );  โปรแกรมก็จะหยุดรอรับค่าใด ๆ  จากคีย์บอร์ด  เช่น  เรากด  enter  ก็จะกลับเข้าสู่โปรแกรม   
          สรุปข้อแนะนำการใช้ฟังก์ชันรับข้อมูล  (input  functions)

• เมื่อต้องการรับค่าข้อมูล  string  ควรใช้ฟังก์ชัน  gets( )  หรือ  scanf( )
• เมื่อต้องการรับตัวเลขหรือตัวอักษรเพียง  1  ตัว  ที่ไม่ต้องการเห็นบนจอภาพ  และไม่ต้องกดแป้น  enter  ควรใช้ฟังก์ชัน  getch( ) แต่ถ้าต้องการเห็นบนจอภาพด้วยควรใช้ฟังก์ชัน  getche( )
• เมื่อต้องการรับข้อมูลตัวเลขที่มากกว่า  1  ตัว  เช่น  ตัวเลขจำนวนเต็มหรือตัวเลขทศนิยม  ควรใช้ฟังก์ชัน  scanf( )
• กรณีที่ใช้ฟังก์ชัน  scanf( )  รับข้อมูลติดต่อกันมากกว่า  2  ครั้ง  อาจเกิดความผิดพลาดในการรับข้อมูล  ดังนั้นจึงควรใช้คำสั่ง  ch = getchar( );  คั่นก่อนที่จะรับข้อมูลครั้งที่  3  โดยจะต้องมีคำสั่งประกาศตัวแปร  char  ch;  ไว้ด้วย

สาระสำคัญ
รูปแบบการเขียนโปรแกรมภาษาเบสิก เครื่องหมายในการเขียนโปรแกรมเบื้องต้น ประเภทของคำสั่งในภาษาเบสิก

จุดประสงค์ปลายทาง
เข้าใจรูปแบบ ประเภทคำสั่งและเครื่องหมายที่ใช้ในการเขียนโปรแกรมได้
จุดประสงค์นำทาง
1. อธิบายรูปแบบของคำสั่งในการเขียนโปรแกรมได้
2. อธิบายวิธีการและคำสั่งการเขียนโปรแกรมได้
3. นักเรียนสามารถเลือกใช้คำสั่งในการเขียนโปรแกรมได้ถูกต้อง
เนื้อหา
โปรแกรมภาษาเบสิก จัดเป็นภาษาโปรแกรมระดับสูง แต่เป็นภาษาที่มีเทคนิควิธีการและรูปแบบการเขียนโปรแกรมที่ง่ายไม่ซับซ้อน จึงเหมาะสำหรับผู้เริ่มต้นเขียนโปรแกรม ซึ่งองค์ประกอบในการเขียนโปรแกรมจะประกอบด้วย
1. ค่าคงที่ (Constants)
2. ตัวแปร (Variable)
3. นิพจน์ (Expression)
แต่องค์ประกอบของโปรแกรมที่สำคัญยังต้องประกอบไปด้วย รูปแบบในการเขียนโปรแกรมและคำสั่ง เฉพาะสำหรับการเขียนโปรแกรมแต่ละภาษา ซึ่งรูปแบบและคำสั่งของโปรแกรมภาษาเบสิกก็จะมีรูปแบบเฉพาะเป็นของตนเองเช่นกัน
รูปแบบการเขียนโปรแกรมภาษาเบสิก
การเขียนโปรแกรมภาษาเบสิกจะมีรูปแบบเป็นของตนเอง ซึ่งมีลักษณะค่อนข้างง่ายต่อการเข้าใจ เนื่องจากลักษณะการใช้ตัวอักษรและอักขระที่ผู้อ่านสามารถเข้าใจการทำงานของโปรแกรมได้ รูปแบบการเขียนได้แก่
1. การเขียนโปรแกรมแบบมีหมายเลขบรรทัด (Line Number) ใช้หมายเลขสำหรับกำหนดลำดับของคำสั่ง โดยใช้หมายเลขกำกับหน้าคำสั่งในแต่ละบรรทัด เช่น
10 LET A = 10
20 LET B = 5
30 LET C = A+B
2. สำหรับการพิมพ์บรรทัด จะพิมพ์บรรทัดใดก่อนก็ได้ เครื่องจะทำงานเรียงหมายเลขบรรทัดจากน้อยไปหาหมายเลขบรรทัดมาก ในกรณีหมายเลขซ้ำกันโปรแกรมจะถือเอาคำสั่งในหมายเลขที่พิมพ์หลังสุด
3. การทำงานของโปรแกรมจะทำงานตามหมายเลขบรรทัด โดยจะทำงานจากหมายเลขบรรทัดน้อยไปหามาก
4. กรณีที่กำหนดหมายเลขบรรทัดในโปรแกรม จะต้องกำหนดหมายเลขให้มีระยะห่างกันพอสมควรเพื่อที่จะแทรกหมายเลขเพิ่มเติม
5. การเขียนโปรแกรมจะกำหนดให้เป็นตัวพิมพ์เล็กหรือพิมพ์ใหญ่ก็ได้ ซึ่งโปรแกรมจะเปลี่ยนให้เป็นตัวพิมพ์ใหญ่โดยอัตโนมัติ
6. การทำงานของคำสั่งโปรแกรมจะทำจากซ้ายไปขวา
7. การเขียนโปรแกรมสามารถรวมคำสั่งหลายคำสั่งเอาไว้บรรทัดเดียวกันได้ โดยการใช้เครื่องหมาย (;)
เครื่องหมายในการเขียนโปรแกรม
1. เครื่องหมายโคลอน (Colon) เป็นเครื่องหมายสำหรับการเชื่อมคำสั่งซึ่งเราได้ทำหลาย ๆ คำสั่งต่อกัน
2. เครื่องหมายจุลภาคหรือคอมมา (Comma “,”) ในกรณีคำสั่ง PRINT เป็นการสั่งแบ่งระยะโดยจะทำให้ระยะระหว่างข้อมูลที่จะแสดงผลที่จอภาพถูกจัดแบ่งเป็นระยะเท่า ๆ กัน
3. เครื่องหมายอัฒภาค หรือ เซมิโคลอน (Semicolon “;”) เมื่อแสดงผลที่จอภาพข้อมูลจะถูกพิมพ์ต่อเนื่องกัน
ประเภทคำสั่งในภาษาเบสิก
1. คำสั่งสำหรับรับและส่งข้อมูล
คือ กลุ่มคำสั่งที่เขียนขึ้นเพื่อรับข้อมูลเข้าไปทำการประมวลผลในโปรแกรมและกลุ่มคำสั่งที่สั่งให้โปรแกรมแสดงผลที่อุปกรณ์ประกอบคำสั่งเหล่านี้ได้แก่
1.1 คำสั่ง INPUT เป็นคำสั่งที่รับข้อมูลโดยการป้อนผ่านแป้นพิมพ์ เพื่อให้โปรแกรมรับทราบว่าใส่ข้อมูลใด เมื่อเวลาแสดงผลจะแสดงเครื่องหมายคำถาม เพื่อป้อนข้อมูลที่ต้องการต่อท้ายเครื่องหมายคำถาม
1.2 คำสั่ง PRINT เป็นคำสั่งในภาษาเบสิก เพื่อแสดงผลของข้อมูลที่โปรแกรมสั่งให้ทำงานออกทางจอภาพ
1.3 คำสั่ง LPRINT เป็นคำสั่งในภาษาเบสิก ที่แสดงผลของข้อมูลที่โปรแกรมสั่งออกทางเครื่องพิมพ์
2. คำสั่งเกี่ยวกับการกำหนดค่าให้กับตัวแปรและการตั้งสมการคำนวณ
2.1 คำสั่ง LET เป็นคำสั่งที่ใช้ในการกำหนดค่าคงที่ให้กับ ไม่ว่าเป็นตัวแปรแบบอักขระหรือตัวแปรแบบตัวเลข และใช้ตั้งสมการทางคณิตศาสตร์
3. คำสั่งในการคำนวณ
ลักษณะของคำสั่งประเภทนี้จะอยู่ในรูปของเครื่องหมาย แสดงแทนเครื่องหมายทางคณิตศาสตร์ จะใช้ประกอบกับคำสั่งประเภทอื่น ๆ
4. คำสั่งสำหรับการควบคุม
ลักษณะของคำสั่งในการควบคุม เป็นการสั่งในแบบกำหนดเงื่อนไข และแบบไม่มีเงื่อนไขรวมถึงคำสั่งควบคุมการวนซ้ำ
4.1 คำสั่งแบบมีเงื่อนไข ได้แก่ IF/THEN/ELSE DO..LOOP WHILE..WEND 4.2 คำสั่งแบบไม่มีเงื่อนไข ได้แก่ GO,GOSUB1.3 คำสั่งควบคุมการวนซ้ำ คือ คำสั่งที่ควบคุมการกระทำซ้ำ ได้แก่ FOR/NEXT
5. คำสั่งเกี่ยวกับการกำหนดรูปแบบ
เป็นคำสั่งที่ใช้ในการกำหนดการวางรูปแบบของการแสดงผลโปรแกรม บางครั้งก็จะอยู่ในรูปเครื่องหมาย ใช้ร่วมกับคำสั่งทั่วไป
6. คำสั่งฟังก์ชัน
เป็นกลุ่มคำสั่งประเภทหนุ่งที่ถูกสร้างขึ้นเพื่อำนวยความสะดวกแก่ผู้ใช้ โดยคำสั่งประเภทนี้จะมีค่าฟังก์ชันทางคณิตศาสตร์
7. คำสั่งทั่วไป
NEW เป็นคำสั่งลบโปรแกรมและค่าตัวแปรที่อยู่ในหน่วยความจำ โดยจะลบหล้าจอทั้งหมดก่อนที่จะเขียนโปรแกรมใหม่
REM เป็นคำสั่งที่ใช้ในการหมายเหตุ
END เป็นคำสั่งให้หยุดการทำงานของโปรแกรม
CLS เป็นคำสั่งให้ลบหน้าจอใหม่ โดยไม่แสดงผลเดิม

กิจกรรมประกอบการเรียน
1. ให้นักเรียนศึกษารวบรวมคำสั่งประเภทต่าง ๆ สำหรับโปรแกรม BASIC ตั้งแต่ A – Z โดยดูจากเมนูหลัก HELP ในเมนูย่อย CONTENT จากนั้นบอกว่าเป็นคำสั่งในกลุ่มใด ได้แก่
1.1 STATEMENT
1.2 FUNCTION
1.3 KEYWORD
1.4 OPERATION
1.5 MATACOMMAND
2. ให้นักเรียนแยกประเภทของคำสั่งเฉพาะกลุ่มที่เป็น FUNCTION และกลุ่มที่เป็น STATEMENT
3. ให้นักเรียนเข้าไปยัง HELP ของ BASIC เข้าไปยัง CONTENT จากนั้นเลื่อน CURSOR

วิธีใช้หรือสมัคร blogger

วิธีใช้หรือสมัคร blogger

การสมัคร Blogger

สิ่งแรกที่ต้องมีในการสมัคร Blogger คือ E-mail ของ Gmail เท่านั้นครับ ซึ่งในส่วนของการสมัคร E-mail คงจะนำมาสอนเป็นขั้นเป็นตอนเพราะมันง่ายมากครับ

เพื่อนๆที่สมัคร Gmail เรียบร้อยแล้ว สามารถทำตามวิธีดังต่อไปนี้เลยครับในการสมัคร Blogger มาใช้งานกัน

1. สามารถเปลี่ยนภาษาทางด้าน ขวาบน ได้หลากภาษาครับ จากนั้นคลิ๊กที่สร้างบล๊อกดังรูปครับ

2. ตั้งชื่อส่วนหัวของบล๊อก ตั้งชื่อบล๊อก จากนั้นก็ คลิ๊กดำเนิกการต่อ

ดังรูปครับ

3. เลือกแม่แบบ หรือ Theme (หน้าตาบล๊อก) จากนั้น คลิ๊ก ดำเนินการต่อ

ดังรูปครับ

4. เสร็จเรียบร้อยแล้วครับ คลิ๊ก เริ่มต้นการเขียนบล๊อก ได้ทันทีเลย

ดังรูปครับ

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