ภาษาซี เป็นภาษาคอมพิวเตอร์ ที่ใช้เขียนโปรแกรมคอมพิวเตอร์ ที่มีประสิทธิภาพสูงมาก มีผู้ผลิตหลายบริษัทที่ผลิตโปรแกรม(compiler)ที่ใช้เปลี่ยนชุดคำสั่งที่เขียนในรูปแบบของภาษาซีไปเป็นภาษาเครื่องที่สั่งให้คอมพิวเตอร์ทำงานตามต้องการได้ เช่น ไมโครซอฟต์ อินไพรส์(เดิมชื่อบอร์แลนด์) เป็นต้น และแต่ละบริษัทอาจมีในหลายชื่อหลายรุ่น ซึ่งแต่ละรุ่นอาจมีความแตกต่างกันบ้าง แต่ส่วนใหญ่จะเป็นไปตามมาตรฐานของสถาบัน ANSI (American Standard National Institute) ซึ่งได้กำหนดมาตรฐานของภาษาซีไว้ ภาษาซีที่เป็นตามมาตรฐานทุกประการเรียกว่า ANSI C ในการเรียนการสอนรายวิชานี้ใช้ของบริษัทอินไพรส์ คือ Borland C/C++ 5.5 ซึ่งเป็นโปรแกรมที่แจกฟรีโดยการ download จากเว็บไซต์ของบริษัทแต่ไม่ได้แจก โปรแกรมที่ใช้สร้างชุดคำสั่ง(ที่เรียกว่า editor) มาให้แต่บอกแหล่งที่แจกโปรแกรม editor ซึ่งไม่ใช่ของบริษัทอินไพรส์ให้ เช่น โปรแกรม SC1.EXE ซึ่งใช้ในการเรียนการสอนวิชานี้ แต่ปกติก็สามารถใช้โปรแกรมประเภท text editor เช่น notepad เขียนชุดคำสั่งได้
ขั้นตอนการสร้างโปรแกรมจากภาษาซี
- 1. เขียนโปรแกรมต้นฉบับ (source program หรือ source code) และบันทึกโดยระบุส่วนขยายของไฟล์ เป็น .c เช่น pro1.c
- 2. แปลโปรแกรมต้นฉบับเป็นโปรแกรมภาษาเครื่อง(object program) ซึ่งมีส่วนขยายเป็น .obj เช่น pro1.obj ซึ่งขั้นตอนนี้เป็นการทำงานของ compiler
- 3. เชื่อมโยงฟังก์ชัน(library function)ในห้องสมุดของฟังก์ชันที่โปรแกรมที่สร้างมีการเรียกใช้เข้ากับโปรแกรมภาษาเครื่อง ซึ่งขั้นตอนนี้เป็นการทำงานของ linker จะได้โปรแกรม(execute program )ที่สามารถทำงานได้ตามลำพัง ได้เป็นไฟล์ที่มีส่วนขยายเป็น .EXE เช่น pro1.exe
- 4. ให้โปรแกรม execute program ที่ได้ทำงาน(run)โดยการป้อนชื่อโปรแกรมนั้น เช่น pro1.exe
โครงสร้างของโปรแกรมที่เขียนด้วยภาษา C
โปรแกรมที่เขียนด้วยภาษา C จะมีโครงสร้าง อย่างง่าย ดังนี้
#include <library> หรือ header file
ส่วนประกาศ หรือ declaration part ส่วนนี้ใช้ประกาศตัวแปร ค่าคงที่ ชนิดของข้อมูล แบบ global
main() ฟังก์ชันหลักของโปรแกรม
{
คำสั่งต่าง ๆ ค่าคงที่ ฯลฯ
}
ฟังก์ชันย่อย (sub function)
{
คำสั่งต่าง ๆ ค่าคงที่ ฯลฯ
}
ไฟล์ส่วนหัว(header file) ประกอบด้วย #include ซึ่งจัดเป็น preprocessor directives เมื่อคอมไพล์โปรแกรม compiler ยังไม่ต้องการ source code แต่จะเรียก preprocessor เพื่อตรวจสอบ source ว่ามีการเรียกใช้ฟังก์ชันใดบ้างมีอยู่ในheader file ที่เรียกใช้หรือไม่ header file จะมีส่วนขยายเป็น .h จะเป็นที่เก็บรวบรวมฟังก์ชันใน library โดยที่แต่ละ header file จะจัดเก็บฟังก์ชันต่าง ๆ ไว้ แตกต่างกันไป เช่น stdiol.h จะเกี่ยวฟังก์ชันต่าง ๆที่เกี่ยวกับ I/O ต่าง ๆ โดย preprocessor directives จะเริ่มต้นด้วย # และไม่ต้องจบด้วย เครื่องหมาย ; เพราะไม่ใช่คำสั่งหรือฟังก์ชัน โดย directive มีหลายตัว เช่น include , define โดยการเขียนโปรแกรมบางครั้งอาจต้องเรียกใช้ header file หลายไฟล์เพราะมีการเรียกใช้ฟังก์ชันที่อยู่ใน library ที่เก็บไว้โดย header file ต่างกัน
Declaration part เป็นส่วนที่ใช้ในการประกาศ ชนิด ค่าของตัวแปร ค่าคงที่ ที่เป็นแบบ global เพราะถูกเรียกไปใช้ได้ในทุก ๆ ฟังก์ชัน ของโปรแกรม ในส่วนนี้ยังเป็นที่ใช้ประกาศว่ามีฟังก์ชันย่อยใดบ้างในโปรแกรม
main() เป็นฟังก์ชันหลักของโปรแกรม ซึ่งต้องมีอย่างน้อย 1 ฟังก์ชัน การทำงานของฟังก์ชันนี้นอกจากใช้คำสั่งต่าง ๆ ใช้ฟังก์ชันต่าง ๆ จาก library แล้วยังสามารถเรียกใช้ฟังก์ชันย่อย ๆ ต่าง ๆ ได้
ฟังก์ชันย่อย (sub function) เป็นฟังก์ชันที่มีการสร้างขึ้นเพื่อให้โปรแกรมเพื่อให้โปรแกรมสามารถทำงานได้ตามต้องการ
สิ่งควรรู้เป็นเบื้องต้นของภาษา C
1. ฟังก์ชัน main() จะไม่ส่งค่าให้ฟังกชันอื่น ๆ และไม่ต้องรับค่า จึงอาจเขียนว่า void main(void) โดย void หมายความว่าไม่ส่งค่ากลับไป ส่วน(void) หมายความว่าไม่มีอาร์กูเมนต์(argument) คือไม่ต้องรับค่า
2. ขอบเขตของฟังก์ชัน จะเริ่มต้นด้วยเครื่องหมาย { และสิ้นสุดขอบเขตด้วยเครื่องหมาย } นั่นคือจะเขียนฟังก์ชันใดต้องเริ่มต้นด้วย { และจบด้วย } ทำนองเดียวกันกับเมื่อนำคำสั่งหลาย ๆ คำสั่งมาประกอบกันเป็นชุดเดียวกันก็จะเริ่มด้วย { และจบด้วย } เช่นเดียวกัน
3. คำสั่งแต่ละคำสั่งจะต้องจบด้วยเครื่องหมาย ; (semicolon)
4. ชื่อฟังก์ชันและคำสั่งต่าง ๆ ในภาษาซีจะต้องใช้ตัวอักษรตัวเล็ก (lowercase)
- 5. ชื่อตัวแปรจะใช้ตัวอักษรตัวเล็กหรือตัวอักษรตัวใหญ่(uppercase) ก็ได้และภาษา C จะถือว่าตัวอักษรตัวเล็กตัวใหญ่ต่างกัน (case sensitive) ตัวแปรในฟังก์ชันต่างกันอาจชื่อเหมือนกันได้แต่ในฟังก์ชันเดียวกันจะมีตัวแปรชื่อเหมือนกันไม่ได้
ตัวอย่างโปรแกรม
/* นี่คือตัวอย่าง */ หรือ // ตัวอย่างนะจ๊ะ
#include <stdio.h> /* บรรทัดที่1 */
main() // บรรทัดที่ 2
{ /* บรรทัดที่3 */
printf("Bodindecha is a school in Bangkok. \n"); // บรรทัดที่4
} // บรรทัดที่ 5
บรรทัดที่ 1 #include <stdio.h> เป็นการเรียกใช้แฟ้มที่บรรจุความหมายรูปแบบของฟังก์ชันที่จำเป็นต้องใช้ในที่นี้คือ printf() อยู่ในแฟ้มนี้
บรรทัดที่ 2ไม่มีชนิดของฟังก์ชันนำหน้าชื่อ main และ ไม่มีอาร์กูเมนต์ในวงเล็บ หรือ อาจเขียน เป็น void main(void) แสดงว่าไม่มีการส่งค่าจากฟังก์ชันนี้และไม่มีการรับค่าที่ส่งมา
บรรทัดที่ 3 { บอกว่าฟังก์ชัน main() มีจุดเริ่มตั้งแต่ตำแหน่งนี้
บรรทัดที่ 4 เป็นการให้พิมพ์คำว่า Bodindecha is a school in Bangkok.ที่จอภาพแล้วให้ขึ้นบรรทัดใหม่ (\n)
บรรทัดที่ 5 } แสดงว่าสิ้นสุดขอบเขตของฟังก์ชัน main()
ส่วนเครื่องหมาย /* ................. */ ใช้สำหรับเขียนหมายเหตุในโปรแกรม โดย compiler จะไม่ดำเนินการกับข้อความที่อยู่ระหว่างเครื่องหมาย /* */ ในกรณีที่หมายเหตุอยู่ในบรรทัดเดียว อาจใช้นำหน้าด้วย // บอกให้รู้ว่าสิ่งที่อยู่ต่อจาก // compiler จะไม่ดำเนินการกับข้อความเหล่านั้น
องค์ประกอบพื้นฐานของภาษา C
อักขระ(characters) ค่าคงที่(constants) ตัวแปร(variables) ตัวดำเนินการ(operators) นิพจน์(expressions)
Characters แบ่งเป็น
ตัวเลข (digits) คือ ตัวเลข 0 ถึง 9 และเลขฐานสิบหก คือ A B C D E และ F
ตัวอักษร(letters) คือตัวอักษรในภาษาอังกฤษ เป็นตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก คือ A-Z และ a-z
อักขระพิเศษ(special characters) คือ ! * + " < # ( = | > % ) ~ : / ^ - [ ; ? , & _ ] ' . space ในภาษาซี ถือว่า เครื่องหมายขีดเส้นใต้เป็นตัวอักษร ตัวหนึ่ง characters ต่าง ๆ นี้จะใช้เป็นค่าคงที่ ตัวแปร ตัวดำเนินการ
Constants เป็นค่าที่มีค่าไม่เปลี่ยนแปลง แบ่งเป็น
ค่าคงที่ประเภทเลขจำนวนเต็ม (integer constant) คือเลขจำนวนเต็ม ที่อยู่ระหว่าง -32768 ถึง 32767 เช่น -25 หรือ 0 หรือ 236 ค่าเหล่านี้แต่ละค่าใช้หน่วยความจำในการเก็บ 2 ไบต์ ค่าเหล่านี้เขียนในรูปเลขฐานสิบ ฐานแปด(เขียนโดยใช้เลขศูนย์นำหน้า เช่น 045) เลขฐานสิบหก(เขียนโดย ใช้เลขศูนย์และx นำหน้า เช่น 0x28 0X2AF)
ค่าคงที่ชนิดตัวเลขทศนิยม(floating point constants) เป็นตัวเลขทศนิยม เช่น 1.0 1.6 E+09 ค่านี้ใช้หน่วยความจำในการเก็บค่าละ 4 ไบต์ และมีค่าอยู่ในช่วง 1.2 E -38 ถึง 3.4E+38 โดย 3 ไบต์แรกเก็บค่าตัวทศนิยม ส่วนไบต์สุดท้ายเก็บเลขยกกำลัง
ค่าคงที่ชนิดตัวเลขทศนิยมความละเอียดสองเท่า (double floating point) เรียกสั้น ๆ ว่า double เก็บจำนวน 2.2E-308 ถึง 1.8E+308 เท่านั้น ใช้หน่วยความจำ 8 ไบต์ 7 ไบต์แรกเก็บเลขทศนิยม ไบต์สุดท้ายเก็บเลขยกกำลัง
ค่าคงที่ชนิดตัวอักขระ (single character constant) เก็บตัวอักขระ 1 ตัว โดยใช้เครื่องหมาย ' และ ' ล้อม 1 ตัวอักขระใช้ 1 ไบต์ เช่น 'E' 'X'
ค่าคงที่ชนิดข้อความ (string constant) ใช้เก็บข้อความ มีความยาวตั้งแต่ 1 ตัวอักขระ เก็บในรูปอาร์เรย์ แต่ละตัวใช้หน่วยความจำ 1 ไบต์ เรียงต่อกันโดยไบต์สุดท้ายจะต้องเก็บ \0 (null charactor) เพื่อบอกว่าจบข้อความแล้ว เช่น "Bodindecha" ใช้หน่วยความจำ 11ไบต์
ตัวแปร(variables)
เป็นชื่อที่ตั้งเพื่อใช้อ้างอิงถึงข้อมูลต่าง ๆ โดยตัวแปรจะมีการใช้เนื้อที่ในหน่วยความจำในปริมาณที่ต่างกันขึ้นกับชนิดของข้อมูล ข้อมูล พื้นฐานในภาษาซี มี 5 ชนิด คือ อักขระ (char) จำนวนเต็ม(int) จำนวนจริง(float) จำนวนจริงละเอียด2เท่า(double) ไม่ให้ค่าใด ๆ (void) นอกจากนี้เพื่อความสามารถในการใช้งานจึงมีการเพิ่มชนิดของตัวแปรขึ้นมาดังตาราง
ตารางแสดงชนิดของตัวแปร
คำประกาศชนิดของตัวแปร | เครื่องหมาย | จำนวนไบต์ที่ใช้ | ค่าที่เป็นไปได้ |
char | คิดเครื่องหมาย | 1 | -128 ถึง 128 |
int | คิดเครื่องหมาย | 2 | -32768 ถึง 32767 |
short | คิดเครื่องหมาย | 2 | -32768 ถึง 32767 |
long | คิดเครื่องหมาย | 4 | -2147483648 ถึง 2147483647 |
unsigned char | ไม่คิดเครื่องหมาย | 1 | 0 ถึง 255 |
unsigned int | ไม่คิดเครื่องหมาย | 2 | 0 ถึง 65535 |
unsigned short | ไม่คิดเครื่องหมาย | 2 | 0 ถึง 65535 |
unsigned long | ไม่คิดเครื่องหมาย | 4 | 0 ถึง 4294967295 |
float | คิดเครื่องหมาย | 4 | 3.4E-38 ถึง 3.4E+38 |
double | คิดเครื่องหมาย | 8 | 1.7E-308 ถึง 1.7E+308 |
long double | คิดเครื่องหมาย | 10 | 3.4E-4932 ถึง 1.1E+4932 |
การตั้งชื่อตัวแปร
1. ต้องขึ้นต้นด้วยตัวอักษรเท่านั้น ตัวต่อไปจะเป็นตัวเลขหรือตัวอักษรได้ ความยาวไม่เกิน 31 ตัว
2. ชื่อตัวแปรควรสื่อความหมายของตัวแปรเพื่อป้องกันความสับสนของการพิจารณาโปรแกรม
3.ห้ามตั้งชื่อตรงกับคำสงวนในภาษาซี ซึ่งมี 33 คำ ดังนี้
asm auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while
การประกาศตัวแปร
ในการจะใช้งานตัวแปรจะต้องมีการประกาศชนิดและชื่อของตัวแปรนั้นก่อน โดยการประกาศตัวแปรใช้รูปแบบ คือ ชนิดของตัวแปร ชื่อตัวแปร โดยถ้ามีตัวแปรชนิดเดียวอาจประกาศพร้อมกันโดยใช้ คอมมา คั่นระหว่างชื่อของตัวแปร ถ้ามีการกำหนดค่าให้ใช้เครื่องหมาย = และใช้เครื่องหมายแสดงการจบคำสั่งเมื่อสิ้นสุด คำสั่ง ตัวอย่าง เช่น
char name, day = 'S' , surname[20] ="Kodedee";
int x=5 ,y,z[100]; float a=5.00 ,b,c; double k=1.234567, m ;
ตัวดำเนินการ(operator)
ตัวดำเนินการมีหลายประเภทลักษณะการดำเนินการแตกต่างกันไป ในที่นี้จะกล่าวถึงบางประเภทเท่านั้น
ตัวดำเนินการทางคณิตศาสตร์ (mathematical operators)
สัญลักษณ์ | การดำเนินการ | ตัวอย่าง |
+ | การบวก | 2+5 ผลลัพธ์ 7 |
- | การลบ | 7-4 ผลลัพธ์ 3 |
* | การคูณ | 2*6 ผลลัพธ์ 12 |
/ | การหาร | 8/2 ผลลัพธ์ 4 |
% | การหารหาเศษ | 9%4 ผลลัพธ์ 1 |
ตัวดำเนินการความสัมพันธ์หรือการเปรียบเทียบ (relational operators)
สัญลักษณ์ | การดำเนินการ | ตัวอย่าง |
< | น้อยกว่า | 2<3 ผลลัพธ์ จริง(1) |
> | มากกว่า | 2>3 ผลลัพธ์ เท็จ(false)(0) |
<= | น้อยกว่าหรือเท่ากับ | 2<= 3 ผลลัพธ์ จริง(true) |
>= | มากกว่าหรือเท่ากับ | 2>= 3 ผลลัพธ์ เท็จ(false) |
== | เท่ากับ | 4==4 ผลลัพธ์ จริง(true) |
!= | ไม่เท่ากับ | 2!= 2 ผลลัพธ์ เท็จ(false) |
ตัวดำเนินการตรรกะ (logical operators)
สัญลักษณ์ | การดำเนินการ | ตัวอย่าง |
&& | และ(AND) | (2<3)&&(3>1) ผลลัพธ์ จริง |
|| | น้อยกว่า(OR) | (2>3)||(4<1) ผลลัพธ์ เท็จ(false) |
! | ไม่(NOT) | !(2> 3) ผลลัพธ์ จริง(true) |
ตัวดำเนินการกำหนดค่า (assignment operators)
สัญลักษณ์ | การดำเนินการ | ตัวอย่าง |
= | กำหนดค่า(assignment) | a=2 ความหมายคือ กำหนดให้a มีค่าเป็น2 |
+= | การบวก(addition) | a+=b ความหมายคือ(a=a+b) |
*= | การคูณ(multiplication) | a*=b ความหมายคือ(a=a*b) |
-= | การลบ(subtraction) | a-=b ความหมายคือ(a=a-b) |
/= | การหาร(division) | a/=b ความหมายคือ(a=a/b) |
%= | การหารหาเศษ(remainder) | a%=b ความหมายคือ(a=a%b) |
++ | เพิ่มค่า(increment) | a++ หรือ ++a ความหมายคือ a=a+1 |
-- | ลดค่า(decrement) | a-- หรือ --a ความหมายคือ a=a-1 |
ลำดับการดำเนินการของตัวดำเนินการ (operator precedence)
ลำดับที่ | ตัวดำเนินการ | ลักษณะการทำงาน |
1 | ( ) [ ] . -> | ซ้าย ไป ขวา |
2 | - ~ | * & | ขวา ไป ซ้าย |
3 | ++ -- | ขวา ไป ซ้าย |
4 | * / % | ซ้าย ไป ขวา |
5 | + - | ซ้าย ไป ขวา |
6 | << >> | ซ้าย ไป ขวา |
7 | < > <= >= | ซ้าย ไป ขวา |
8 | == != | ซ้าย ไป ขวา |
9 | &(bitwise AND) | ซ้าย ไป ขวา |
10 | ^(bitwise XOR) | ซ้าย ไป ขวา |
11 | |(bitwise OR) | ซ้าย ไป ขวา |
12 | && | ซ้าย ไป ขวา |
13 | || | ซ้าย ไป ขวา |
14 | ?: | ซ้าย ไป ขวา |
15 | = += -= /= %= | ขวา ไป ซ้าย |
16 | <<= >>= | ขวา ไป ซ้าย |
โดยตัวดำเนินการที่มีลำดับน้อยกว่าจะดำเนินก่อนตัวดำเนินการที่มีลำดับสูงกว่า เช่น
X = 2 + 5 * 3 จะมีลำดับการดำเนินการ คือ
ลำดับที่ 1 5 * 3 (เพราะ * มีลำดับเป็น 4 ส่วน + อยู่ลำดับ 5)
ลำดับที่ 2 2 + 15
ลำดับที่ 3 17 เป็นค่าของ X
นิพจน์ (expression)
เกิดจากการนำ ค่าคงที่ หรือ ตัวแปร และตัวดำเนินการมาประกอบกัน โดยนิพจน์มีหลายชนิด เช่นนิพจน์ทางคณิตศาสตร์ นิพจน์ทางตรรกะ นิพจน์ทางการเปรียบเทียบ นิพจน์เกี่ยวกับเงือนไข นิพจน์เกี่ยวกับข้อความ เช่น
2 + x * 5 เป็นตัวอย่างของนิพจน์ทางคณิตศาสตร์ (2>3)&&(5>=4) เป็นนิพจน์ทางตรรกะและการเปรียบเทียบ !(a) เป็นนิพจน์ทางตรรกะ if(x==y) เป็นนิพจน์เงื่อนไข
ตัวอย่าง การหาผลลัพธ์ของนิพจน์
กำหนด int a = 10 , b = 12, c =3; จงหาผลลัพธ์ของ 2 * a + b % c ดำเนินการดังนี้ (2 * a) + (b %c) ผลลัพธ์ คือ 20 + 0 คือ 20
จากข้อกำหนดด้านบน จงหาผลลัพธ์ ของ (a>b)&&(c<=b) ซึ่งเราอาจพิจารณา ดังนี้
(เท็จ)&& (จริง) ดังนั้น ผลลัพธ์ คือ เท็จ
จากความรู้ที่เรียนมาในใบความรู้ที่ 1 และ 2 ควรจะเขียนโปรแกรมเป็นภาษาซีได้บ้างแล้ว
ตัวอย่าง กำหนดให้ x y z เป็นจำนวนเต็ม จงเขียนโปรแกรม หา ค่า ของ z ที่มีความสัมพันธ์กับ x y เป็นสมการทางคณิตศาสตร์ ดังนี้ z = 5x + 10y โดย x มีค่าเป็น 6 ส่วน y มีค่า 7 และแสดงผลลัพธ์ทางจอภาพ
โปรแกรม อาจเป็นทำนองนี้
/* program name 2_1_1.c */
#include <stdio.h>
int x = 6,y=7,z;
main()
{
z = (5 * x) +( 10 * y);
printf("value of x = %d \t value of y = %d \t value of z = %d",x,y,z);
}
หรือ
/* program name 2_1_1.c */
#include <stdio.h>
int x = 6,y=7,z;
main()
{
printf("value of x = %d \t value of y = %d \t value of z = %d",x,y,5*x+10*y);
}
การแสดงผล (Output)
การแสดงผลลัพธ์ ปกติก็คือแสดงออกทางจอภาพ ในภาษาซีใช้ในรูปของฟังก์ชัน เช่นเดียวกับงานอื่น ๆ โดยฟังก์ชันมาตรฐานที่มีใน library ฟังก์ชันที่ใช้แสดงผลทางจอภาพ เช่น printf() ,puts() , putchar() ฟังก์ชัน เหล่านี้อยู่ใน header file ชื่อ stdio.h
ฟังก์ชัน printf()
เป็นฟังก์ชันที่ใช้แสดงผลลัพธ์ออกทางจอภาพ การแสดงผลทางจอภาพด้วยฟังก์ชันนี้สามารถกำหนดรูปแบบและรหัสควบคุมได้ โดยฟังก์ชัน printf() มีรูปแบบ ดังนี้
printf(control string,argument list);
โดย control string รวมทั้งข้อความ รหัสกำหนดรูปแบบ รหัสควบคุม ทั้งหมดนี้ ต้องล้อมด้วยเครื่องหมาย คำพูด (") ส่วนargument list เป็นรายการของตัวแปร ค่าคงที่ หรือนิพจน์ที่จะแสดงออกทางจอภาพ หากมี ตัวแปร ค่าคงที่ หรือนิพจน์ มากกว่า 1 ค่า แต่ละค่าจะคั่นด้วยเครื่องหมาย คอมม่า(,)
รหัสกำหนดรูปแบบ(format code) เป็นรหัสกำหนดรูปแบบของตัวแปร ค่าคงที่ หรือนิพจน์ที่จะแสดงผล เช่น แสดงค่าเลขจำนวนเต็ม หรือจำนวนจริง อักขระ ข้อความ ฯลฯ ส่วนรหัสควบคุม(control code)เป็นตัวกำหนดว่าเมื่อแสดงผลแล้วลักษณะของการแสดงผลครั้งต่อไปจะเปลี่ยนเป็นอย่างไร หรือใช้แสดงผลอักขระหรือสัญลักษณ์พิเศษบางตัว
รหัสรูปแบบที่ใช้กับฟังก์ชัน printf() จะเริ่มด้วยเครื่องหมาย % ดังตารางแสดงต่อไปนี้
รหัสรูปแบบ | ความหมายหรือหน้าที่ของรหัสรูปแบบ |
%c | ใช้กำหนดตำแหน่งที่จะแสดง อักขระ 1 ตัว (single character) |
%d | ใช้กำหนดตำแหน่งแสดงเลขจำนวนเต็ม(integerหรือ int ) 1 จำนวนในรูปเลขฐานสิบ |
%e | ใช้แสดงตัวเลขที่เป็นจุดทศนิยม (floating point ,float)ในรูป e เช่น 2.15e+2 คือแทนค่า215 |
%f , %lf | ใช้กับข้อมูลเป็น float และ double |
%g | ใช้กับข้อมูล float |
%h | ใช้กับ short integer |
%o(ตัวโอ) | ใช้แสดง integer ในรูปเลขฐานแปด |
%x | ใช้แสดง integer ในรูปเลขฐานสิบหก |
%s | ใช้แสดงข้อความ |
%p | ใช้แสดง address ของตัวแปรพอยน์เตอร์ |
รหัสควบคุมที่ใช้กับ printf() (นำหน้าด้วยเครื่องหมาย \ )
รหัสควบคุม | ความหมาย |
\a | ส่งเสียงบี๊พ |
\b | ลบตัวอักษรที่อยู่ด้านซ้าย1ตำแหน่ง (backspace) |
\t | เลื่อนตำแหน่งในการพิมพ์ครั้งต่อไป 1 แท็บ(แนวราบ horizontal) |
\n | ขึ้นบรรทัดใหม่ |
\v | เลื่อนตำแหน่งไป 1 แท็บแนวดิ่ง |
\r | เลื่อนไปต้นบรรทัด |
\" | แสดงเครื่องหมาย " |
\' | แสดงเครื่องหมาย ' |
\? | แสดงเครื่องหมาย ? |
\\ | แสดงเครื่องหมาย \ |
ฟังก์ชัน putchar()
เป็นฟังก์ชันที่ใช้แสดงอักขระครั้งละ 1 ตัว ทางจอภาพ รูปแบบของฟังก์ชัน คือ
Putchar(character);
ฟังก์ชัน puts()
ใช้แสดงข้อความ(ไม่ใช่อักขระ)ออกทางจอภาพ รูปแบบของฟังก์ชัน คือ
puts(string);
ฟังก์ชันรับข้อมูล (Input function)
ฟังก์ชัน getchar()
เป็นฟังก์ชันที่ใช้รับข้อมูลเป็นตัวอักขระจำนวน 1 ตัวจากแป้นพิมพ์และอักขระนั้นจะปรากฏบนจอภาพ ด้วยและต้องเคาะแป้น enter เพื่อแสดงว่าป้อนข้อมูลแล้ว แต่ในการกำหนดตัวแปรมารับค่าถ้าใช้เป็น int
จะไม่มีการฟ้องการผิดพลาด โดยค่าจำนวนเต็มที่รับจากการเคาะแป้นพิมพ์จะเป็นรหัส ASCII ของ ตัวอักษรนั้น เช่น A จะเป็น 65 แต่ถ้าตัวแปรที่มารับค่าเป็น char จะมี warning ในเรื่องการเปลี่ยนประเภทตัวแปร แต่ค่าที่จะแสดงออกมาจะตรงตามที่มีการเคาะแป้น และจะมีปัญหาเมื่อมีการใช้ฟังก์ชันนี้มากกว่า 1 ครั้ง
ฟังก์ชัน getch()
ใช้รับตัวอักขระ 1 ตัวจากแป้นพิมพ์ แต่ขณะรับไม่แสดงทางจอภาพและไม่ต้องเคาะแป้น enter
แล้ว แต่ในการกำหนดตัวแปรมารับค่าถ้าใช้เป็น int จะไม่มีการฟ้องการผิดพลาด โดยค่าจำนวนเต็มที่ตัวแปรได้รับมาเป็นค่ารหัส ASCII ของตัวอักขระ ที่เคาะแป้นพิมพ์ เช่น C เป็น 67 แต่ถ้าตัวแปรที่มารับค่าเป็น char จะมี warning ในเรื่องการเปลี่ยนประเภทตัวแปร แต่ค่าที่ได้จะแสดงออกมาได้ถูกต้อง
ฟังก์ชัน getche()
รับตัวอักขระจากแป้นพิมพ์ 1 ตัว โดยแสดงออกทางจอภาพด้วยและไม่ต้องเคาะแป้น enter ลักษณะการทำงานเป็นไปในลักษณะเดียวกับ getche() ต่างกันที่แสดงออกทางจอภาพหรือไม่เท่านั้น
ฟังก์ชัน gets()
ใช้รับข้อความจากแป้นพิมพ์ มาเก็บไว้ในชื่อตัวแปรที่กำหนด โดยเคาะแป้น enter แสดงการจบการป้อนข้อมูล มีรูปแบบ คือ gets(string_var);
โดย string_var คือ ชื่อตัวแปรที่ใช้เก็บข้อมูลที่รับมาจากการป้อนทางแป้นพิมพ์ เป็นตัวแปรประเภทข้อความ และสามารถแยกเป็นตัวอักขระได้ ทั้งหมดนี้ให้พิจารณาจากใบงาน
ฟังก์ชัน scanf()
เป็นฟังก์ชันที่ใช้รับข้อมูลประเภทต่าง ๆ จากแป้นพิมพ์ได้กว้างขวางกว่าฟังก์ชันอื่น ๆ ที่ผ่านมา ข้อมูลที่รับ เช่น จำ นวนเต็ม จำนวนจริง ข้อความ อักขระ รูปแบบของฟังก์ชัน คือ scanf(control string ,variable list);
control string เป็นรหัสสำหรับรูปแบบของข้อมูลที่จะรับเข้า โดยรหัสรูปแบบนี้เป็นทำนองเดียวกับฟังก์ชัน printf() โดยรหัสนี้ทังหมดจะต้องอยู่ภายในเครื่องหมายพูด รหัสแต่ละตัวจะแทนข้อมูลแต่ละค่า โดยสามารถมีรหัสของข้อมูล หลายค่าได้ในครั้งเดียวกันโดยไม่จำเป็นต้องมีเครื่องหมายอื่นใดมาคั่น
variable list คือรายการของชื่อตัวแปรที่จะมารับค่าของข้อมูลที่ป้อนจากแป้นพิมพ์ โดยตัวแปรต้องประเภทเดียวกับข้อมูลที่ตัวแปรนั้นรับ และจำนวนตัวแปรจะต้องมีจำนวนเท่ากับจำนวนรหัสรูปแบบของข้อมูล โดยชื่อตัวแปรนั้นอยู่หลังจากเครื่องหมายคำพูดที่ล้อมรหัสข้อมูลโดยมีการคั่นด้วยเครื่องหมายคอมม่า(,)และหากมีตัวแปรหลายตัวแต่ละตัวจะคั่นด้วยเครื่องหมายคอมม่าเช่นกัน และหน้าชื่อตัวแปรแต่ละตัวจะต้องนำด้วยเครื่องหมาย & ยกเว้นตัวแปรของข้อมูลประเภทข้อความ(string) เช่น คำสั่ง
scanf("%d %f %s",&i,&f1,word);
เป็นคำสั่งให้รับข้อมูลจากแป้นพิมพ์ 3 ค่า เป็นข้อมูลประเภท จำนวนเต็มแบบเลขฐานสิบ ตามด้วยข้อมูลเลขทศนิยม และข้อมูลประเภทข้อความ โดยมีตัวแปรชื่อ i , f1 และ word ซึ่งเป็นแปรตัวประเภท จำนวนเต็ม จำนวนทศนิยม และตัวแปรข้อความตามลำดับ มารับค่าของข้อมูลเหล่านั้น รหัสข้อมูลที่ใช้ในฟังก์ชัน scanf() เป็นดังรายการ
รหัสรูปแบบ | ความหมายในการใช้ |
%c | สำหรับข้อมูลประเภทตัวอักขระ ( character) |
%d | สำหรับข้อมูลจำนวนเต็มในรูปเลขฐานสิบ |
%e | สำหรับข้อมูลประเภททศนิยม( floating point) ที่เขียนในรูปเลขยกกำลัง |
%f %lf | สำหรับจำนวนประเภท float และ double |
%g | ใช้กับข้อมูลประเภท float |
%h | สำหรับข้อมูลประเภท short integer |
%l | สำหรับข้อมูลประเภท integer ทั้งเลขฐาน 8 ฐาน 10 และฐาน 16 |
%o | สำหรับข้อมูลประเภท integer เลขฐาน 8 เท่านั้น |
%u | สำหรับข้อมูลประเภท unsigned integer เลขฐาน 10 เท่านั้น |
%x | สำหรับข้อมูลประเภท integer เลขฐาน 16 เท่านั้น |
%s | สำหรับข้อมูลประเภทข้อความ (string) |
คำสั่งทำซ้ำ(เมื่อทราบจำนวนรอบของการทำงาน) (for statement)
คำสั่ง for เป็นคำสั่ง(statement) ให้ทำซ้ำโดยมีเงื่อนไข ปกติใช้การเพิ่มค่าหรือลดค่าของตัวนับ ทำซ้ำไปเมื่อเงื่อนไขที่กำหนดเป็นจริง จนกระทั่งเมื่อเงื่อนไขเป็นเท็จให้เลิกทำ รูปแบบของคำสั่ง เป็นดังนี้
for (นิพจน์ที่1;นิพจน์ที่2;นิพจน์ที่3) คำสั่ง 1 คำสั่ง
หรือ for (นิพจน์ที่1;นิพจน์ที่2;นิพจน์ที่3)
{
คำสั่งที่1
คำสั่งที่2
...
คำสั่งสุดท้าย
}
เมื่อ นิพจน์ที่1 เป็นนิพจน์ที่ใช้กำหนดค่าเริ่มต้นให้กับตัวแปรที่ใช้ในการทำซ้ำ
นิพจน์ที่2 เป็นนิพจน์ที่ใช้เป็นเงื่อนไขโดยมีค่าได้เพียง 1 ใน 2 ค่าเท่านั้น คือ เป็นจริง หรือ เท็จ
นิพจน์ที่3 เป็นนิพจน์ที่กำหนดการเพิ่มหรือลดค่าของตัวแปรที่ใช้ในการทำซ้ำ
คำสั่ง(statement )หลัง for ถ้ามีมากกว่า 1 คำสั่ง จะต้องอยู่ภายในเครื่องหมาย { กับ } เพื่อให้รวมเป็นคำสั่งชุดเดียว เนื่องจากในภาษาซีคำสั่งที่อยู่ในการทำซ้ำแบบ for จะต้องมีเพียง 1 คำสั่ง (คำสั่งการทำซ้ำหรือเงือนไขอื่นก็เป็นเช่นเดียวกัน)
คำสั่ง for นี้อาจเขียนเป็นผังงาน ดังนี้
เงื่อนไข- |
เท็จ |
ออกจาก for |
คำสั่งต่าง ๆ |
เพิ่มหรือลดค่าตัวแปรที่ใช้ในการทำซ้ำ |
จริง |
กำหนดค่าเริ่มต้นให้แก่ตัวแปรที่ใช้ในการทำซ้ำ
|
ตัวอย่าง โปรแกรม for1.c
#include <stdio.h>
#include <conio.h>
int counter ;
char word[20] = "Bodindecha";
main()
{
clrscr();
for (counter = 5;counter<=10;counter = counter+1)
printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word);
}
โปรแกรมนี้ จะลบจอภาพ ก่อน แล้วจึงกำหนด เริ่มต้น ให้ counter มีค่าเป็น 5 แล้วทดสอบว่าเงื่อนไข คือ counter <= 10 เป็นจริง หรือไม่ ถ้าเป็นจริง จะทำตามคำสั่ง
printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word);
แล้วจึงทำตามคำสั่ง counter = counter +1 ซึ่งเป็นการเพิ่มค่า ของ counter จากเดิม แล้วตรวจสอบเงื่อนไข ถ้าเป็นจริงก็ทำต่อไปซ้ำกันไปเรื่อยจนกระทั่งนิพจน์เงื่อนไข เป็นเท็จ คือ counter มากกว่า10 จึงออกจากการทำซ้ำ ในตัวอย่างนี้มีการทำซ้ำ 6 รอบ ได้ผลดังรูป
ตัวอย่าง โปรแกรม for2.c
#include <stdio.h>
#include <conio.h>
int row,collumn ;
main()
{
clrscr();
for (row = 1;row<=5;row++) /* บรรทัด 1 */
{ /* บรรทัด 2 */
for(collumn=1;collumn<=4;collumn++) /* บรรทัด 3 */
printf("%d%d \t",row,collumn); /* บรรทัด 4 */
printf("\n"); /* บรรทัด 5 */
} /* บรรทัด 6 */
}
คำอธิบาย
บรรทัด 1 เริ่มต้นกำหนดค่าให้ row เป็น 1 แล้วทดสอบเงื่อนไข row <= 5 เมื่อเป็นจริง จะทำตามบรรทัด 2
ถ้าไม่จริง จะออกจาก for (row = 1;row<=5;row++) นี้และในที่นี้จะจบโปรแกรมไปเลย จากบรรทัด 2 จะไปสู่บรรทัด3 เริ่มต้นจะกำหนดค่า collumn เป็น 1 และทดสอบเงื่อนไข collumn <= 4 ถ้าเป็นจริงจะทำตามคำสั่ง printf("%d%d \t",row,collumn); ถ้าไม่จริงจะออกจาก for(collumn=1;collumn<=4;collumn++) นี้ไปทำตามคำสั่งในบรรทัด 5 คือทำตามคำสั่ง printf("\n"); แล้วกลับเข้าสู่ for (row = 1;row<=5;row++) ซ้ำกันเช่นนี้จนกระทั่งเงื่อนไข row<=5 เป็นเท็จ ก็จะออกจาก for (row = 1;row<=5;row++) และในที่นี้จะจบโปรแกรม
ผลที่ได้จากการ run โปรแกรม for2.exe เป็นดังรูป
คำสั่งทำซ้ำหรือวนรอบ while statement
while เป็นคำสั่งให้มีการทำซ้ำเป็นรอบ ๆ (loop) ลักษณะการทำงานทำนองเดียวกับคำสั่ง for แต่ต่างกันตรงที่ไม่ทราบจำนวนรอบที่แน่นอน แต่ต้องมีเงื่อนไขที่เป็นเท็จจึงจะออกจากคำสั่ง while ได้มิฉะนั้นจะมีปัญหาที่โปรแกรมทำงานแบบวนซ้ำแบบไม่มีที่สิ้นสุด (endless loop)
การทำซ้ำแบบ while อาจเขียนผังงาน ดังรูป
เงื่อนไข- |
เท็จ |
ออกจากคำสั่ง while |
คำสั่งต่าง ๆ |
เปลี่ยนแปลงเงื่อนไขในการทำซ้ำ
|
จริง |
กำหนดเงื่อนไขในการทำซ้ำ
|
คำสั่ง while มีรูปแบบ ดังนี้
while (นิพจน์ทดสอบเงื่อนไข) statement ;
หรือ
while (นิพจน์ทดสอบเงื่อนไข)
{
คำสั่งที่1;
คำสั่งที่2;
...
คำสั่งสุดท้าย;
}
โดย while จะทำการทำซ้ำต่อไปเมื่อนิพจน์ทดสอบเงื่อนไขให้ผลลัพธ์เป็นจริง และทำต่อจนกระทั่งผลลัพธ์ของนิพจน์ทดสอบเงื่อนไขเป็นเท็จ
ตัวอย่าง while statement
/* while1.c */
#include <stdio.h>
#include <conio.h>
int counter ;
char word[20] = "Bodindecha";
main()
{
clrscr();
counter = 5;
while (counter < 11 )
{
printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word);
counter++;
}
}
โปรแกรมนี้ จะลบจอภาพ ก่อน แล้วจึงกำหนด เริ่มต้น ให้ counter มีค่าเป็น 5 แล้ว จึงเข้าสู่การทำซ้ำ แบบ while ทดสอบว่าเงื่อนไข คือ counter < 11 เป็นจริง หรือไม่ ถ้าเป็นจริง จะทำตามคำสั่ง
printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word);
แล้วจึงทำตามคำสั่ง counter++ ซึ่งเป็นการเพิ่มค่า ของ counter จากเดิม แล้วตรวจสอบเงื่อนไข ถ้าเป็นจริงก็ทำต่อไปซ้ำกันไปเรื่อยจนกระทั่งนิพจน์เงื่อนไข เป็นเท็จ คือ counter ไม่น้อยกว่า จึงออกจากการทำซ้ำ ในตัวอย่างนี้มีการทำซ้ำ 6 รอบ ได้ผลดังรูป
ตัวอย่าง while statement
/* while2.c */
#include <stdio.h>
#include <conio.h>
main()
{
int character =65;
clrscr();
while (character != '\r') /* line 1 */ /* start while */
{
printf("\n Enter the character that you want :");
character = getche() ;
printf("\n The ASCII Code of your character is\t%d ",character);
} /* end while */
} /* end main() */
คำอธิบาย โปรแกรมนี้นิพจน์เงื่อนไขของคำสั่ง while คือ character != '\r' หมายความว่า ค่าของ character ไม่ใช่การเคาะแป้น enter โดย character นี้เป็นตัวแปรที่รับค่าการเคาะแป้น จาก คำสั่ง character = getche() ; ดังนั้นถ้าการเคาะแป้นไม่ใช่แป้น enter เงื่อนไขก็จะยังเป็นจริง โปรแกรมจะทำซ้ำ แต่ถ้ามีการเคาะแป้น enter เงื่อนไขก็จะเป็นเท็จ ก็จะออกจากคำสั่ง while ดังนั้น เมื่อ โปรแกรม while2.exe ทำงาน จะได้ผล ดังรูป
คำสั่งทำซ้ำหรือวนรอบ do while statement
do while เป็นคำสั่งให้มีการทำซ้ำเป็นรอบ ๆ (loop) ลักษณะการทำงานทำนองเดียวกับคำสั่ง while แต่ต่างกันตรงที่คำสั่งนี้จะมีการทำงานตามคำสั่งไป 1 รอบ ก่อนที่จะทดสอบเงื่อนไข ถ้าเงื่อนไขที่เป็นจริงจะทำงานต่อไป ถ้าเงื่อนไขเป็นเท็จจึงจะออกจากคำสั่ง do while คำสั่งนี้ก็เช่นเดียวกันจะต้องกำหนดให้มีโอกาสที่เงื่อนไขเป็นเท็จได้ มิฉะนั้นจะมีปัญหาที่โปรแกรมทำงานแบบวนซ้ำแบบไม่มีที่สิ้นสุด (endless loop) กรณีที่เงื่อนไขเป็นเท็จเพียงอย่างเดียวจะมีการทำงาน 1 รอบ ก่อนออกจากการทำซ้ำ
เงื่อนไข- |
เท็จ |
ออกจากคำสั่ง do while |
คำสั่งต่าง ๆ |
จริง |
กำหนดเงื่อนไขในการทำซ้ำ
|
การทำซ้ำแบบ do while อาจเขียนผังงาน ดังรูป
คำสั่ง do while มีรูปแบบ ดังนี้
Do {
คำสั่งที่1;
คำสั่งที่2;
...
คำสั่งสุดท้าย;
} while (นิพจน์ทดสอบเงื่อนไข) ;
โดย do while จะทำการทำซ้ำต่อไปเมื่อนิพจน์ทดสอบเงื่อนไขให้ผลลัพธ์เป็นจริง และทำต่อจนกระทั่งผลลัพธ์ของนิพจน์ทดสอบเงื่อนไขเป็นเท็จ ก็จะออกจากการทำซ้ำ
ตัวอย่าง do while statement
/* dowhile1.c */
#include <stdio.h>
#include <conio.h>
int counter ;
char word[20] = "Bodindecha";
main()
{
clrscr();
counter = 11;
do /* start do while */
{
printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word);
counter++;
} while (counter < 11 ); /* end do while */
} /* end main() */
โปรแกรมนี้ จะลบจอภาพ ก่อน แล้วจึงกำหนด เริ่มต้น ให้ counter มีค่าเป็น 11 แล้ว จึงเข้าสู่การทำซ้ำ แบบ do while ทำตามคำสั่ง printf("counter \t=\t%2d\tmy school is\t%s \n",counter,word); ไปก่อนแล้วจึงทดสอบว่าเงื่อนไข คือ counter < 11 เป็นจริง หรือไม่ จึงได้ผลการทำงานเป็น ดังรูป ทั้งที่เงื่อนไขเป็นเท็จ
ให้ผลทำนองเดียวกับเงื่อนไขเป็นจริง 1 ครั้ง เช่น เมื่อเริ่มด้วย counter = 10 ดังรูป
ให้นักเรียนลองทำดู โดยเปลี่ยนค่า ในโปรแกรม แล้วบันทึกไฟล์แล้วคอมไพล์แล้วลองรันดู
คำสั่งควบคุมการทำงานของโปรแกรม กลุ่มที่มีการทดสอบเงื่อนไขก่อนการตัดสินใจเพื่อทำงานต่อไปตามคำสั่งที่กำหนดไว้ มีหลายคำสั่ง คือ if , if else , if else if , switch คำสั่งเหล่านี้จะมีลักษณะคล้ายกันที่ต้องมีการทดสอบเงื่อนไขเพื่อเลือกเลือกคำสั่งที่จะทำงานต่อไป
คำสั่ง if
เงื่อนไข- |
เท็จ |
ออกจากคำสั่ง if |
คำสั่งต่าง ๆ |
จริง |
คำสั่งนี้เป็นคำสั่งที่มีการทดสอบเงื่อนไขก่อนที่จะทำงานตามคำสั่งที่กำหนด คำสั่งนี้อาจเขียนผังงานได้ดังนี้
รูปแบบของคำสั่ง if เป็น ดังนี้
if (expression) statement ;
หรือ
If (expression)
{
statement 1;
...
statement n;
}
expression ในคำสั่ง if เป็นเงื่อนไขที่มีค่าได้เพียง จริง หรือ เท็จ เท่านั้น ถ้ามีเป็นจริงจะทำตามคำสั่งใน if จากนั้น ออกไปทำตามคำสั่งนอกคำสั่ง if ถ้าเงื่อนไขมีค่าเป็นเท็จ จะไม่ทำตามคำสั่งใน if ดังตัวอย่าง
ตัวอย่าง การใช้คำสั่ง if
/* if1.c */
#include <stdio.h>
#include <conio.h>
int ch;
main()
{
clrscr();
printf("Please press any key.");
ch = getche();
if (ch == '\r') printf("\n Enter key ( ASCII code = 13 ) was pressed .");
printf("\n Out of if statement");
}
คำสั่ง if (ch == '\r') printf("\n Enter key ( ASCII code = 13 ) was pressed ."); กำหนดให้ตรวจสอบเงื่อนในคำสั่ง คือ ถ้าการเคาะแป้นจากคำสั่ง ch = getche(); เป็นแป้น enter จริง แล้วให้ทำตามคำสั่งใน if คือ คำสั่ง ให้แสดงข้อความว่า Enter key ( ASCII code = 13 ) was pressed . ออกทางหน้าจอ แล้วจึงทำตามคำสั่งนอกคำสั่ง if คือ แสดงข้อความว่า Out of if statement ดังรูป
ถ้าเงื่อนไขเป็นเท็จ ให้แสดงข้อความว่า Out of if statement โดยไม่ต้องแสดงข้อความในคำสั่ง if ดังรูป
คำสั่ง if else
เป็นคำสั่งที่มีการทดสอบเงื่อนไขแบบ 2 ทางเลือก ถ้าเงื่อนไขเป็นจริง ให้ทำตามคำสั่งชุด(A)ที่อยู่ใน if ถ้าเงื่อนไขเป็นเท็จ ให้ทำตามคำสั่งชุดใน else (ชุดB)การทำงานของคำสั่ง if else อาจเขียนเป็นผังงาน ดังนี้
เงื่อนไข- |
เท็จ |
ออกจากคำสั่ง if else |
คำสั่งต่าง ๆ (ชุด B ) |
จริง |
คำสั่งต่าง ๆ (ชุด A) |
รูปแบบของคำสั่ง if else
คำสั่ง if else มีรูปแบบ ดังนี้
if (expression) {
statement A1;
…
statement An;
}
else {
statement B1;
…
statement Bn;
}
โดย expression ใน if มีค่าได้เพียง จริง หรือ เท็จ ถ้ามีค่าเป็นจริง โปรแกรมจะทำงานต่อไปในคำสั่งหลัง if คือ คำสั่งชุด A เสร็จแล้วออกจาก if โดยไม่ทำตามคำสั่งชุด B ถ้า expression มีค่าเป็นเท็จ โปรแกรมจะทำตามคำสั่งหลัง else คือ คำสั่งชุด B แล้วออกไปโดยไม่ทำตามคำสั่งชุด A
ตัวอย่าง if else
/*ifelse1.c */
#include <stdio.h>
#include <conio.h>
main()
{
int score1;
clrscr();
printf("\n Please type your score : ");
scanf("%d",&score1);
if (score1 >= 50) printf("You pass the examination.");
else printf("\n You failed the examination.");
}
เป็นโปรแกรมรับการป้อนค่าคะแนนจากแป้นพิมพ์นำไปเก็บในตัวแปร score1 แล้วนำ score1 มาเปรียบเทียบกับ 50 ถ้ามากกว่าหรือเท่ากับ 50 จะได้ผลเป็น จริง โปรแกรมจะทำตามคำสั่งใน if คือ
printf("You pass the examination."); แล้วออกจาก if โดยไม่ทำตามคำสั่งใน else แต่ถ้าเปรียบเทียบ score1 กับ 50 แล้วได้ค่าเป็นเท็จ คือ score1 น้อยกว่า 50 โปรแกรมจะทำตามคำสั่งหลัง else คือ printf("\n You failed the examination."); แล้วออกจากคำสั่งโดยไม่ทำตามคำสั่งหลัง if
คำสั่ง if else if
คำสั่งนี้มีโครงสร้าง else if เพิ่มเข้ามาในคำสั่ง else ทำให้ใช้คำสั่ง else if เพิ่มได้ตามที่ต้องการ ใช้กับการตัดสินใจที่มีทางเลือกมากกว่า 2 ทางเลือก อาจเขียนผังงานได้เป็น
จริง |
เงื่อนไข1 |
เท็จ |
คำสั่งชุดที่ 1 |
เงื่อนไข2 ง |
เท็จ
|
คำสั่งชุดที่ 2 |
เงื่อนไข N |
ออกจากคำสั่ง if else if |
จริง |
เท็จ |
คำสั่งชุดที่ n |
จริง |
เงื่อนไข n |
รูปแบบของคำสั่ง if else if
if (expression1)
{
statement A;
}
else if (expression2)
{
statement B;
}
...
else if (expression n)
{
statement N;
}
else
{
statement N + 1;
}
ตัวอย่าง if else if
#include <stdio.h>
#include <conio.h>
main()
{
int score1;
clrscr();
printf("\n Please type your score : ");
scanf("%d",&score1);
if (score1 >= 80) printf("\n You get A. \n Congratulation");
else if (score1 >= 70) printf("\n You get B.");
else if (score1 >= 60) printf("\n You get C.");
else if (score1 >= 50 ) printf("You get D.");
else printf("\n You get E" );
}
โปรแกรมนี้เป็นการให้ป้อนคะแนนทางแป้นพิมพ์เพื่อหาระดับคะแนน ตามเกณฑ์และรายงานผลออกทางจอภาพ ดังรูป
โครงสร้าง nested if
คำสั่งนี้มีโครงสร้าง nested if เพิ่มเข้ามาในคำสั่ง if ทำให้ใช้คำสั่ง if เพิ่มได้ตามที่ต้องการ ใช้กับการตัดสินใจที่มีทางเลือกมากกว่า 2 ทางเลือก อาจเขียนผังงานได้เป็น (มีได้หลายแบบ)
เงื่อนไข1 |
เท็จ |
ออกจากคำสั่ง nested if |
คำสั่งชุดที่ 3 |
จริง |
คำสั่งชุดที่ 2 |
เงื่อนไข2 ง |
เท็จ
|
จริง |
คำสั่งชุดที่ 1 |
รูปแบบของคำสั่ง nested if
if (expression1)
if (expression 2)
{
statement 1;
}
else
{
statement 2;
}
else
{
statement 3;
}
ตัวอย่าง nested if
/* nestedif1.c */
#include <stdio.h>
#include <conio.h>
main()
{
int a,b; clrscr();
printf("\n Please enter first integer : "); scanf("%d",&a);
printf("\n Please enter second integer : "); scanf("%d",&b);
if (a <= b) /* start if */
if (a < b) /* start nested if */
printf("\n\t %d \t<\t %d\n",a,b);
else
printf("\n\t %d \t==\t %d\n",a,b); /* end nested if */
else
printf("\n\t %d \t>\t %d\n",a,b); /* end if */
}
คำสั่ง switch
เ ป็นคำสั่งที่ใช้ทดสอบเงื่อนไขและมีทางเลือกของการตัดสินใจหลายทาง ทำนองเดียวกับคำสั่ง if else if แต่นิยมใช้คำสั่ง switch มากกว่า เพราะมีรูปแบบที่เข้าใจได้ง่าย สะดวกในการแก้ไขในกรณีที่มีการผิดพลาด
รูปแบบ
switch (expression) {
case (constant 1) :
statements;
break;
case (constant 2):
statements;
break;
…
case (constant n):
statements;
break;
default :
statements
}
expression ของ switch เป็นตัวแปรนิพจน์ที่ใช้เปรียบเทียบค่าว่าตรงกับ constant ของ case ใด โดยโปรแกรมจะปฏิบัติตามคำสั่งต่าง ๆ ใน case นั้น ส่วนคำสั่ง break; จะเป็นคำสั่งให้ออกจากคำสั่ง switch ในกรณีที่ไม่มีคำสั่ง break โปรแกรมจะปฏิบัติเรียงตามลำดับตลอดทุกคำสั่งในทุก case ที่อยู่ต่อกัน ในกรณีที่ค่าของ expression ของ switch ไม่ตรงกับ constant ของ case ใด โปรแกรมจะปฏิบัติตามคำสั่งใน default โดยข้อสังเกตที่ควรจำ ในแต่ละ case อาจมีคำสั่งหลายคำสั่งไม่ต้องใช้เครื่องหมาย { } ล้อม และที่ case ต่าง ๆ และ default จะต้องมี : (colon) ต่อท้ายดังนี้ case (constant) : และ default :
ตัวอย่าง switch
/* switch1.c */
#include <Stdio.h>
#include <conio.h>
main()
{
float num1 = 1.0 , num2 = 1.0;
int operate;
clrscr();
printf("\n Please enter first floating point number : ");
scanf("%f",&num1);
printf("\n Please enter seconf floating point number : ");
scanf("%f",&num2);
printf(" \n Please enter the operator. : ");
operate = getche();
switch ( operate) /* start switch */
{
case '+' :
printf("\n\t result \tof \t%0.2f \t%c \t%02.2f\tis \t %.2f",num1,operate,num2,num1+num2);break;
case '-' :
printf("\n\t result \tof \t%0.2f \t%c \t%02.2f\tis \t %.2f",num1,operate,num2,num1 - num2); break;
case '*' :
printf("\n\t result \tof \t%0.2f \t%c \t%02.2f\tis \t %.2f",num1,operate,num2,num1+num2);break;
case '/' :
printf("\n\t result \tof \t%0.2f \t%c \t%02.2f\tis \t %.2f",num1,operate,num2,num1+num2);break;
default :
printf("unknown operator");
} /* end switch */
} /* end main() */
ฟังก์ชัน ในภาษาซี มี 2 ชนิด คือ ฟังก์ชันมาตรฐาน(standard function) กับ ฟังก์ชันที่ผู้เขียนโปรแกรมเขียนขึ้นเอง (user defined function)
ฟังก์ชันมาตรฐาน เป็นฟังก์ชันที่ผู้ผลิตคอมไพล์เลอร์เขียนขึ้นเพื่อผู้ใช้นำไปใช้ในการเขียนโปรแกรมเพื่อให้เขียนโปรแกรมได้สะดวกและง่ายขึ้น บางครั้งอาจเรียกว่า library functions ปกติฟังก์ชันเหล่านี้จะจัดเก็บไว้ใน header files ดังนั้นผู้ใช้จะต้องรู้ว่าฟังก์ชันนั้นอยู่ใน header file ใด จึงจะนำไปเรียกใช้ในส่วนต้นของโปรแกรม ด้วย #include <header file.h> ได้ เช่น #include <stdio.h> ฟังก์ชันมีมากมาย อาจจำแนกดังนี้
ฟังก์ชันทางคณิตศาสตร์ เป็นฟังก์ชันที่ใช้ทางการคำนวณ ทางคณิตศาสตร์ ปกติอยู่ใน math.h ผลลัพธ์ ที่ได้จากฟังก์ชันกลุ่มนี้เป็นข้อมูลประเภท double ดังนั้นตัวแปรที่ใช้จึงเป็นพวกที่มีชนิดเป็น double
ฟังก์ชัน sin(x) เป็นฟังก์ชันใช้คำนวณหาค่าของ sine โดย x มีค่าของมุมในหน่วย เรเดียน
ฟังก์ชัน cos(x) ใช้หาค่า cosine โดย x มีหน่วยเป็นเรเดียน(radian)
ฟังก์ชัน tan(x) ใช้หาค่า tangent โดย x มีหน่วยเป็นเรเดียน(radian)
ตัวอย่าง /* math1.c */
#include <stdio.h>
#include <conio.h>
#include <math.h>
main()
{ float deg , angle, pi = 3.141592654; clrscr();
printf("Please enter value of angle in degree that you want to find tan cos sin :");
scanf("%f",°);
angle = deg * pi / 180; /* เปลี่ยนค่า องศา ให้เป็นเรเดียน */
printf("\nvalue of tangent %4.0f degree is %4.2f ",deg,tan(angle));
printf("\nvalue of sine %4.0f degree is %4.2f ",deg,sin(angle));
printf("\nvalue of cosine %4.0f degree is %4.2f ",deg,cos(angle));
}
ฟังก์ชัน sqrt(x) ใช้หาค่ารากที่สองของ x โดย x เป็นตัวเลขหรือตัวแปรที่ไม่ติดลบ
ฟังก์ชัน exp(x) ใช้หาค่า ex โดย e มีค่าประมาณ 2.718282
ฟังก์ชัน pow(x,y) ใช้หาค่า x y
ฟังก์ชัน log(x) ใช้หาค่า log ฐาน e เรียกว่า natural logarithm โดย x เป็นตัวเลขหรือตัวแปรที่ไม่ติดลบ
ฟังก์ชัน log10(x) ใช้หาค่า log ฐาน 10 โดย x เป็นตัวเลขหรือตัวแปรที่ไม่ติดลบ
ฟังก์ชัน ceil(x) ใช้ในการปัดเศษทศนิยมของ x เมื่อ x เป็นเลขทศนิยม
ฟังก์ชัน floor(x) ใช้ในการตัดเศษทศนิยมของ x ทิ้งเมื่อ x เป็นเลขทศนิยม
ฟังก์ชัน fabs(x) ใช้ในการหาค่าสัมบูรณ์ของค่าคงที่หรือตัวแปรที่มีทศนิยม โดยเป็นบวกหรือลบก็ได้
ตัวอย่าง ให้นักเรียนศึกษาการทำงานของโปรแกรม /* math2.c */ แล้วป้อนโปรแกรมและตรวจสอบการทำงานว่าตรงกับที่คาดคะเนหรือไม่
/* math2.c */
#include <stdio.h>
#include <conio.h>
#include <math.h>
main()
{
double x = 10.0 , y = 2.0 ,z = 16.0,a = 2.718282 , b = -2.718282 , m=1.0;
clrscr();
printf("\npow\(x,y\) = %4.2f when x=10.0 y=2.0", pow(x,y));
printf("\nsqrt\(z\) = %4.2f when z=16.0", sqrt(z));
printf("\nexp\(m\) = %4.6f when m=1.0",exp(m));
printf("\nlog\(a\) = %4.2f when a=2.718282",log(a));
printf("\nlog10\(x\) = %4.2f when x=10.0",log10(x));
printf("\nceil\(a\) = %4.2f when a=2.718282",ceil(a));
printf("\nceil\(b\) = %4.2f when b=-2.718282",ceil(b));
printf("\nfloor\(a\) = %4.2f when a=2.718282",floor(a));
printf("\nfloor\(b\) = %4.2f when b=-2.718282",floor(b));
printf("\nfabs\(a\) = %4.6f when a=2.718282" ,fabs(a));
printf("\nfabs\(b\) = %4.6f when b=-2.718282" ,fabs(b));
}
ฟังก์ชันที่จัดการเกี่ยวกับตัวอักษร(character functions) เป็นฟังก์ชันที่จัดการกับตัวอักษร single char เท่านั้น ตัวอักษรนี้ใช้หน่วยความจำเพียง 1 ไบต์ ฟังก์ชันเหล่านี้อยู่ใน header file ชื่อ ctype.h ก่อนจะทำการเขียนโปรแกรมจึงต้อง #include <ctype.h> เข้ามาในส่วนต้นของโปรแกรม
ฟังก์ชัน isalnum(cha) เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลในตัวแปร(ซึ่งคือตัวแปรประเภท char ) เป็นตัวอักขระหรือตัวเลขหรือไม่ ถ้าเป็นตัวอักษรหรือตัวเลข ฟังก์ชันจะส่งค่าที่ไม่ใช่ 0 มาให้ ถ้าข้อมูลในตัวแปร เป็นอักขระพิเศษอื่นที่ไม่ตัวอักษรหรือตัวเลขจะส่งค่าออกมาเป็น 0
ฟังก์ชัน isalpha(cha) เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลในตัวแปร(ซึ่งคือตัวแปรประเภท char ) เป็นตัวอักขระหรือไม่ ถ้าเป็นตัวอักษรฟังก์ชันจะให้ค่าที่ไม่ใช่ 0 ออกมาถ้าเป็นตัวเลขหรืออักขระพิเศษอื่นฟังก์ชันจะส่งค่า 0 ออกมา
ฟังก์ชัน isdigit(cha) เป็นฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลในตัวแปร(ซึ่งคือตัวแปรประเภท char ) ฟังก์ชัน เป็นตัวเลขหรือไม่ ถ้าเป็นตัวเลขฟังก์ชันจะให้ค่าที่ไม่ใช่ 0 ออกมา ถ้าเป็นตัวอักษรหรืออักขระพิเศษอื่น ฟังก์ชันจะส่ง 0 ออกมา
ตัวอย่าง /* isalnumPhadigit.c */
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
main()
{
clrscr();
char cha1 = 'B' ,cha2 ='3',cha3= '&';
printf("\n %d is return value of isdigit\(cha1\) of %c",isdigit(cha1),cha1);
printf("\n %d is return value of isdigit\(cha2\) of %c ",isdigit(cha2),cha2);
printf("\n %d is return value of isalpha\(cha3\) of %c ",isalpha(cha3),cha3);
printf("\n %d is return value of isalpha\(A\) of %c ",isalpha('A'),'A');
printf("\n %d is return value of isalpha\('0'\) of %c ",isalpha('0'),'0');
printf("\n %d is return value of isalpha\('$'\) of %c ",isalpha('$'),'$');
printf("\n %d is return value of isalnum\(cha1\) of %c",isalnum(cha1),cha1);
printf("\n %d is return value of isalnum\(cha2\) of %c ",isalnum(cha2),cha2);
printf("\n %d is return value of isalnum\(cha3\) of %c ",isalnum(cha3),cha3);
printf("\n %d is return value of isalnum\(A\) of %c ",isalnum('A'),'A');
printf("\n %d is return value of isalnum\('0'\) of %c ",isalnum('0'),'0');
printf("\n %d is return value of isalnum\('$'\) of %c ",isalnum('$'),'$');
}
ฟังก์ชัน islower(cha) ฟังก์ชันที่ใช้ตรวจสอบว่าตัวอักขระในตัวแปร cha เป็นตัวพิมพ์เล็กหรือไม่ ถ้าเป็นตัวพิมพ์เล็กฟังก์ชันจะส่งค่ากลับเป็นจำนวนเต็มที่ไม่ใช่ 0 แต่ถ้าไม่ใช่ตัวพิมพ์เล็กจะส่งค่ากลับเป็น 0
ฟังก์ชัน isupper(cha) ฟังก์ชันที่ใช้ตรวจสอบว่าตัวอักขระในตัวแปร cha เป็นตัวพิมพ์ใหญ่หรือไม่ ถ้าเป็นตัวพิมพ์ใหญ่ ฟังก์ชันจะส่งค่ากลับเป็นจำนวนเต็มที่ไม่ใช่ 0 แต่ถ้าไม่ใช่ตัวพิมพ์ใหญ่จะส่งค่ากลับเป็น 0
ฟังก์ชัน tolower(cha) ฟังก์ชันที่ใช้เปลี่ยนตัวพิมพ์ใหญ่ที่เก็บอยู่ในตัวแปรให้เป็นตัวพิมพ์เล็ก
ฟังก์ชัน toupper(cha) ฟังก์ชันที่ใช้เปลี่ยนตัวพิมพ์เล็กที่เก็บอยู่ในตัวแปรให้เป็นตัวพิมพ์ใหญ่
ตัวอย่าง /* upperlower.c */
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
main()
{
char cha1 = 'D' , cha2 = 'a' ,cha3 = 'f' , cha4 = 'N' ;
clrscr();
printf("\ncheck cha1 = 'D' is uppercase yes or no : %d ",isupper(cha1));
printf("\ncheck cha2 = 'a' is lower yes or no : %d ",islower(cha2));
printf("\ncheck cha2 = 'a' is upper yes or no : %d ",isupper(cha2));
printf("\ncheck 'i' is lower yes or no : %d ",islower('i'));
printf("\ncheck 'L' is uppercase yes or no : %d ",isupper('L'));
printf("\nchange cha3 = 'f' to uppercase %c : ", toupper(cha3));
printf("\nchange cha4 = 'N' to lowercase %c : ", tolower(cha4));
}
ฟังก์ชัน isspace(cha) ฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลในตัวแปร cha เป็น whitespace หรือไม่ whitespace ได้แก่ space ,tab ,vertical tab ,formfeed ,carriage retun ,newline ถ้ามี whitespace จริง ฟังก์ชันจะส่งค่าไม่เท่ากับ 0 ถ้าไม่จริงจะส่งค่า 0
ฟังก์ชัน isxdigit(cha) ฟังก์ชันที่ใช้ตรวจสอบว่าข้อมูลในตัวแปร cha เป็น เลขฐานสิบหก ( คือ 0-9 , A-F , a – f) หรือไม่ ถ้าจริงส่งค่าตัวเลขที่ไม่ใช่ 0 ถ้าไม่จริงส่งตัวเลข 0
ตัวอย่าง /*isspaceisxdigit.c */
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
main()
{
char cha1 ='\r',cha2= '\n',cha3='\v' ,cha4 ='A';
clrscr();
printf("\n%d is volue return from isspace %c ",isspace(cha1),cha1);
printf("\n%d is volue return from isspace %c ",isspace(cha2),cha2);
printf("\n%d is volue return from isspace %c ",isspace(cha3),cha3);
printf("\n%d is volue return from isxdigit %c ",isxdigit(cha4),cha4);
printf("\n%d is volue return from isxdigit %c ",isxdigit('0'),'0');
printf("\n%d is volue return from isxdigit %c ",isxdigit('g'),'g');
}
ฟังก์ชัน gotoxy(x,y); เป็นฟังก์ชันอยู่ใน conio.h ใช้สั่งให้เคอร์เซอร์เคลื่อนที่ไปตามตำแหน่งที่ระบุ โดย x คือ ตำแหน่งของสดมภ์บนจอภาพ (คล้ายค่า x ของกราฟ)ค่าเพิ่มจากซ้ายไปขวามีค่าตั้งแต่ 1 ถึง 79 ตำแหน่งที่ 80 สงวนไว้ไม่ให้ใช้
ส่วน y คือตำแหน่งแถวบนจอภาพนับจากบนลงล่าง มีค่าได้ตั้งแต่ 1 ถึง 24 ตำแหน่งที่25 สงวนไว้
ฟังก์ชัน clreol(); เป็นฟังก์ชันอยู่ใน conio.h ใช้ลบข้อความตั้งแต่ตำแหน่งที่เคอร์เซอร์อยู่ไปจนจบบรรทัด
ฟังก์ชัน delline(); เป็นฟังก์ชันอยู่ในconio.h ใช้ลบข้อความทั้งบรรทัดที่เคอร์เซอร์อยู่ไปจนจบบรรทัดและเลื่อนข้อความในบรรทัดล่างขึ้นมาแทน
ฟังก์ชัน insline(); เป็นฟังก์ชันอยู่ในconio.h ใช้แทรกบรรทัดว่าง 1 บรรทัดใต้บรรทัดที่เคอร์เซอร์อยู่
ฟังก์ชัน system(“dos command”); เป็นฟังก์ชันอยู่ในstdlib.h ใช้เรียกคำสั่งของ dos ขึ้นมาทำงาน เช่นคำสั่ง cls dir date time
ฟังก์ชัน abort(); ฟังก์ชันที่อยู่ใน <stdlib.h> ใช้ ยกเลิกการทำงานของโปรแกรมทันทีไม่ว่าจะทำงานสำเร็จหรือไม่ และมีข้อความ Abnomal program termination แสดงทางจอภาพ
ฟังก์ชัน abs(x); ฟังก์ชันที่อยู่ใน <stdlib.h> ใช้หาค่าสัมบูรณ์ของ x โดย x ต้องเป็นจำนวนเต็ม
ฟังก์ชัน labs(x); ฟังก์ชันที่อยู่ใน <stdlib.h> ใช้หาค่าสัมบูรณ์ของ x โดย x ต้องเป็นlong integer
ฟังก์ชัน atoi(s); ฟังก์ชันที่อยู่ใน <stdlib.h> ใช้เปลี่ยนข้อความให้เป็นเลขจำนวนเต็ม
ฟังก์ชัน atol(s); ฟังก์ชันที่อยู่ใน <stdlib.h> ใช้เปลี่ยนข้อความให้เป็น long integer
ฟังก์ชัน atof(s); ฟังก์ชันที่อยู่ใน <stdlib.h> ใช้เปลี่ยนข้อความให้เป็น floating point
ตัวอย่าง /* atoilf.c */
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
int main(void)
{ char numstring1[10],numstring2[10],numstring3[10];
int in1; float flo1; long lon1; clrscr();
printf("\nEnter number as string1 : ");
scanf("%s",numstring1);
printf("\nEnter number as string2 : ");
scanf("%s",numstring2);
printf("\nEnter number as string3 : ");
scanf("%s",numstring3);
in1 = atoi(numstring1); flo1 = atof(numstring2); lon1=atol(numstring3);
printf("\nnumstring1 =%s change to integer %d ",numstring1,in1);
printf("\nnumstring2 =%s change to floating point %4.4f ",numstring2,flo1);
printf("\nnumstring3 =%s change to long integer %d ",numstring3,lon1);
printf("\nsummation of in1,flo1,lon1 is %6.4f ",in1+flo1+lon1);
printf("\nsummation of atoi(numstring1),atof(numstring2),atol(numstring2) is %6.4lf:",atoi(numstring1)+atof(numstring2)+atol(numstring3));
}
ความหมายของพอยน์เตอร์
พอยน์เตอร์ (pointer) เป็นตัวแปรชนิดหนึ่งใช้เก็บตำแหน่งของข้อมูลในหน่วยความจำ โดยการเก็บตำแหน่งจะเก็บเฉพาะตำแหน่งแรกของข้อมูล
ประเภทของพอยน์เตอร์
พอยน์เตอร์ มี 2 ประเภท คือ
- 1. direct pointer เป็นตัวแปรที่เก็บตำแหน่ง(address) ในหน่วยความจำ ของข้อมูล ตัวอย่าง เช่น ตัวแปรชื่อ x มีข้อมูลเป็น 120 ซึ่งถูกเก็บไว้ในหน่วยความจำที่ตำแหน่ง 5000 พอยน์เตอร์ ชื่อ ptr มีค่าที่เก็บไว้เป็น 5000 ดังรูป
- 2. indirect pointer เป็นตัวแปรที่เก็บตำแหน่ง (address) ของพอยน์เตอร์ซึ่งเก็บตำแหน่งของข้อมูลของตัวแปร เช่น ตัวแปรชื่อ x มีข้อมูลเป็น 120 ซึ่งถูกเก็บไว้ในหน่วยความจำที่ตำแหน่ง 5000 พอยน์เตอร์ ชื่อ ptr มีค่าที่เก็บไว้เป็น 5000 และ พอยน์เตอร์ ชื่อ pptr เก็บตำแหน่งหน่วยความจำของ ptr ซึ่งมีค่า 3000 พอยน์เตอร์ pptr นี้อาจเรียกว่า pointer to pointer ดังรูป
การประกาศตัวแปรพอยน์เตอร์ (Declaration of Pointer Variables)
type *variable_name ;
หรือ type *variable_name1, *variable_name2,... ,*variable_nameN ;
โดย type คือ ชนิดของตัวแปร เช่น int ,float ,char ฯลฯ โดยต้องเป็นชนิดเดียวกับของตัวแปรหรือข้อมูลที่พอยน์เตอร์นั้นเก็บตำแหน่งที่อยู่
* เป็นเครื่องหมายที่ระบุว่าเป็นตัวแปรพอยน์เตอร์
variable_name1, variable_name2,..., variable_nameN ชื่อตัวแปรพอยน์ตัวที่ 1 ถึง ตัวสุดท้ายที่ประกาศในการประกาศครั้งนี้
ตัวอย่าง int *ptr1, *prt2; char *word, *str1;
การกำหนดตำแหน่งของข้อมูลให้ตัวแปรพอยน์เตอร์
การกำหนดตำแหน่งที่เก็บข้อมูลในหน่วยความจำของตัวแปรทำได้โดยใช้เครื่องหมาย & (ampersand) นำหน้าชื่อตัวแปร นำมากำหนดให้เป็นค่าของพอยน์เตอร์เช่น
int num1 = 120; /* ประกาศและกำหนดค่าให้แก่ตัวแปร ในที่นี้เป็นตัวแปร ชื่อ num1 เป็นประเภท int โดยมีค่า เป็น 120 */
int *ptr1; /* ประกาศตัวแปรพอยน์เตอร์ ในที่นี้เป็นประเภท int เพราะใช้เก็บตำแหน่งของตัวแปรประเภท int */
ptr1 = &num1; /* กำหนดค่าตำแหน่งของตัวแปรให้เป็นค่าของพอยน์เตอร์ */
ตัวอย่าง /* pointer1.c */ ให้พิจารณาคาดคะเนการทำงานของโปรแกรม และทดลองโปรแกรมว่าเป็นตามที่คาดหรือไม่
#include <stdio.h>
#include <conio.h>
main()
{
int num1, *ptr1; /* ประกาศตัวแปรและตัวแปรพอยน์เตอร์ ประเภท int */
char s , *ptr_cha1 ; /* ประกาศตัวแปรและตัวแปรพอยน์เตอร์ ประเภท char */
num1 = 500, s = 'A'; /* กำหนดค่าให้ตัวแปร */
ptr1 = &num1, ptr_cha1 =&s; /* กำหนดค่าตำแหน่งของตัวแปรให้ตัวแปรพอยน์เตอร์ */
clrscr();
printf("\n Address of num1 or value of pointer ptr1 is %d ",ptr1); /* พิมพ์ค่าตำแหน่งเป็นเลขฐานสิบ */
printf("\nAddress of num1 or value of pointer ptr1 is %p ",ptr1); /* พิมพ์ค่าตำแหน่งเป็นเลขฐานสิบหก */
printf("\nAddress of num1 or value of pointer ptr1 is %d ",&num1); /* พิมพ์ค่าตำแหน่งเป็นเลขฐานสิบ อีกวิธี */
printf("\n value of variable num1 =%d",num1); /* พิมพ์ค่าตัวแปร */
printf("\n value of variable num1 =%d",*ptr1); /*พิมพ์ค่าตัวแปรโดยใช้พอยน์เตอร์ */
printf("\n Address of s or value of pointer ptr_cha1 is %d ",ptr_cha1); /* พิมพ์ค่าตำแหน่งเป็นเลขฐานสิบ */
printf("\nAddress of s or value of pointer ptr_cha1 is %p ",ptr_cha1); /* พิมพ์ค่าตำแหน่งเป็นเลขฐานสิบหก */
printf("\nAddress of s or value of pointer ptr_cha1 is %p ",&s); /* พิมพ์ค่าตำแหน่งเป็นเลขฐานสิบหก อีกวิธี */
printf("\n value of variable s =%c",s); /* พิมพ์ค่าตัวแปร */
printf("\n value of variable s =%c",*ptr_cha1); /*พิมพ์ค่าตัวแปรโดยใช้พอยน์เตอร์ */
}
ตัวแปรพอยน์เตอร์กับตัวแปรชุด ( pointer and arrays)
ตัวแปรพอยน์เตอร์ กับตัวแปรชุด มีลักษณะทำนองเดียวกับตัวแปรอื่น ๆ คือ กำหนดพอยน์เตอร์ให้กับตัวแปรแต่ละตัวในตัวแปรชุดก็ได้ ดังตัวอย่าง
ตัวอย่าง /* pointer1_1.c */
#include <stdio.h>
#include <conio.h>
int x[10] = { 11,43,523,789,101,90,7,187,13,24}; /* ประกาศและกำหนดค่า ตัวแปรชุด */
int *pt1,*pt2,*pt3,*pt4,*pt5; /* ประกาศตัวแปรพอยน์เตอร์ */
main()
{
clrscr(); pt1 = &x[2]; pt2 =&x[5]; pt3=&x[8]; pt4 = &x[6]; pt5 =&x[2]; /*กำหนดค่าตำแหน่งของตัวแปรชุดบางตัวให้แก่ พอยน์เตอร์ */
printf("Address of x[2] = %p value of x[2] = %d\n",pt1,*pt1); // พิมพ์ค่าตำแหน่งและค่าของตัวแปร
printf("Address of x[5] = %p value of x[5] = %d\n",pt2,*pt2); // พิมพ์ค่าตำแหน่งและค่าของตัวแปร
printf("Address of x[8] = %p value of x[8] = %d\n",pt3,*pt3); // พิมพ์ค่าตำแหน่งและค่าของตัวแปร
printf("Address of x[6] = %p value of x[6] = %d\n",pt4,*pt4); // พิมพ์ค่าตำแหน่งและค่าของตัวแปร
printf("Address of x[2] = %p value of x[2] = %d\n",pt5,*pt5); // พิมพ์ค่าตำแหน่งและค่าของตัวแปร
x[3] = *pt5; // กำหนดค่าให้ค่า x[2] ให้แก่ x[3]
printf("After assign new value!!! Value of x[3] = %d \n",x[3]); // พิมพ์ค่าของตัวแปร
}
เมื่อ run โปรแกรมจะได้ผลดังรูป
เมื่ออ้างตัวแปรชุดโดยไม่อ้างดัชนี ต่อท้าย จะหมายถึง ระเบียนแรก ของตัวแปรชุด เช่นตัวแปรชุด record[5] เมื่ออ้างถึง record จะหมายถึง record[0] และการอ้างถึงดัชนีของพอยน์เตอร์ อาจมีการบวกเหมือนการบวกเลข เช่น ptr = &record; แล้ว จะได้ (ptr+1) มีค่าเป็น &record[1] ส่วน (ptr+2) มีค่าคือ &record[2] ,... , และ (ptr+5) มีค่าเป็น &record[5] ไม่ใช่ ptr1 มีค่าเป็น &record[1] (เพราะ ptr1 คือตัวแปรคนละตัวกับ ptr+1 ทำนองเดียวกัน ptr+2 ไม่ใช่ ptr2 และ ptr0 ไม่ใช่ ptr+0 ซึ่งคือ ptr ) เช่น ดังตัวอย่าง pointer2.c
ตัวอย่าง /* pointer2.c */
#include <stdio.h>
#include <conio.h>
main()
{
clrscr();
int arr[5] ={ 10,15,25,30,12};
int i,j,*pt,*pp,*p0,*p1,*p2,*p3,*p4;
pt = arr; pp = &arr[0]; /* การกำหนดตำแหน่งของตัวแปรชุดถ้าจะใช้ต่อเนื่องได้จะต้องเริ่มตั้งแต่ตำแหน่งแรกของตัวแปรชุด เช่นต้องเริ่มที่ &arr[0]; ไม่ใช่ตัวอื่น เช่น &arr[1]; */
p0=&arr[0]; p1=&arr[1]; p2=&arr[2]; p3=&arr[3]; p4=&arr[4]; /* กำหนดตำแหน่งให้พอยน์เตอร์ */
for(i=0;i<=4;i++)
{
printf("\nvalue of pt[%d] = %d",i,pt+i); printf("\tvalue of *pt[%d] = %d ",i,*(pt+i));
}
printf("\naddress of arr[0] = %d",&arr[0]); printf("\tvalue of arr[0] = %d",arr[0]);
printf("\nvalue of p0 = %d",p0); printf("\tvalue of *p0 = %d",*p0);
printf("\naddress of arr[1] = %d",&arr[1]); printf("\tvalue of arr[1] = %d",arr[1]);
printf("\nvalue of p1 = %d",p1); printf("\tvalue of *p1 = %d",*p1);
printf("\naddress of arr[2] = %d",&arr[2]); printf("\tvalue of arr[2] = %d",arr[2]);
printf("\nvalue of p2 = %d",p2); printf("\tvalue of *p2 = %d",*p2);
printf("\naddress of arr[3] = %d",&arr[3]); printf("\tvalue of arr[3] = %d",arr[3]);
printf("\nvalue of p3 = %d",p3); printf("\tvalue of *p3 = %d",*p3);
printf("\naddress of arr[4] = %d",&arr[4]); printf("\tvalue of arr[4] = %d",arr[4]);
printf("\nvalue of p4 = %d",p4); printf("\tvalue of *p4 = %d",*p4);
for (j=0;j<=4;j++)
{
printf ("\nvalue of pp[%d] = %d",j,pp+j); printf("\tValue of *pp[%d] = %d",j,*(pp+j));
}
} เมื่อ run โปรแกรมจะได้ดังรูป
ผลการ run โปรแกรม pointer2.c
พอยน์เตอร์กับข้อความ (pointers and strings)
ข้อความเป็นตัวแปรชุด(string variable)อย่างหนึ่งโดยเป็นตัวแปรชุดของตัวอักขระ มีรหัส null character(\0)ที่หน่วยความไบต์ที่ต่อจากตัวอักขระตัวสุดท้าย ดังรูป
ในการระบุชื่อตัวแปรข้อความโดยไม่ระบุดัชนี เช่น word จะมีความหมายถึงตำแหน่งเริ่มต้นของตัวแปร คือตำแหน่งของ word[0] ดังนั้นการกำหนดค่าตำแหน่งของตัวแปรข้อความให้กับพอยน์เตอร์ จึงไม่ต้องใช้เครื่องหมาย & เช่น char *ptr , word[6]; ptr = word; ไม่ใช่ ptr = &word; และการแสดงค่าของข้อความโดยใช้พอยน์เตอร์ ก็ใช้ชื่อของพอยน์เตอร์ ได้ เช่น
printf("\nvalue of word = %s",word); กับ printf("\nvalue of word = %s",ptr); จะได้ผลออกมาเหมือนกัน (แต่ใช้ printf("\nvalue of word = %s",*ptr); ไม่ได้แม้จะcompile ผ่านแต่ตอน run จะมีปัญหา) ดังตัวอย่างโปรแกรม pointerss.c และ pointerss2.c
ตัวอย่าง /*pointerss.c */ (ให้นักเรียนลองคิดพิจารณาแล้วลอกเป็นโปรแกรมให้ทำงานว่าได้ผลดังคาดหรือไม่)
#include <stdio.h>
#include <conio.h>
#include <string.h>
char *ptr , word[6]= "Study";
main()
{ clrscr(); ptr=word;
printf("\naddress of ptr = %d",&ptr); printf("\naddress of ptr+0 = %d",&ptr+0);
printf("\naddress of ptr+1 = %d",&ptr+1); printf("\naddress of ptr+2 = %d",&ptr+2);
printf("\naddress of ptr+3 = %d",&ptr+3); printf("\naddress of ptr+4 = %d",&ptr+4);
printf("\naddress of ptr+5 = %d",&ptr+5); /* การใช้ดัชนีของพอยน์เตอร์กับตัวแปรในตัวแปรข้อความในการหาตำแหน่งของพอยน์เตอร์ */
printf("\nvalue of ptr+0 = %d",ptr+0); printf("\nvalue of ptr+1 = %d",ptr+1);
printf("\nvalue of ptr+2 = %d",ptr+2); printf("\nvalue of ptr+3 = %d",ptr+3);
printf("\nvalue of ptr+4 = %d",ptr+4); printf("\nvalue of ptr+5 = %d",ptr+5);
printf ("\nvalue of ptr = %d",ptr); */ การใช้ดัชนีของพอยน์เตอร์กับกับค่าที่ตัวแปรพอยน์เตอร์เก็บไว้ซึ่งคือตำแหน่งของตัวแปรอักขระแต่ละตัวในตัวแปรข้อความ */
printf("\naddress of word = %d",&word); printf("\naddress of \&word[0] = %d",&word[0]);
printf("\naddress of \&word[1] = %d",&word[1]); printf("\naddress of \&word[2] = %d",&word[2]);
printf("\naddress of \&word[3] = %d",&word[3]); printf("\naddress of \&word[4] = %d",&word[4]);
printf("\naddress of \&word[5] = %d",&word[5]); /* การใช้ & แสดงตำแหน่งของตัวแปรอักขระแต่ละตัวในตัวแปรข้อความ */
printf("\nvalue of word[0] = %c",word[0]); printf("\nvalue of word[1] = %c",word[1]);
printf("\nvalue of word[2] = %c",word[2]); printf("\nvalue of word[3] = %c",word[3]);
printf("\nvalue of word[4] = %c",word[4]); printf("\nvalue of word[5] = %c",word[5]); /* การแสดงค่าของตัวแปรอักขระแต่ละตัวในตัวแปรข้อความ */
printf("\nvalue of word = %s",word); printf("\nvalue of word = %s",ptr); /* การแสดงค่าของตัวแปรข้อความ โดยใช้ตัวแปรข้อความ และพอยน์เตอร์ */
printf("\naddress of ptr = %d ",&ptr);
printf("\nlength of word = %d ",strlen(word)); printf("\nsize of word = %d ",sizeof(word));
}
ตัวอย่าง /*pointerss.c */ (ให้ดูที่ค่าต่าง ๆ แต่รูปแบบไม่เหมือนเพราะจัดใหม่ให้พอกับหน้ากระดาษ)
ตัวอย่าง pointerss2.c
#include <stdio.h>
#include <conio.h>
#include <string.h>
char *p, name[10]; int x;
main()
{ clrscr(); strcpy(name,"Wichai"); p = name;
printf("\nFind character from *(pointer)\n");
for(x=0;x<=5;x++)
{printf("\n *\(p+%d\) char = %c ",x,*(p+x));} // ใช้พอยน์เตอร์หาตัวอักขระในข้อความ
// printf("\n Find String from Pointer String = %s", *p); มีปัญหาตอน run แม้ compile ผ่าน
printf("\n Find String from pointer name String \( p = %s \) \n Find from variable name \(name = %s \) ",p,name);
x=0; // เริ่มการหาตำแหน่งของอักขระแต่ละตัวในข้อความดัวย พอยน์เตอร์ และ &variable name
while (x <= 5) {printf("\nFindAddress from pointer \( value of p+%d = %p and \nFind address from \(& and varialble name \(address of name[%d] = %p\n",x,p+x,x,&name[x]);x++;}
} // จบโปรแกรม ให้นักเรียนศึกษา คาดคะเนผล และนำไปเขียนและทดลองว่าเป็นตามที่คาดคะเนหรือไม่
ตัวแปรชุดของพอยน์เตอร์ (Arrays of pointers)
บางครั้งเราต้องการใช้พอยน์เตอร์เป็นจำนวนมาก โปรแกรมจึงออกแบบให้เราสามารถสร้างพอยน์เตอร์ขึ้นเป็นแบบตัวแปรชุด (arrays of pointers) โดยมีรูปแบบการประกาศ ดังนี้
type *pointername[n]; หรือ type *pointername[n] = { valuelist };
โดย type คือ ชนิดของตัวแปรพอยน์เตอร์ เช่น int float double char
* เครื่องหมายที่แสดงว่าเป็นพอยน์เตอร์
pointername คือ ชื่อของตัวแปรพอยน์เตอร์ ตั้งตามกฎเกณฑ์การตั้งชื่อตัวแปร n คือ ขนาดของ array
valuelist คือ ค่าต่าง ๆ ที่กำหนดให้เป็นค่าของตัวแปรพอยน์เตอร์ ถ้าพอยน์เตอร์ เป็นของข้อความ ค่าแต่ละค่าใน valuelist จะต้องถูกล้อมด้วย “ “
ตัวอย่าง ให้ศึกษาโปรแกรม /* arraypointer.c */ แล้วคาดคะเนผลการทำงานของโปรแกรมแล้วนำไปสร้างโปรแกรมและทดสอบการทำงานว่าเป็นไปตามที่คาดหรือไม่
#include <stdio.h>
#include <conio.h>
int *ptr[6],num[6]={18,27,66,45,54,63};
main()
{ clrscr(); int j,k; for (j=0;j<6;j=j+1) { ptr[j]=&num[j]; }
for (k=0;k<=5;k++)
{ *ptr[k] = *ptr[k] + 8 ; printf("\n new value of y[%d] = %d from old value = %d",k,*ptr[k],*ptr[k]-8); }
}
ตัวอย่าง ให้ศึกษาโปรแกรม /* arraypointer2.c */ แล้วคาดคะเนผลการทำงานของโปรแกรมแล้วนำไปสร้างโปรแกรมและทดสอบการทำงานว่าเป็นไปตามที่คาดหรือไม่
#include <stdio.h>
#include <conio.h>
int *ptr[16],room[16]={101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,};
main()
{ clrscr(); int j=16;
while (j>0) { ptr[j-1] = &room[j-1]; printf("Room no %d has address = %p \n",*ptr[j-1],ptr[j-1]);
j--; }
}
ตัวอย่าง ให้ศึกษาโปรแกรม /* arraypointer3.c */ แล้วคาดคะเนผลการทำงานของโปรแกรมแล้วนำไปสร้างโปรแกรมและทดสอบการทำงานว่าเป็นไปตามที่คาดหรือไม่
/* arraypointer3.c */
#include <stdio.h>
#include <conio.h>
char *ptr[6] ={"Ramkamhaeng","Ladproa","Srinakarin","Serithai","Akekachai","Sukhumvit"};
main()
{
int i; clrscr();
for (i=5;i>=0;i--)
printf("Street name = %s \n",ptr[i]); /* pointer ของข้อความใช้ *pointer หาข้อความทั้งข้อความไม่ได้ ต้องใช้ pointer (ไม่ใช้*) */
}
พอยน์เตอร์ซ้อนพอยน์เตอร์ (pointer to pointer or indirect pointer)
พอยน์เตอร์ เป็นตัวแปรเช่นเดียวกับตัวแปรอื่น ๆ ในการเก็บค่าของตัวจึงต้องใช้หน่วยความจำในการเก็บ ซึ่งถ้าต้องการทราบตำแหน่งที่จัดเก็บข้อมูลในตัวแปรพอยน์เตอร์ ก็สามารถสร้างพอยน์เตอร์ ซึ่งเรียกว่า indirect pointer หรือ pointer to pointer โดย มีรูปแบบในการประกาศ ตัวแปรพอยน์เตอร์ซ้อนพอยน์เตอร์ ดังนี้
type **pointername; หรือ type **pointername1,pointername2,...,pointernameN;
โดย type ชนิดของตัวแปร indirect pointer ซึ่งต้องเป็นชนิดเดียวกับ pointer ที่ต้องการทราบตำแหน่งในหน่วยความจำ
** เป็นเครื่องหมายที่กำหนดให้เป็น indirect pointer
pointername ชื่อของ indirect pointer ที่ประกาศ
ลักษณะของความสัมพันธ์ระหว่างตัวแปร pointer และ indirect pointer เป็นดังรูป
ลักษณะของความสัมพันธ์ระหว่างตัวแปรนี้ศึกษาได้จากโปรแกรม pointertopointer.c
ตัวอย่าง ให้ศึกษาโปรแกรม /* pointertopointer.c */ โดยวิเคราะห์การทำงานแล้ว นำไปสร้างเป็นโปรแกรม และทดสอบว่าเป็นไปตามที่คาดคะเนหรือไม่
/* pointertopointer.c */
#include <stdio.h>
#include <conio.h>
int **pt,*ptr,num,show,exhi;
main()
{
clrscr(); num = 100; ptr = # pt = &ptr; show = *ptr; exhi = **pt;
printf("\nValue of num in dec = %d and in hex = %p ",num,num);
printf("\nAddress of num in dec = %d and in hex = %p ",ptr,ptr);
printf("\nValue of *ptr in dec = %d and in hex = %p ",*ptr,*ptr);
printf("\nAddress of ptr in dec = %d and in hex = %p ",pt,pt);
printf("\nValue of **pt in dec = %d and in hex = %p ",**pt,**pt);
printf("\nValue of show in dec = %d and in hex = %p ",show,show);
printf("\nValue of exhi in dec = %d and in hex = %p ",exhi,exhi);
}
ทดสอบโปรแกรมแล้วจะได้ ดังรูป
พอยน์เตอร์ แบบนี้สามารถใช้แบบตัวแปรชุดของพอยน์เตอร์ได้ เช่นเดียวกัน ดังโปรแกรม pointertopointer1.c
ตัวอย่าง ให้ศึกษา วิเคราะห์ โปรแกรม pointertopointer.c แล้วนำไปทดสอบว่าเป็นไปตามที่คาดหรือไม่
/* pointertopointer.c */
#include <stdio.h>
#include <conio.h>
int **pt[4],*ptr[4],num[4]={15,50,99,125},i,j,k;
main()
{ clrscr(); for(i=0;i<=3;i++){ ptr[i] =&num[i];}
j=4; while (j>0) { pt[j-1] = &ptr[j-1]; j--;}
k = 0 ;
do
{
printf("\n num[%d] = %d *ptr[%d] = %d and **pt[%d] = %d ",k,num[k],k,*ptr[k],k,**pt[k]);k++;
} while (k<4);
}
เมื่อทดสอบโปรแกรม pointertopointer.c จะได้ดังรูป
ตัวอย่าง เกี่ยวกับ pointer to pointer ของตัวแปรอักขระ ตัวแปรทศนิยม และตัวแปรชุด ให้พิจารณาจากโปรแกรม pointertopointer2.c คาดคะเนผลและลองทดสอบดู
/* pointertopointer2.c */
#include <stdio.h>
#include <conio.h>
char *sp,**spp,s='A'; int *nt[3],**ntt[3],num[3]={11,25,39},i,j; float *fp,**fpp,flo = 5.26;
main()
{
clrscr(); fp = &flo; fpp =&fp; sp = &s; spp=&sp;
printf("\n flo = %4.2f\t *fp = %4.2f\t**fpp = %4.2f",flo,*fp,**fpp);
printf("\n s = %c\t *sp = %c\t**spp = %c",s,*sp,**spp);
for (i=0;i<3;i++)
{ nt[i] =&num[i]; ntt[i]=&nt[i];printf("\nnt[%d] = %d *nt[%d] = %d ntt[%d] = %d **ntt[%d] = %d ",i,nt[i],i,*nt[i],i,ntt[i],i,**ntt[i] );}
} /* ผลการทำงานของโปรแกรมเป็นดังรูป */
ผลการทำงานของโปรแกรม pointertopointer2.exe เป็นดังรูป
ข้อควรสังเกต
1. ถ้าใช้พอยน์เตอร์ซ้อนพอยน์เตอร์กับ ตัวแปร int char(อักขระตัวเดียว) float ใช้ **นำหน้าชื่อพอยน์เตอร์กรณีแสดงค่าตัวแปร ดังในตัวอย่างที่ผ่านมา
2. กรณี ตัวแปรข้อความ ใช้เพียง * นำหน้าชื่อ indirect pointer ใช้ ** ไม่ได้ ดังตัวอย่างในโปรแกรม pointertopointer3.c
ตัวอย่าง ศึกษาโปรแกรม pointertopointer3.c แล้วคาดคะเนผล แล้วทดสอบโปรแกรม
/* pointertopointer3.c */
#include <stdio.h>
#include <conio.h>
#include<string.h>
char word[6]= "Today";
char *pt,**ptt;
main()
{
clrscr(); pt = word; ptt=&pt;
printf("\n pt+2 = %p *(pt+2) = %c \npt+3 =%p *(pt+3)= %c \n pt+4 =%p *(pt+4) = %c",pt+2,*(pt+2),ptt+3,*(pt+3),pt+4,*(pt+4));
printf("\n pt = %p *pt = %s ",pt,pt ); /* ผ่านมาแล้วในกรณี ข้อความกับ pointer */
printf("\n ptt = %p **ptt = %s" ,ptt,*ptt); /* ใช้ในรูปแบบนี้ กรณี ข้อความกับ pointer to pointer*/
// printf("\n *(ptt+1) = %c ",*(ptt+1)); ใช้ในรูปแบบนี้ได้ผลไม่ถูกต้อง บางกรณีคอมไพล์ผ่านแต่ทำงานไม่ได้
} ผลการทำงานของโปรแกรมเป็นดังรูป
ไม่มีความคิดเห็น:
แสดงความคิดเห็น