2. ส่วนประกอบในโครงสร้างภาษาซี บทที่ 2 2. ส่วนประกอบในโครงสร้างภาษาซี #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { system("PAUSE"); return 0; }

2.1 ส่วนหัวโปรแกรม (head file) รูปแบบ #include <header_file> คำอธิบาย header_name ชื่อเฮดเดอร์ไฟล์ที่ควบคุม ฟังก์ชั่นมาตรฐาน เช่น ฟังก์ชั่น printf ใช้ควบคุม การแสดงผล จัดเก็บในไลบารี่ชื่อ #include<stdio.h> ตัวอย่าง #include <stdio.h> อธิบาย ให้คอมไพเลอร์ค้นหาไลบารี่ไฟล์ชื่อ stdio.h จากไดเรกทอรี่ include

ส่วนฟังก์ชั่น จะถูกเก็บไว้ในส่วนของ libary

2.2 ส่วนฟังก์ชั่นหลัก(mainfunction) เป็นส่วนเขียนคำสั่งควบคุมการทำงานภายในขอบเขตเครื่องหมาย { } ของฟังก์ชั่นหลักคือ main ( ) ต้องเขียนคำสั่งตามลำดับขั้นตอนจากกระบวนการวิเคราะห์ระบบงานเบื้องต้น และขั้นวางแผนลำดับการทำงานที่ได้จัดทำล่วงหน้าไว้ เช่น ลำดับการทำงานด้วยผังงานโปรแกรม เพื่อลดข้อผิดพลาดในขั้นตอนลำดับคำสั่งควบคุมงาน

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

ตัวอย่างการเขียนคำสั่ง #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int x,y,r,s,t; printf("\t Arithmetic Operation \n"); printf("-----------------------------\n"); printf("Data x="); scanf("%d",&x); printf("Data y="); scanf("%d",&y); r=x+y*2; s=(x+y)*2; t=x+y*2-1; printf("r=x+y*2=%d \n",r); printf("s=(x+y)*2 =%d \n",s); printf("t=x+y*2-1 =%d \n",t); printf("-----------------------------\n\n"); system("PAUSE"); return 0; }

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

3.1 ชนิดข้อมูลแบบพื้นฐาน การจัดเก็บข้อมูลลงหน่วยความจำทั้งแบบค่าคงที่หรือแบบตัวแปร ต้องกำหนดชนิดข้อมูลให้ระบบรับทราบ ตารางชนิดข้อมูลแบบพื้นฐาน ชนิดข้อมูล ขอบเขตของข้อมูล อธิบาย char -128 ถึง 127 เก็บข้อมูลแบบอักขระ int -32768 ถึง 32767 เก็บข้อมูลแบบตัวเลขจำนวนเต็ม float 3.4*10 ถึง 3.4*10 เก็บข้อมูลเป็นตัวเลขทศนิยม -38 38

3.2 คำสั่งจัดเก็บข้อมูลแบบคงที่ ประสิทธิภาพของคำสั่ง ลักษณะการจัดเก็บข้อมูลในหน่วยความจำไม่สามารถเปลี่ยนแปลงได้ รูปแบบ const data_type var = data ; อธิบาย data_type คือ ชื่อชนิดข้อมูลแบบพื้นฐาน var คือ ชื่อหน่วยความจำที่ผู้ใช้ต้องกำหนดตาม กฎการตั้งชื่อ data คือ ข้อมูลที่กำหนดเป็นค่าคงที่

ตัวอย่างคำสั่ง จัดเก็บข้อมูลแบบค่าคงที่ ตัวอย่างคำสั่ง จัดเก็บข้อมูลแบบค่าคงที่ const float pi = 3.14 ; const char ans = ‘n’ ; Const char word[10] = “sriracha” ;

คำสั่ง จัดเก็บข้อมูลแบบตัวแปร คำสั่ง จัดเก็บข้อมูลแบบตัวแปร ประสิทธิภาพคำสั่ง : ลักษณะการจัดเก็บข้อมูลในหน่วยความจำสามารถเปลี่ยนแปลงได้ รูปแบบที่ 1 var_type varname [….] ; รูปแบบที่ 2 var_type varname = data ;

var_type คือชื่อชนิดข้อมูลแบบพื้นฐาน อธิบาย var_type คือชื่อชนิดข้อมูลแบบพื้นฐาน var_name คือชื่อหน่วยความจำที่ผู้ใช้กำหนด data คือ ข้อมูลที่กำหนดเป็นค่าเริ่มต้น (อาจมีหรือไม่มีก็ได้) ตัวอย่างคำสั่ง กำหนดคุณสมบัติให้ตัวแปรในการจัดเก็บข้อมูล char ans ; int salary , bonus short value = 2

4. คำสั่งควบคุมการทำงานขั้นพื้นฐาน 4. คำสั่งควบคุมการทำงานขั้นพื้นฐาน คำสั่งการทำงานขั้นพื้นฐานมี 3 กลุ่มคือ คำสั่งรับข้อมูลจากแป้นพิมพ์แล้วนำไปจัดเก็บลงหน่วยความจำ (Input) การเขียนสมการการคำนวณโดยใช้นิพจน์ทางคณิตศาสตร์ (Process) คำสั่งแสดงผลข้อความ หรือข้อมูลที่จัดเก็บในหน่วยความจำ (Output)

4.1 คำสั่งแสดงผล : printf( ) ประสิทธิภาพคำสั่ง : ใช้แสดงผล เช่น ข้อความ ข้อมูลจากค่าคงที่ หรือตัวแปร ที่จอภาพ รูปแบบที่ 1 printf(“string_format”,data_list) ; รูปแบบที่ 2 printf(“string_format”) ; อธิบาย string_format คือลักษณะของสิ่งต่อไปนี้ เช่น ข้อความ รหัส รูปแบบข้อมูล เช่น %d รหัสควบคุม เช่น \n data_list คือข้อมูลแสดงผลอาจเป็นค่าคงที่ ตัวแปร นิพจน์ หากมีหลายตัวใช้ , คั่น

รหัสรูปแบบข้อมูลระดับพื้นฐาน รหัส format code ความหมาย %c ใช้กับข้อมูลแบบ char %d ใช้ข้อมูลแบบ int เฉพาะฐาน 10 %f ใช้กับข้อมูลแบบ float และ double %s ใช้กับข้อมูลแบบ string

ตัวอย่างคำสั่งควบคุมการแสดงผลด้วย printf Printf(“Data is %d \n”,score); อธิบาย พิมพ์ข้อความคำว่า data is ตามด้วยค่าข้อมูลในหน่วยความจำตัวแปร ชื่อ score ซึ่งเป็นข้อมูลชนิดจำนวณเต็ม(%d)แล้วเลื่อนเคอร์เซอร์ ไปไว้บรรทัดถัดไป(\n)

4.2 คำสั่งรับข้อมูล : scanf ( ) ประสิทธิภาพคำสั่ง : รับข้อมูลจากบ้านพิมพ์ แล้วจัดเก็บข้อมูลลง หน่วยความจำของตัวแปร รูปแบบ scanf(“string_format”,&address_list); อธิบาย string_format คือรูปแบบการแสดงผลลัพท์ของข้อมูล เท่านั้น เช่น %d adress_list คือการระบุตำแหน่งที่อยู่ในหน่วยความจำ ต้องใช้สัญลักษณ์ & นำหน้าชื่อตัวแปรเสมอ

ตัวอย่างการเขียนคำสั่ง scanf (“%d”,&score); อธิบาย รับข้อมูลจากแป้นพิมพ์ นำไปเก็บในหน่วยความจำชื่อ score เป็นข้อมูลจำนวนเต็ม

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

รูปแบบ var = expression ; อธิบาย var คือชื่อหน่วยความจำชนิดตัวแปร expression คือสมการนิพจน์ เช่น สูตรคำนวณทาง คณิตศาสตร์ ตัวอย่างคำสั่ง sum = a + b ; ให้นำค่าในหน่วยความจำตัวแปรชื่อ a กับ b มา + กัน แล้วนำ ค่าไปเก็บไว้ในหน่วยความจำตัวแปรชื่อ sum

สัญลักษณ์ตัวดำเนินการทางคณิตศาสตร์ ศัพท์เฉพาะ ความหมาย + addition บวก - subtraction ลบ * multiplication คูญ / division หาร % remainder หารเอาเศษ

ลำดับการคำนวณทางคณิตศาสตร์ เครื่องหมาย ลำดับ ( ) 1 ++ , - - 2 - (เครื่องหมายติดลบ) 3 * , / , % 4 + , - 5

ตัวอย่างการเขียนโปรแกรมที่ 2 ตัวอย่างการเขียนโปรแกรมที่ 2.1 เขียนคำสั่งควบคุมให้ประมวลผลนิพจน์คณิตศาสตร์ include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int x,y,r,s,t; printf("\t Arithmetic Operation \n"); printf("-----------------------------\n"); printf("Data x="); scanf("%d",&x); printf("Data y="); scanf("%d",&y); r=x+y*2; s=(x+y)*2; t=x+y*2-1; printf("r=x+y*2=%d \n",r); printf("s=(x+y)*2 =%d \n",s); printf("t=x+y*2-1 =%d \n",t); printf("-----------------------------\n\n"); system("PAUSE"); return 0; } ส่วนป้อนข้อมูล ประมวลผลตามนิพจน์คณิตศาสตร์ แสดงผลข้อมูลที่จัดเก็บในตัวแปร

ผลของการทดสอบโปรแกรม Arimathmatic Operator -------------------------------------------------- Data x = 2 Data y = 3 r = x + y * 2 = 8 s = (x+y)*2 = 10 t = x + y *2-1 = 7 ------------------------------------------------------- press any key to continue ผู้ใช้ระบบป้อนข้อมูล ระบบประมวลผลตามนิพจน์ ที่กำหนดแล้วนำไปจัดเก็บลง ตัวแปรและนำมาแสดงผล

แนวคิดในการเขียนคำสั่งควบคุมงาน ส่วนป้อนข้อมูล ผู้ใช้ระบบงานป้อนค่า 2 เก็บในหน่วยความจำ x และป้อนค่า 3 เก็บในหน่วยความจำ y ด้วยคำสั่ง printf(“Data x = ”); scanf(“%d”,&x); printf(“Data y = ”); scanf(“%d”,&y);

2. ส่วนประมวลผล ระบบจะนำค่าไปประมวลผลตามนิพจน์คณิตศาสตร์ r = 2 +3 * 2 ; ได้คำตอบคือ 8 s = ( 2 + 3 ) * 2 ; ได้คำตอบคือ 10 t = 2 + 3 * 2 – 1 ; ได้คำตอบคือ 7 ทั้งนี้คอมพิวเตอร์ประมวลผล โดยยึดหลักลำดับความสำคัญของเครื่องหมาย ทางคณิตศาสตร์ เช่น คำนวณเครื่องหมาย * ก่อนเครื่องหมาย +

3. ส่วนแสดงผล คำสั่งควบคุมแสดงผลลัพธ์ printf (“r = x + y * 2 = % d \n”,r); printf (“s = ( x + y ) * 2 = % d \n”,s); printf (“t = x + y * 2 – 1 = % d \n”,t);

5. คำสั่งแสดงผล-รับข้อมูล เฉพาะอักขระ ภาษาซีมีคำสั่งแสดงผลและรับข้อมูลเฉพาะข้อมูลประเภท 1 อักขระ (char) ดังนี้ 5.1 คำสั่ง putchar() 5.2 คำสั่ง getchar() 5.3 คำสั่ง getch() 5.4 คำสั่ง getche()

5.1 คำสั่ง putchar() แสดงผลข้อมูลจากหน่วยความจำของตัวแปร ทางจอภาพ ครั้งละ 1 อักขระเท่านั้น รูปแบบ putchar (char_argument); อธิบาย char_argument คือข้อมูลชนิดอักขระ

ตัวอย่าง โปรแกรมที่ 2.2 แสดงประสิทธิภาพคำสั่ง putchar( ) #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { char word1='A' , word2='1'; printf("\t TEST putchar () Command \n"); printf("\t****************************** \n"); printf(" \t Display 2 character="); putchar (word1); putchar (word2); printf("\n"); system("PAUSE"); return 0; }

ผลการทดสอบโปรแกรม แสดงผลอักขระ 2 ตัว ที่จัดเก็บใน word1 และ word2 *Test putchar() command* ********************************************************** Display 2 character = A1 Press any key to continue_ แสดงผลอักขระ 2 ตัว ที่จัดเก็บใน word1 และ word2

แนวคิดในการเขียนคำสั่งควบคุมการทำงาน 1. กำหนดค่า ‘A’ เก็บในตัวแปรประเภท char ชื่อ word และกำหนดค่า ‘1’ เก็บในตัวแปรชื่อ word ด้วยคำสั่ง char word1 = ‘A’ , word2 = ‘1’ ; 2.เขียนคำสั่งควบคุมการแสดงผลทีละ 1 อักขระ โดยไม่ใช้สัญลักษณะขึ้นบรรทัดใหม่ด้วยคำสั่ง putchar(word1); putchar(word2); จึงพิมพ์คำว่า A1 ที่จอภาพ

5.2 คำสั่ง getchar( ) รับข้อมูลจากแป้นพิมพ์ครั้งละ 1 อักขระและแสดงอักขระที่จอภาพ จากนั้นต้องกดแป้น enter เพื่อนำข้อมูลที่บันทึกลงหน่วยความจำ รูปแบบที่ 1 ไม่นำข้อมูลจัดเก็บลงหน่วยความจำของตัวแปร getchar ( ); รูปแบบที่ 2 นำข้อมูลจัดเก็บลงหน่วยความจำของตัวแปร char_var = getchar ( ); อธิบาย char_var คือข้อมูลชนิด char

ตัวอย่างโปรแกรมที่ 2.3 แสดงประสิทธิภาพคำสั่ง getchar() #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { char word; printf("\t Test getchar () comman* \n"); printf("\t************************\n"); printf("\tKey 1 Character="); word=getchar(); printf("\n"); printf("\tYou Key Character is %c \n",word); system("PAUSE"); return 0; }

Test getchar () comman* **************************************** ผลการทดสอบโปรแกรม Test getchar () comman* **************************************** Key 1 Character = a You key Character is = a ***************************************** Press any key to continue ผู้ใช้โปรแกรมป้อนข้อมูลเข้าระบบ ต้องกดแป้น enter ระบบแสดงข้อมูลจากหน่วยความจำตัวแปร

แนวคิดในการเขียนโปรแกรมคำสั่งควบคุมการทำงาน เขียนคำสั่งควบคุมการป้อนข้อมูลประเภทอักขระด้วยคำสั่ง printf (“Key 1 Character =“); word = getchar ( ); หมายถึงป้อนอักขระ 1 ตัว เช่น a จะ แสดงค่า ให้เห็นที่หน้าจอด้วย แล้ว ต้อง กดแป้น enter เพื่อนำข้อมูลบัทึกลงหน่วยความจำตัว แปรประเภท char ชื่อ word 2. เขียนคำสั่งควบคุมการแสดงผลจากหน่วยความจำ word จึงเห็นค่า a (แทนที่ word) printf(“You key Character is=%c \n”,word)

5.3 คำสั่ง getch() รับข้อมูลจากแป้นพิมพ์ครั้งละ 1 อักขระแต่ไม่ปรากฏอักษรบนจอภาพและไม่ต้องกดแป้น enter รูปแบบที่ 1 ไม่นำข้อมูลจัดเก็บลงหน่วยความจำของตัวแปร getch ( ) ; รูปแบบที่ 2 นำข้อมูลจัดเก็บลงหน่วยความจำของตัวแปร char_var = getch( );

ตัวอย่างโปรแกรมที่ 2.4 แสดงประสิทธิภาพคำสั่ง getch ( ) #include <stdio.h> #include <stdlib.h> #include <conio.h> int main(int argc, char *argv[]) { char word ; printf("\t Test getch () command \n"); printf("\t************************\n"); printf("\t Key 1 character=\n"); word=getch(); printf("\n"); printf("\t You key Character is =%c\n",word); system("PAUSE"); return 0; }

ผลการทดสอบโปรแกรม *Test getch() command* ****************************************** Key 1 Character = You key Character is = a Press any key to continue_ ผู้ใช้โปรแกรมป้อนข้อมูลเข้าระบบ จะมองไม่เห็นอักขระที่จอ และ ไม่ต้องกด enter ระบบแสดงผลข้อมูล จากหน่วยความจำตัวแปร

5.4 คำสั่ง getche( ) รับข้อมูลจากแป้นพิมพ์ครั้งละ 1 อักขระ และ แสดงอักษรบนจอภาพ และไม่ต้องกดแป้น enter รูปแบบที่ 1 ไม่นำข้อมูลจัดเก็บลงหน่วยความจำของตัวแปร getche( ) ; รูปแบบที่ 2 นำข้อมูลเก็บลงหน่วยความจำของตัวแปร char_var = getche ( ); อธิบาย char_var คือข้อมูลชนิดอักขระ

ตัวอย่างโปรแกรมที่ 2.5 แสดงประสิทธิภาพคำสั่ง getche( ) #include <stdio.h> #include <stdlib.h> #include <conio.h> int main(int argc, char *argv[]) { char word ; printf("\t *Test getche() command \n*"); printf("\t************************\n"); printf("\t Key 1 character="); word=getche(); printf("\n"); printf("\t You key Character is =%c\n",word); system("PAUSE"); return 0; }

Test getche() command* **************************************** ผลทดสอบโปรแกรมที่ 2.5 Test getche() command* **************************************** Key 1 Character = a You key Character is = a ********************************************** Press any key to continue

แนวคิดในการเขียนคำสั่งควบคุมการทำงาน เขียนคำสั่งควบคุมการป้อนข้อมูลประเภทอักขระด้วยคำสั่ง printf (“Key 1 Character = ”); word = getche ( ); หมายถึงป้อนค่าใดทางแป้นพิมพ์เป็นอักขระ 1 ตัว เช่น a จะแสดงค่าให้เห็นที่หน้าจอ และไม่ต้องกดแป้น enter เพื่อนำข้อมูลบันทึกลงหน่วยความจำตัวแปรประเภท char ชื่อ word 2. เขียนคำสั่งควบคุมการแสดงผลเพื่อแสดงค่าจากหน่วยความจำ word จึงเห็นค่า a (แทนที่ word) printf(“You key Character is = %c \n”,word);

6. คำสั่งแสดงผล-รับข้อมูล เฉพาะข้อความ ภาษาซีมีคำสั่งใช้ในการรับข้อมูลเฉพาะประเภทข้อความ (String)ในภาษาซีคือ ข้อมูลชนิด char[n] จัดเก็บในหน่วยความจำ และแสดงผลข้อมูลประเภทข้อความเท่านั้น มีรายละเอียดดังนี้ 6.1 คำสั่ง puts( ) 6.2 คำสั่ง get( )

6.1 คำสั่ง puts แสดงผลข้อมูลเฉพาะประเภทข้อความทางจอภาพครั้งละ 1 ข้อความ รูปแบบ puts = (string_argument) อธิบาย string_argument คือ ข้อมูลชนิดข้อความ

ตัวอย่างโปรแกรม แสดงประสิทธิภาพของ puts( ) #include <stdio.h> #include <stdlib.h> #include <conio.h> int main(int argc, char *argv[]) { Char word[15] = “*Example*”; puts(word); puts(“**************************”); }

********************************** ผลการทดสอบโปรแกรม ระบบแสดงข้อมูลจาก หน่วยความจำตัวแปร *Example* ********************************** Press any key to continue

แนวคิดในการเขียนคำสั่งควบคุมการทำงาน เขียนคำสั่งกำหนดค่าข้อความเก็บในตัวแปรชื่อ word char word[15] = “*Example*” เขียนคำสั่งควบคุมการแสดงผลในลักษณะข้อความด้วย puts puts (word) ; puts (“*******************”);

6.2 คำสั่ง gets( ) รับข้อมูลข้อความจากแป้นพิมพ์ และ ต้องกดแป้น enter รูปแบบ 1 ไม่นำข้อมูลจัดเก็บลงหน่วยความจำของตัวแปร gets ( ) ; รูปแบบ 2 นำข้อมูลจัดเก็บลงหน่วยความจำของตัวแปร string_var = gets ( ); อธิบาย string_var คือข้อมูลชนิดข้อความ

ตัวอย่าง แสดงประสิทธิภาพคำสั่ง gets( ) #include <stdio.h> #include <stdlib.h> #include <conio.h> int main(int argc, char *argv[]) { char word[40]; printf("\t Test gets () command \n"); printf(" \t *****************************\n"); printf("\t Key your name="); gets(word); printf("\n"); printf("\t You name is %s \n",word); system("PAUSE"); return 0; }

***************************************** ผลการทดลองโปรแกรม *Test gets( ) command* ***************************************** Key you name chalong You name is chalong ****************************************** Press any key to continue_ ผู้ใช้ป้อนข้อความกด enter ระบบแสดงข้อความที่เก็บไว้ ในตัวแปร

แนวคิดในการเขียนคำสั่งควบคุมการทำงาน เขียนคำสั่งรับข้อมูลชนิดข้อความจากแป้นพิมพ์และต้องกด enter เพื่อนำข้อความบันทึกลงตัวแปรชนิดข้อความด้วยคำสั่ง gets(word); เขียนคำสั่งควบคุมให้แสดงผลลักษณะข้อความด้วย printf (“Your name is %s \n”,word);

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

ตัวอย่างโปรแกรม 2.8 กรณีศึกษาระบบงานคำนวณหาผลรวมเลข 2 จำนวน ตัวอย่างโปรแกรม 2.8 กรณีศึกษาระบบงานคำนวณหาผลรวมเลข 2 จำนวน #include <stdio.h> #include <stdlib.h> #include <conio.h> int main(int argc, char *argv[]) { int n1,n2,result; printf("Calculate Add \n \n"); printf("Key number 1 = "); scanf ("%d",&n1); printf("Key number 2 = "); scanf ("%d",&n2); result = n1+n2; printf("\n Result=%d \n",result); system("PAUSE"); return 0; } ส่วนป้อนข้อมูล ส่วนประมวลผล ส่วนแสดงผล

ผลทดสอบโปรแกรมตัวอย่างที่ 2.8 *Calculate Add* Key number 1 = 250 Key number 2 = 100 **Result = 350 Press any key to continue ป้อนข้อมูลเลข 2 จำนวณ บันทึกลงตัวแปร ประมวลผลจัดเก็บลงตัวแปร

แนวคิดในการเขียนคำสั่งควบคุมงาน 1. ประกาศพรีโปรเซสเซอร์ไดเร็กทีฟ #include <stdio.h> ระบุไลบารีควบคุมคำสั่ง 2. เขียนหมายเหตุ(remark) เช่น /* calulate// cal1.c */ชื่อแฟ้มงานที่จัดเก็บโปรแกรมนี้ 3. กำหนดชื่อหน่วยความจำ ประเภทตัวแปรและชนิดข้อมูลที่จัดเก็บในที่นี้คือ int n1,n2,result, 4. พิมพ์หัวข้อรายงานของโปรแกรมระบบงานนี้ เช่น printf(“*Calculaye Add*\n\n);” \n คือเลื่อนเคอร์เซอร์ขึ้นบรรทัดใหม่

5. ส่วนป้อนข้อมูลเข้าระบบ เขียนคำสั่งควบคุม printf(“Key number1 = ”); scanf(“%d,&n1”); 6. ส่วนเขียนนิพจน์ เพื่อประมวลผลสมการ เช่น result=n1+n2; นำค่าตัวแปร n1 กับ n2 บวกกันแล้วเก็บในตัวแปรชื่อ result 7. ส่วนแสดงผล ที่เก็บไว้ในตัวแปรนิพจน์ เช่น printf(“\n **Result=%d \n”,result); (เลื่อนเคอร์เซอร์ขึ้นบรรทัดใหม่แล้วพิมพ์ **Result=ตามด้วยค่าresult ที่เป็นตัวเลขจำนวนเต็ม%d แล้วขึ้นบรรทัดใหม่)

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

ตัวอย่างโปรแกรมที่ 2.9 กรณีศึกษาโปรแกรมระบบงานคำนวณหาสองเท่าของผลรวมเลข2จำนวน #include <stdio.h> #include <stdlib.h> #include <conio.h> int main(int argc, char *argv[ ]) { const char line[20]= " *************** "; const int n3=2; int n1,n2,result; printf("Calculate Value \n\n"); printf(line); printf("\n Key number1=");scanf("%d",&n1); printf("\n Key number2=");scanf("%d",&n2); result=(n1+n2)*n3; printf("\n");printf(line); printf("\n %d+%d x %d=%d \n", n1,n2,n3,result); printf(line); printf("\n"); system("PAUSE"); return 0; } ส่วนป้อนข้อมูล ส่วนประมวลผล ส่วนแสดงผล

ผลการทดสอบโปรแกรมที่ 2.9 *Calculate Value* ******************************* Key number 1 = 2 Key number 2 = 3 2 + 3 x 2 = 10 Press any key to continue

แนวคิดในการเขียนคำสั่งควบคุมการทำงาน เขียนคำสั่งกำหนดชื่อหน่วยความจำ 1.1 หน่วยความจำประเภทคงที่ พร้อมกำหนดค่าให้เก็บในหน่วยความจำ const char line [20]=“********************”; const int n3 = 2; 1.2 หน่วยความจำประเภทตัวแปร int n1 , n2 , result ;

พิมพ์หัวข้อรายงาน printf(“* Calculate Value \n \n”); printf(line) ; ส่วนป้อนข้อมูล printf(“\n key number 1 =“);scanf(“%d”,&n1); printf(“\n key number 2 =“);scanf(“%d”,&n2); 4. ส่วนประมวลผล เขียนคำสั่งควบคุมประมวลผลนิพจน์คณิตศาสตร์ result=(n1+n2)*3; 5. ส่วนแสดงผล เขียนคำสั่งควบคุมตัวแปร printf(“\n %d+%dx%d=%d \n”,n1,n2,n3,result);

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

ตัวอย่างโปรแกรมที่ 2.10 ส่วนป้อนข้อมูล ส่วนประมวลผล ส่วนแสดงผล #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { const char line[26]="========================="; int score ; float result ; char name[30]; printf("\t Calculate Score \n \n"); printf(line); printf("\n Key student name :"); scanf("%s",name); printf("key score :");scanf("%d",&score); result= (score*100)/250; printf("\n");printf(line); printf("\n Percentage=%f \n",result); printf(line);printf ("\n"); system("PAUSE"); return 0; } ส่วนป้อนข้อมูล ส่วนประมวลผล ส่วนแสดงผล

ผลการทดสอบโปรแกรมตัวอย่างที่ 2.10 Calculate Score* ======================= Key student name : chalong Key score : 200 *Percentage = 80.000000 Press any key to continue ป้อนชื่อและคะแนนดิบ คะแนนได้จากการคำนวณ

แนวคิดในการเขียนคำสั่งควบคุมการทำงาน ส่วนป้อนข้อมูล เขียนคำสั่งควบคุมให้ผู้ใช้ระบบป้อนข้อมูลชื่อ นักศึกษาและคะแนนด้วยคำสั่ง Printf(“\n key student name :”);scanf(“%S”,name); printf(“key score :”); scanf(“%d”,score); 2. ส่วนประมวลผล เขียนคำสั่งควบคุมการประมวลผลนิพจน์ตามโจทย์ result = (score * 100)/250 ; 3. ส่วนแสดงผล เขียนคำสั่งควบคุมการแสดงผลด้วยคำสั่ง printf(“\n Percentage = %f”,result);

7.4 กรณีศึกษา แสดงขั้นตอนการสร้างโปรแกรม และชุดคำสั่ง 7.4 กรณีศึกษา แสดงขั้นตอนการสร้างโปรแกรม และชุดคำสั่ง โจทย์ บริษัท ok ต้องการคำนวณยอดขายเฉลี่ยของพนักงานขาย แต่ละราย และกำหนดการแสดงผลทางจอภาพดังนี้ Report averrang ********************************************************* code (รหัสพนักงาน) = …….. Name (ชื่อพนักงาน) = ……. Summit(ยอดสินค้า) = ……. Number(จำนวนสินค้า)=…… ****************************************************************** Averange (ยอดขายเฉลี่ย)=…….. ******************************************************************

1.การวิเคราะห์ระบบงานเบื่องต้น กำหนดคุณสมบัติของตัวแปร ข้อมูล ชื่อหน่วยความจำ ชนิดข้อมูล รหัสพนักงาน no กลุ่มอักขระ ชื่อพนักงาน name ยอดขาย sum ตัวเลขจำนวนเต็ม จำนวนสินค้า num ค่าเฉลี่ยยอดขาย avg ตัวเลขทศนิยม

2. ลำดับการทำงานด้วยผังงานโปรแกรม start พิมพ์ heading ป้อนค่า no,name,sum,num คำนวณ avg=sum/num พิมพ์ค่า avg end

3.คำสั่งควบคุมการทำงาน #include <stdio.h> #include <stdlib.h> #include <conio.h> int main(int argc, char *argv[]) { char name[30]; int code,sum,num; float avg; printf("************************* \n "); printf("Report Averange \n"); printf("************************* \n \n"); printf("code=>");scanf("%d",&code); printf("Name=>");scanf("%s",name); printf("Summit=>");scanf("%d",&sum); printf("Number=>");scanf("%d",&num); avg=sum/num; printf("* Averange=%.2f \n",avg); system("PAUSE"); return 0; } 3.คำสั่งควบคุมการทำงาน ส่วนกำหนดคุณสมบัติ ส่วนป้อนข้อมูล ส่วนประมวลผล ส่วนแสดงผล

ผลการทดลองโปรแกรม ป้อนข้อมูล *********************************** Report Averange ********************************** code => 001 Name=> chalong Summit=> 60000 number=> 10 ********************************** *Averange=6000.00 ********************************** Press any key to continue ป้อนข้อมูล ผลการคำนวณหลังการคำนวณ ตามนิพจน์

แนวคิดในการเขียนคำสั่งควบคุมการทำงาน วิเคราะห์คุณสมบัติหน่วยความจำ ด้วยการกำหนดตัวแปรและชนิดข้อมูล char name[-จ]; int code,sum,num; float avg; 2. ส่วนป้อนข้อมูล เขียนคำสั่งควบคุมการทำงานของนิพจน์ avg = sum/num; 3. ส่วนแสดงผล เขียนคำสั่งควบคุมแสดงผลลัพท์จากตัวแปร printf(“ * Avergange = %.2f \n”,avg);

************************************************ โจทย์ บริษัท Thank you ต้องการวิเคราะห์ เงินคงเหลือของโครงการวิจัยที่นำเสนอกำหนดแสดงผลดังนี้ Report Thank you Company ************************************************ project name (ชื่อโครงการวิจัย)…. budget (งบประมาณ)……….. ************************************************ Maintenance (หักค่าบำรุง 20%) Public utility (หักเงินค่าสาธารณูปโภค 5%) Remaining (เงินคงเหลือ)………… ********************************************************

การวิเคราะห์งานเบื้องต้น 1.1 สิ่งที่ต้องการ เงินหักค่าบำรุง 20% เงินหักค่าสาธารณูปโภค 5% และเงินคงเหลือ 1.2 สมการคำนวณ 1. เงินหักค่าบำรุง 20% คำนวณตามสมการดังนี้ เงินหักค่าบำรุง 20% = งบประมาณ * 20/100 2. เงินหักค่าสาธารณูปโภค 5% คำนวณตามสมการดังนี้ เงินหักค่าสาธารณูปโภค5% = (งบประมาณ - เงินหักค่าบำรุง20% )*5/100 3. เงินคงเหลือ คำนวณตามสมการดังนี้ เงินคงเหลือ = งบประมาณ - เงินหักค่าบำรุง20% - เงินหักค่าสาธารณูปโภค 5%

1.3 ข้อมูลนำเข้า ชื่อโครงการวิจัย งบประมาณ 1.4 การแสดงผลตามโจทย์กำหนด 1.3 ข้อมูลนำเข้า ชื่อโครงการวิจัย งบประมาณ 1.4 การแสดงผลตามโจทย์กำหนด 1.5 กำหนดคุณสมบัติตัวแปร ข้อมูล ชื่อหน่วยความจำ ชนิดข้อมูล ชื่อโครงการวิจัย name กลุ่มอักขระ งบประมาณ budget ตัวเลขทศนิยม เงินหักค่าบำรุง20% maint หักค่าสาธารณูปโภค 5% pub เงินคงเหลือ remain

1.6 ลำดับขั้นตอนการทำงาน (action) 1. พิมพ์หัวรายงาน 2. ป้อนข้อมูล ชื่อโครงการวิจัย(name) งบประมาณ(budget) 3. เงินหักค่าบำรุง 20% คำนวณตามสมการดังนี้ maint = budget * 20/100 4. หักเงินค่าสวาธารณูปโภค คำนวณตามสมการดังนี้ pub = (budget - maint)*5/100 5. เงินคงเหลือ คำนวณตามสมการดังนี้ remain = budget – maint – pub 6. พิมพ์ค่า maint , pub , remain 7. จบการทำงาน

คำนวณ pub = (budget-maint)*5/100 คำนวณ remain= budget-maint-pub start ผังงานที่ 2.12 พิมพ์ heading ป้อนค่า name,budget คำนวณ maint= budget*20/100 คำนวณ pub = (budget-maint)*5/100 คำนวณ remain= budget-maint-pub พิมพ์ maint,pub,remain end

โปรแกรมที่ 2.12 ส่วนกำหนดคุณสมบัติ ส่วนป้อนข้อมูล ส่วนประมวลผล #include<stdio.h> #include<stdlib.h> int main(int argc, char *argv[]) { char name[40]; float budget,maint,pub,remain; printf("*Report Thank you Company*\n\n"); printf("----------------------\n"); printf("Project name=");scanf("%s",name); printf("\n"); printf("Budget=");scanf("%f",&budget); maint=budget*20/100; pub=(budget-maint)*50/100; remain=budget-maint-pub; printf("\n **Maintenance=%.2f \n",maint); printf("\n**Public utility = %.2f \n",pub); printf("\n ** Remain = %.2f \n",remain); system("PAUSE"); return 0; } ส่วนกำหนดคุณสมบัติ ส่วนป้อนข้อมูล ส่วนประมวลผล ส่วนแสดงผล

ผลการทดสอบโปรแกรม * Report Thank you Company * ------------------------------------------------- Project name = cai Budget = 90000 -------------------------------------------------- ** Maintenance = 18000.00 ** Public utility = 3600.00 ** Remain = 68400.00 ---------------------------------------------------- Press any key to continue ป้อนข้อมูลเข้าระบบ ผลการประมวลผล หลักการคำนวณตาม นิพจน์

แนวคิดในการเขียนคำสั่ง 1. วิเคราะห์คุณสมบัติหน่วยความจำ ด้วยการกำหนดชื่อตัวแปรและชนิดข้อมูลchar name[40]; float budget , maint , pub , remain ; 2. ส่วนป้อนข้อมูล เขียนคำสั่งควบคุมการนำเข้า หน่วยความจำตัวแปร printf(“Project name = ”);scanf(“%s”,name); printf(“Budget = ”);scanf(“%f”&budget); 3. ส่วนประมวลผล เขียนคำสั่งควบคุมประมวลผลนิพจน์ Maint=budget *20/100; pub = (budget-maint)*5/100; remain = budget – maint – pub ; 4. ส่วนแสดงผล เขียนคำสั่งควบคุมการแสดงผลจากตัวแปร printf(“\n ** Mainternance = %.2f \n”,maint); printf(“\n ** Public utility = %.2f \n”,pub); printf(“\n ** Remain = %.2f \n”,remain);

end