ใบความรู้ที่ 2.3 นิพจน์และตัวดำเนินการทางคณิตศาสตร์

1

ใบความรู้ที 2.3
เรือง นิพจน์และตวั ดําเนินการ

ในการเขียนโปรแกรมใหค อมพิวเตอรป ระมวลผลนั้น สามารถนาํ คาคงท่ี ตวั แปร
ตวั ดาํ เนนิ การมาประกอบกันเปน นพิ จนไ ด โดยในนิพจนห นง่ึ ๆ สามารถนาํ ตวั ดาํ เนนิ การมากกวา
หนึง่ ตัวมาใชไ ด ตวั อยางเชน

int y; //ประกาศตวั แปร y สําหรับเก็บเลขจํานวนเตม็
y = 5 * 3 + 2 * 2; //สรา งนพิ จนแ ลวกาํ หนดคาใหก บั ตวั แปร
printf (“Output = %d”, y);

จากตวั อยา งผลลพั ธท ไี่ ดจ ะเปน Output = 19 โดยการประมวลผลลักษณะนี้ผเู ขียนโปรแกรม
จะตองเขาใจลําดับกอนหลังของการกระทาํ ของตวั ดาํ เนนิ การดวยวา ถา หากมตี วั ดาํ เนินการ
หลายๆ ตัวประกอบอยู คอมพวิ เตอรจ ะประมวลผลอยา งไร จากตวั อยางโปรแกรมจะนํา 5
คณู กบั 3 กอ น จากนน้ั นาํ คา 2 คณู กบั 2 แลวนาํ ผลลัพธท งั้ สองมารวมกนั แลว เกบ็ ไวใ นตวั แปร
y สําหรบั ตัวดาํ เนนิ การทางคณิตศาสตรจ ะกลา วในลําดบั ตอ ไป

1. นพิ จน์ (expression)
ในภาษาซี นิพจน หมายถึง ส่ิงที่ประมวลผลแลวสามารถใหเ ปน คาตวั เลขได ซ่งึ แตล ะชนิด

จะมีระดบั ความยากงา ยในการประมวลผลทแ่ี ตกตางกนั นพิ จนท ่ีมีระดบั การประมวลผลแบบงา ย
ท่สี ุด จะประกอบดว ย ตวั แปรเพยี งตวั เดียว หรอื คาคงท่ี นพิ จนทม่ี ลี กั ษณะเปน คาคงท่ี เชน

100
‘g’
นพิ จนท ี่เปน คาคงท่ที เี่ ปน สญั ลกั ษณ เชน
#define VAT 7 //ประกาศตวั แปร VAT มีคาเทากับ 7
#define PI 3.14159 //ประกาศตวั แปร PI มคี า เทา กับ 3.14159
const int a = 35; //ประกาศตวั แปร a มีคา เทากบั 35
const char ch = ‘m’; //ประกาศตัวแปร ch มคี า เทากับ ตัวอกั ษร m

2

จากขอ ความส่ังในภาษาซีดงั กลาวขา งตน ทําให VAT, PI, a และ ch ตา งเปน นิพจน
ทเี่ ปน คาคงที่ นพิ จนท ่มี ีลกั ษณะเปนตวั แปร เชน

int count; //ประกาศตัวแปร count สําหรับเก็บเลขจํานวนเต็ม
float amount; //ประกาศตัวแปร amount สาํ หรับเกบ็ เลขจํานวนจริง
char ch; //ประกาศตวั แปร ch สาํ หรับเกบ็ ตวั อกั ษร

จากขอ ความส่งั ในภาษาซีดงั กลาวขา งตน ทาํ ให count, amount, และ ch ตา งเปน นพิ จน
ทเ่ี ปน ตัวแปร ดงั นนั้ นพิ จน จงึ หมายถงึ จํานวนใดจํานวนหนงึ่ ตอ ไปนี้

1.1 จาํ นวนเต็มจาํ นวนเดยี ว
1.2 จาํ นวนจริงจํานวนเดยี ว
1.3 ตวั เลขจํานวนเตม็ หรอื ตวั เลขจาํ นวนจริง หลายจํานวน ท่เี ชอื่ มโยงกนั ดว ยตวั ดาํ เนินการ

+, -, *, / หรือ % ซึง่ เรยี กวา การคาํ นวณทางคณิตศาสตร
สาํ หรับนิพจนท มี่ ีระดบั การประมวลผลทีซ่ ับซอ น จะประกอบดวย นิพจนที่มรี ะดบั
การประมวลผลอยา งงายหลายนิพจน และเช่อื มตอกนั ดว ยตัวดาํ เนนิ การ เชน

นพิ จนทีป่ ระกอบดว ย 2 นิพจน และ 1 ตัวดาํ เนินการ
37 + 6
54 * 7
405 / 9

นพิ จนทม่ี คี วามซบั ซอ นมากข้นึ เชน
score1 * 2 + score2 * 5 + score3 * 3

2. ข้อความสังกาํ หนดค่า (assignment statement)
ขอความส่ังกาํ หนดคา ใชสําหรบั กําหนดคา ใหก บั ตัวแปร มรี ปู แบบดังน้ี
ตัวแปร = นิพจน ;
ขอ ความสง่ั กาํ หนดคา คือ ขอ ความสั่งที่ใชส าํ หรบั สัง่ ใหน าํ ผลลัพธข องนพิ จนท ่ีอยูดา นขวา

ของตวั ดําเนนิ การเทากับ (=) มาเกบ็ ไวใ นตัวแปรท่ีอยดู า นซายของตัวดาํ เนนิ การเทากบั

3

เม่อื นํานิพจนม าเขียนไวใ นโปรแกรมภาษาซจี ะกลายเปนขอ ความกําหนดคา ดงั ตวั อยา งตอไปน้ี
con = 10.5;
result = 25 * 6;
point = score1 * 2 + score2 * 5 + score3 * 3;

ตวั อย่างที 1 การใชข อ ความสั่งกําหนดคา //นาํ คาท่ีเกบ็ ใน a ไปเกบ็ ไวใ น b

1 #include <stdio.h>
2 #include <conio.h>
3 main ( )
4{
5 int a, b;
6 printf ("Insert number = ");
7 scanf (“%d”, &a);
8 b = a;
9 printf (“a is %d\n”, a);
10 printf (“b is %d\n”, b);
11 getch ( );
12 }

ผลการกระทาํ การ
Insert number = (รบั คา ตัวเลข)
a is (ปรากฏตวั เลข)
b is (ปรากฏตัวเลข)
ขอความสง่ั กาํ หนดคา อาจเขยี นในรูปแบบที่ซบั ซอนขน้ึ a = b = 0;
กาํ หนดใหเ ก็บคา ศนู ยไวใ น a และ b

4

ตวั อย่างที 2 การใชข อความสงั่ กําหนดคาท่ีซ้ําซอ น
1 #include <stdio.h>
2 #include <conio.h>
3 main ( )
4{
5 int sum, total;
6 sum = total = 0;
7 printf (“sum = %d\n”, sum);
8 printf (“total = %d\n”, total);
9 getch ( );
10 }

ผลการกระทําการ
sum = 0
total = 0

3. ตวั ดําเนนิ การทางคณติ ศาสตร์ (arithmetic operator)
ในการเขียนโปรแกรม เพื่อคํานวณทางคณติ ศาสตร จะตอ งใชต วั ดําเนินการตางๆ ซง่ึ มี

วิธีการใชง านและการทํางาน ดังนี้
ตารางที 1 อธิบายการทํางานของตัวดาํ เนนิ การทางคณิตศาสตร

การคาํ นวณ ตวั ดําเนินการ ตวั อย่าง การทํางาน
บวก + c = a + b;
นาํ คาท่เี กบ็ ใน a บวกกบั คา ท่ีเกบ็ ใน b
ลบ - c = a – b; แลว เก็บผลลัพธไ วใ น c
นาํ คา ท่เี กบ็ ไวใ น b ลบออกจากคา
คูณ * c = a * b; ทีเ่ กบ็ ใน a แลวเก็บผลลัพธไ วใน c
นําคา ท่ีเก็บใน a คณู กบั คาทเี่ กบ็ ใน b
แลว เก็บผลลัพธไวใน c

5

การคาํ นวณ ตวั ดาํ เนินการ ตวั อย่าง การทํางาน
หาร / c = a / b;
ใหคา ท่ีเก็บใน a เปนตวั ต้ัง คา ที่เก็บไวใ น
มอดูลสั % c = a % b; b เปนตวั หาร แลวเกบ็ ผลหารไวใ น c
ถา ท้ังตัวตัง้ และตวั หารตา งเปน จํานวนเต็ม
คาทีเ่ ก็บไวใ น c จะเปน จาํ นวนเตม็
แตถ า ตวั ตงั้ หรอื ตัวหารตัวใดตวั หนงึ่
เปนจํานวนจรงิ ท่มี ที ศนิยม ผลลัพธท่ีได
จะเปนจาํ นวนจริงทีม่ ที ศนิยมดว ย
ใหค าทเ่ี กบ็ ใน a เปน ตวั ตงั้ คา ทเ่ี กบ็ ใน b
เปนตวั หาร แลวเก็บเศษไวใ น c

ลําดบั การดาํ เนนิ การในนพิ จนท ี่มตี วั ดาํ เนินการหลายตัว
ในกรณีทนี่ ิพจนมตี วั ดําเนนิ การหลายตัว จะตองดาํ เนนิ การตามลาํ ดับตอ ไปน้ี
1. ( )
2. * / %
3. + -

ถาในนิพจนม ีตวั ดาํ เนินการท่ีมลี ําดับเทา กนั จะประมวลผลจากซา ยไปขวา

ตวั อย่างที 3 การแสดงผลลพั ธข องการบวก //รับคา จาํ นวนเต็มมาเกบ็ ไวใ น a
//รบั คา จํานวนเตม็ มาเก็บไวใ น b
1 #include <stdio.h> //แสดงผลจากการบวก
2 #include <conio.h>
3 main ( )
4{
5 int a, b, sum;
6 scanf (“%d”, &a);
7 scanf (“%d”, &b);
8 printf (“Sum is %d\n”, a + b);
9 getch ( );
10 }

6

ผลการกระทําการ
รบั คา (a) รบั คา (b) จากแปนพมิ พ
Sum is (นําคาทเี่ ก็บใน a บวกกับคา ท่ีเกบ็ ใน b แลว แสดงผลลัพธ)

ตวั อย่างที 4 การใชข อ ความส่ังกาํ หนดคา และแสดงผลลพั ธข องการบวก

1 #include <stdio.h>

2 #include <conio.h>

3 main ( )

4{

5 int a, b, sum;

6 scanf (“%d”, &a); //รับคาจํานวนเตม็ มาเก็บไวใ น a

7 scanf (“%d”, &b); //รบั คาจาํ นวนเต็มมาเกบ็ ไวใ น b

8 sum = a + b; /*นาํ คาทเี่ ก็บใน a บวกกบั คาที่เกบ็ ใน
b แลวนําผลบวกไปเก็บใน sum*/

9 printf (“Sum is %d\n”, sum); //แสดงผลจากการบวก

10 sum = sum + sum; /*นาํ คาทเ่ี ก็บใน sum บวกกนั แลว เก็บ
ไวใน sum อกี ครง้ั */
11 printf (“Sum is %d\n”, sum);
12 getch ( ); //แสดงผลจากการบวก
13 }

ผลการกระทําการ
รับคา (a) รบั คา (b) จากแปน พมิ พ
Sum is (นาํ คาท่เี ก็บใน a บวกกับคาที่เกบ็ ใน b แลว เกบ็ ผลลพั ธไ วใ น Sum)
Sum is (นาํ คา ทเ่ี ก็บใน Sum บวกกับคา ทีเ่ ก็บใน Sum แลว เกบ็ ผลลัพธไ วใน Sum)

7

ตวั อย่างที 5 การแสดงผลลพั ธข องการคูณ

1 #include <stdio.h>

2 #include <conio.h>

3 #define GP 454

4 main ( )

5{

6 int gram, pound;

7 scanf (“%d”, &pound); //รบั คาจาํ นวนเต็ม pound

8 gram = pound * GP; //แปลงปอนดใ หเ ปนกรัม

9 printf (“Weight in grams = %d\n”, gram); /*แสดงคา กรมั ทไ่ี ดจ ากการแปลง*/

10 getch ( );

11 }

ผลการกระทําการ
รบั คา (pound) จากแปน พมิ พ
Weight in grams = (นําคาทเ่ี กบ็ ใน pound คณู กบั คาคงท่ที เ่ี กบ็ ใน GP

แลว เกบ็ ผลลพั ธไ วใ น gram)

ตวั อย่างที 6 การแสดงผลลพั ธของการหารและมอดูลสั

1 #include <stdio.h>

2 #include <conio.h>

3 #define MS 60 //กําหนดให MS เปนตัวคงทม่ี คี า 60

4 #define HM 60 //กาํ หนดให HM เปนตัวคงท่มี ีคา 60

5 main ( )

6{

7 int sec, min, hr, sec_left, min_left;

8 scanf (“%d”, &sec); //รบั คา sec (วินาท)ี
9 min = sec / MS; //แปลงวนิ าทใี หเ ปนนาที

8

10 sec_left = sec % MS; //หาเศษวินาทีจากการแปลงเปน นาที

11 hr = min / HM; //แปลงนาทใี หเ ปนชวั่ โมง

12 min_left = min % HM; //หาเศษนาทีจากการแปลงเปนช่ัวโมง

13 printf (“%d seconds is equal to”, sec);

14 printf (“%d h, %d m, and %d s”, hr, min_left, sec_left);

15 getch ( );

16 }

ผลการกระทําการ
รบั คา (sec) จากแปน พมิ พ
แสดงคา (sec) seconds is equal (hr) h, (min_left) m, (sec_left) s

ตวั อย่างที 7 การแสดงผลลพั ธข องการหาร /*การหาร โดยมตี ัวตั้ง
1 #include <stdio.h> และตวั หารเปนจาํ นวนเตม็ */
2 #include <conio.h> /*การหาร โดยมตี วั ตง้ั
3 main ( ) และตวั หารเปน จาํ นวนเต็ม*/
4{
5 printf (“\n integer division”); /*การหาร โดยมตี วั ตง้ั และตวั หาร
6 printf (“\n 11 / 4 = %d”, 11 / 4); เปน จาํ นวนจรงิ ทม่ี ีทศนิยม*/
/*การหาร โดยมตี ัวต้ังและตวั หาร
7 printf (“\n 3 / 4 = %d”, 3 / 4); เปน จาํ นวนจรงิ ทม่ี ที ศนิยม*/

8 printf (“\n floating point division”);
9 printf (“\n 11. / 4. = %f”, 11. / 4.);

10 printf(“\n 3. / 4. = %f”, 3. / 4.);

11 getch ( );
12 }

9

ผลการกระทาํ การ
-บรรทัดวาง-
integer division
11 / 4 = 2
3/4=0
floating point division
11. / 4. = 2.750000
3. / 4. = 0.750000

ตวั อย่างที 8 การใชข อความสงั่ กาํ หนดคาและการบวก

1 #include <stdio.h>

2 #include <conio.h>

3 main ( )

4{

5 int a, b, x;

6 a = 20; //กําหนดใหเก็บคา 20 ไวใน a
7 x = a; //กาํ หนดใหเ ก็บคา ที่อยใู น a ไวใน x
8 printf (“x is %d\n”, x); //แสดงคาที่เกบ็ ใน x
9 x = a + 1; //นําคา ท่เี ก็บใน a บวก 1 แลวเกบ็ ไวใ น x
10 printf (“x is %d\n”, x); //แสดงคา ทเ่ี ก็บใน x
11 b = 30; //กําหนดใหเก็บคา 30 ไวใ น b
12 x = a + b; /*นาํ คา ที่อยใู น a บวกกบั คา ทอ่ี ยใู น b
แลวเกบ็ ไวใน x*/
13 printf (“x is %d\n”, x); //แสดงคา ท่เี ก็บใน x
14 getch ( );
15 }

10

ผลการกระทาํ การ
x is 20
x is 21
x is 50

ตวั อย่างที 9 การประมวลผลนิพจนม ีตวั ดําเนนิ การหลายตวั
1 #include <stdio.h>
2 #include <conio.h>
3 main ( )
4{
5 int p, q, r, w, m, n, y;
6 p = 30;
7 q = 2;
8 r = 10;
9 w = 7;
10 m = 20;
11 n = 5;
12 y = p + q * r % w – m / n;
13 printf (“y = %d”, y);
14 getch ( );
15 }

ผลการกระทาํ การ
y = 32

11

ตวั อย่างที 10 การใชข อ ความสั่งกําหนดคา ในรูปแบบทซี่ ับซอ น และมตี วั ดําเนนิ การหลายตวั
1 #include <stdio.h>
2 #include <conio.h>
3 main ( )
4{
5 float sum, point, score1, score2, score3;
6 scanf (“%f %f %f”, &score1, &score2, &score3);
7 sum = point = score1 * 2 + score2 * 5 + score3 * 3;
8 printf (“sum = %f\n”, sum);
9 printf (“point = %f\n”, point);
10 getch ( );
11 }

ผลการกระทําการ
รับคา (score1) รบั คา (score2) รับคา (score3) จากแปนพมิ พ
sum = (นําคา ทเ่ี ก็บใน score1 คณู กับ 2 นําคาที่เกบ็ ใน score2 คณู กบั 5

นาํ คาทเ่ี ก็บใน score3 คณู กับ 3 จากนัน้ นาํ มาบวกกนั แลว เกบ็ ผลลพั ธไ วใน
point)
point = (นาํ คา ที่เกบ็ ใน score1 คูณกบั 2 นําคาท่เี ก็บใน score2 คูณกบั 5
นาํ คาทเ่ี กบ็ ใน score3 คณู กบั 3 จากนัน้ นาํ มาบวกกนั แลว เกบ็ ผลลพั ธไว)

4. ตวั ดาํ เนินการเอกภาค (unary operator)
ตวั ดําเนนิ การเอกภาค คือ การใชต วั ดาํ เนนิ การ กบั ตวั แปรตัวเดยี ว ในที่นี้จะแสดงการใช

ตวั ดาํ เนนิ การ 2 ตวั กับตัวแปรตวั เดียว ซ่งึ มีลกั ษณะการใช 2 แบบ คือ
4.1 ตวั ดาํ เนนิ การเอกภาคเติมหลัง (postfix mode) หมายถึง ตัวดาํ เนินการเอกภาค
อยหู ลังตวั แปร เชน a++ หมายถึง ใหเ พิ่มคาใหต วั แปร a ข้นึ อกี 1 คา
4.2 ตัวดําเนนิ การเอกภาคเติมหนา (prefix mode) หมายถงึ ตัวดาํ เนนิ การเอกภาค
อยูหนา ตวั แปร เชน ++a หมายถงึ ใหเพ่ิมคาใหต วั แปร a ข้ึนอีก 1 คา

12

การใชต วั ดําเนินการเอกภาคท้ัง 2 แบบ มกี ารใชงานดงั น้ี
ตารางที 2 อธิบายการทํางานของตัวดาํ เนินการเอกภาค

การคาํ นวณ ตวั ดําเนินการ ตวั อย่าง การทํางาน
เพม่ิ คา ตัวถกู ดาํ เนินการทีละหนง่ึ ++ x++ x=x+1
เพ่มิ คา ตวั ถกู ดําเนินการทีละหนึ่ง ++ ++x x=x+1
ลดคา ตัวถกู ดาํ เนินการทีละหน่ึง -- x-- x=x-1
ลดคา ตัวถูกดาํ เนินการทีละหนงึ่ -- --x x=x-1

ตวั อย่างที 11 การใชตวั ดาํ เนนิ การเอกภาค //กําหนดใหเ ก็บคา 20 ไวใ น a
//กาํ หนดใหเ กบ็ คา ทเ่ี ก็บใน a ไวใ น x
1 #include <stdio.h> //แสดงคาทเ่ี ก็บใน x
2 #include <conio.h> //เพม่ิ คา x ข้ึนอกี 1
3 main ( ) //แสดงคา x
4{
5 int a, b, x; /*กําหนดใหนาํ คา ทอี่ ยใู น a บวกเขา
6 a = 20; กบั คาท่เี ก็บใน b แลวนําไปเก็บไวใน x*/
7 x = a; //เพมิ่ คา x ขึ้นอกี 1
8 printf (“x is %d\n”, x); //แสดงคาที่เก็บใน x
9 x++;
10 printf (“x is %d\n”, x);
11 b = 30;
12 x = a + b;

13 ++x;
14 printf (“x is %d\n”, x);
15 getch ( );
16 }

13

ผลการกระทําการ
x is 20
x is 21
x is 51
จากทกี่ ลาวมาแลวขา งตน จะเห็นวา การใชตวั ดาํ เนนิ การเอกภาคทง้ั 2 แบบ มีการทํางาน
เหมือนกัน แตใ นความเปนจริง ตัวดาํ เนินการเอกภาคเติมหลงั มีการทาํ งานและความหมาย
แตกตางจากตวั ดําเนนิ การเอกภาคเติมหนา เม่อื มีการใชงานรวมกบั การทาํ งานอ่ืนภายในคําสง่ั
เดียวกนั ดังนี้
1. ตัวดาํ เนนิ การเอกภาคเติมหลัง (postfix mode) จะทาํ งานอืน่ ภายในขอความสั่งเดียวกันกอ น
จงึ จะเพมิ่ คา ใหต วั แปร
2. ตัวดาํ เนนิ การเอกภาคเตมิ หนา (prefix mode) จะเพมิ่ คา ใหต ัวแปรกอนแลว จงึ จะทํางานอื่น
ภายในขอความส่ังเดียวกนั

ตวั อย่างที 12 การใชตวั ดาํ เนนิ การเอกภาครว มกบั การทาํ งานอ่นื ๆ ภายในขอ ความสัง่ เดียวกัน

1 #include <stdio.h>

2 #include <conio.h>

3 main ( )

4{

5 int x, y;

6 x = y = 0;

7 printf (“\nx y”);

printf (“\n%d %d”, x++, ++y); /*พมิ พค า x กอนแลว จึงเพิ่มคา x

8 ขนึ้ อกี 1 เพ่ิมคา y ข้ึนอกี 1

แลวจึงพิมพค า y */

9 printf (“\n%d %d”, x++, ++y);

10 printf (“\n%d %d”, x++, ++y);
11 printf (“\n%d %d”, x++, ++y);
12 printf (“\n%d %d”, x++, ++y);

14

13 y = x++; //เก็บคา x ไวใ น y กอ น แลว จงึ เพิ่มคา x ขน้ึ อีก 1

14 printf (“\n%d %d”, x, y);

15 y = ++x; //เพ่ิมคา x ขนึ้ อกี 1 แลว จงึ เกบ็ คา x ไวใน y

16 printf (“\n%d %d”, x, y);

17 getch ( );

18 }

ผลการกระทาํ การ
-บรรทดั วา ง-
xy
01
12
23
34
45
65
77

5. ตวั ดําเนนิ การประกอบ (compound operator)
ตวั ดําเนนิ การประกอบ เปนการใชต วั ดาํ เนนิ การหนงึ่ ตวั รวมกับเคร่อื งหมายเทากบั การใช

ตวั ดาํ เนนิ การประกอบจะชวยใหเ ขยี นขอ ความส่งั ไดสนั้ และเร็วขน้ึ
ตารางที 3 อธิบายการทํางานของตวั ดําเนินการประกอบ

ตวั ดําเนนิ การประกอบ ตวั อย่าง การทาํ งาน
+= x += 5 x=x+5
-= x -= 5 x=x-5
*= x *= y x=x*y
/= x /= y x=x/y

ตวั ดําเนินการประกอบ ตวั อย่าง 15
%= x %= y
+= x += y / 8 การทํางาน
x=x%y
x=x+y/8

ลาํ ดบั ในการดําเนนิ การ
ในกรณีทคี่ าํ ส่ังประกอบดว ยตวั ดําเนนิ การประกอบ ตวั ดําเนินการเอกภาคหลายตัว

จะประมวลผลตามลําดบั ตอไปน้ี
1. ( )
2. ++ --
3. * / %
4. + -
5. += *= /= -= %=

ถา ในคาํ ส่งั มีตวั ดาํ เนินการท่ีอยใู นลําดับเทากนั จะประมวลผลจากซายไปขวา

ตวั อย่างที 13 การใชตวั ดาํ เนนิ การประกอบ

1 #include <stdio.h>
2 #include <conio.h>
3 main ( )
4{
5 int x = 10, y = 20 ;

6 printf (“\n%d %d”, x, y);
7 ++x;
8 printf (“\n%d %d”, x, y);
9 y = --x;
10 printf (“\n%d %d”, x, y);
11 x = x-- + y;
12 printf (“\n%d %d”, x, y);
13 y = x- ++x;

16

14 printf(“\n%d %d”, x, y);
15 getch ( );
16 }

ผลการกระทําการ อธบิ ายในตารางท่ี 4
ตารางที 4 อธบิ ายการทาํ งานของคาํ ส่ังกาํ หนดคาและคําสงั่ ที่เปล่ยี นแปลงคา

ของตัวแปร x และ y

คาํ สัง x y
int x = 10, y = 20 10 20
11 20
++x; 10 10
y = --x; 19 10
x = x-- + y; 20 0
y = x - ++x;

6. การแปลงชนดิ ข้อมูล (type cast)
การแปลงชนิดขอมลู มหี ลายวธิ ี แตท ก่ี ลา วในทนี่ ีค้ ือ การแปลงชนิดขอมลู โดยการกาํ หนดชนดิ

ไวท่หี นา ขอมลู นัน้
ตวั แปร = (ชนิดขอมูล) นพิ จน;

โดยท่ี (ชนดิ ขอ มลู ) นพิ จน อาจมหี ลายชดุ แลวเชอื่ มโยงกันดว ยตวั ดาํ เนินการตางๆ

ตวั อย่างที 14 การแปลงชนิดขอ มูล จากจํานวนจรงิ ทมี่ ีทศนิยมใหเปน จํานวนเต็ม

1 #include <stdio.h>
2 #include <conio.h>
3 main ( )
4{
5 int x;
6 x = 5.6 + 3.5;

17

7 printf (“\n%d”, x);
8 x = (int) 5.6 + (int) 3.5;
9 printf (“\n%d”, x);
10 getch ( );
11 }

ผลการกระทาํ การ
-บรรทัดวา ง-
9
8

ตวั อย่างที 15 การแปลงชนดิ ขอ มลู จากจํานวนเตม็ ใหเปนจํานวนจริงทีม่ ที ศนิยม

1 #include <stdio.h>

2 #include <conio.h>

3 main ( )

4{

5 int x = 3, y = 2;

6 float a, b;

7 a = x / y; //ทัง้ ตวั ตัง้ และตัวหารตางเปนจาํ นวนเต็ม ผลลัพธจ ึงปด เศษทง้ิ

8 printf (“%f”, a);

9 b = (float) x / y; /*กาํ หนดใหตวั ตัง้ เปน จํานวนจริงที่มที ศนิยมผลลัพธ
จึงเปน จํานวนจรงิ ทมี่ ที ศนยิ มดว ย*/

10 printf (“\n%f”, b);

11 getch ( );

12 }

ผลการกระทาํ การ
1.000000
1.500000

18

7. การกาํ หนดค่าจากข้อมลู หลายชนดิ (assignment with mixed types)
ถานพิ จนในขอความส่งั กาํ หนดคา ประกอบดว ย ตวั แปร หรือ ตัวคงทีท่ ีม่ ชี นดิ ขอ มลู

ตา งกัน จะตอ งแปลงใหเปนชนดิ เดยี วกนั กอ น แลว จึงนํามาดาํ เนินการ โดยมหี ลกั ดงั นี้ คือ
ถา ตวั แปร หรือ ตวั คงท่ี มชี นดิ ขอมูลทตี่ างกัน จะตองแปลงใหเปนชนิดเดียวกนั กอน

แลวจงึ ดําเนนิ การ โดยในการแปลงจะตองแปลงชนดิ ขอ มลู ทีม่ ขี นาดเลก็ กวา ใหเปนชนดิ ขอมลู
ทม่ี ขี นาดใหญกวา

ดงั นน้ั ถาตวั แปร หรือตัวคงที่ ตวั หนึง่ เปน ชนิดจํานวนเตม็ (int) สวนอีกตวั หนง่ึ เปน ชนดิ
จํานวนจรงิ (float) จะตอ งแปลงตวั แปรหรอื ตัวคงที่ที่เปนจํานวนเต็ม (int) ใหเ ปน จาํ นวนจรงิ
(float) กอน แลว จงึ ดําเนินการ

ตวั อย่างที 16 แสดงการกาํ หนดคาจากขอมูลหลายชนดิ

1 #include <stdio.h>

2 #include <conio.h>

3 main ( )

4{

5 int i, j, k;

6 float a, b, c ;

7 i = 5;

8 j = 3;

9 a = 2.5;

10 b = 30.6;

11 k = i + a; /*แปลงชนิดขอมูลของ i ใหเปน float กอ น
แลว จึงบวก จากน้นั ปด เศษทิง้ แลวคอ ยนําไปเกบ็ ท่ี k*/

12 printf (“k = %d\n”, k);

13 k = a + b; //ปดเศษของผลบวกทิง้ แลวคอยนาํ ไปเกบ็ ไวใน k

14 printf (“k = %d\n”, k);

15 c = a + b;

16 printf (“c = %f\n”, c);

19

17 c = i + a;
18 printf (“c = %f\n”, c);
19 getch ( );
20 }

ผลการกระทําการ
k=7
k = 33
c = 33.099998
c = 7.500000

8. ตวั ดําเนนิ การสัมพนั ธ์ (relational operator)
ตวั ดาํ เนนิ การสัมพนั ธ ใชส าํ หรับการเปรยี บเทยี บนพิ จน ผลของการเปรียบเทยี บนพิ จน

ที่มตี ัวดําเนนิ การสมั พนั ธจ ะใหผลลัพธเปนจรงิ หรอื เทจ็
ตารางที 5 ตัวดาํ เนินการสัมพนั ธ มีวธิ ีการใชด งั น้ี

ตวั ดําเนนิ การ ความหมาย ตวั อย่าง
== เทา กบั x == y
> มากกวา x>y
< นอยกวา x<y
>= x >= y
<= มากกวา หรอื เทา กับ x <= y
!= นอ ยกวา หรอื เทากับ x != y

ไมเ ทากับ

สาํ หรบั นพิ จนท่ีมีการใชต วั ดําเนนิ การสมั พันธ เมอ่ื การเปรยี บเทยี บไดผ ลลพั ธเ ทากับศนู ย
จะแปลความหมายวา เทจ็ แตหากผลลัพธเทากับหนงึ่ จะแปลความหมายวา จรงิ

20

ตารางที 6 การแปลความหมายของนพิ จน เมื่อกําหนดให x = 5, y = 10

นพิ จน์ ผลลพั ธ์ การแปลความหมาย
x == y 0 เท็จ
x>y 0 เท็จ
x >= y 0 เท็จ
x <= y 1 จริง
x != y 1 จรงิ
x*x<y*y 1 จรงิ
x + y >= x * y 0 เท็จ

9. ตวั ดําเนินการตรรกะ (logical operator)
ตวั ดําเนนิ การตรรกะใชสําหรับเชอ่ื มโยงความสมั พันธระหวา งนิพจนตรรกะตั้งแต 2 นิพจน

ข้นึ ไป ผลจากการเชือ่ มโยงความสัมพันธด งั กลาว จะใหผ ลลพั ธเ ปนจรงิ หรอื เท็จ ตวั ดาํ เนินการ
ตรรกะมวี ิธีการใชด งั นี้

ตารางที 7 อธิบายการทาํ งานของตวั ดาํ เนนิ การตรรกะ

ตวั ดําเนินการ ความหมาย ตวั อย่าง
&& และ (and) x && y
|| หรือ (or) x || y
! ไม (not)
!x

21

ตารางที 8 การทาํ งานของตวั ดาํ เนนิ การและ (and) ตัวดาํ เนินการหรอื (or)
และตัวดําเนินการไม (not)

xy นิพจน์ ผลลพั ธ์ การแปล
ความหมาย
nonzero (จริง) nonzero (จรงิ ) x && y 1
nonzero (จรงิ ) 0 (เทจ็ ) x && y 0 จรงิ
x && y 0 เทจ็
0 (เทจ็ ) nonzero (จรงิ ) x && y 0 เทจ็
0 (เท็จ) 0 (เทจ็ ) x || y 1 เทจ็
nonzero (จรงิ ) x || y 1 จริง
nonzero (จริง) nonzero (จริง) x || y 1 จรงิ
0 (เทจ็ ) 0 (เทจ็ ) x || y 0 จรงิ
0 (เท็จ) 0 เทจ็
nonzero (จรงิ ) nonzero (จริง) !x 1 เท็จ
0 (เท็จ) 0 (เทจ็ ) !x จรงิ
-
-

ลาํ ดับในการดําเนนิ การ ในนิพจนทีป่ ระกอบดวยตวั ดําเนนิ การตา งๆ หลายชนดิ จะตอ ง
ดาํ เนินการตามลาํ ดบั ดังตอไปน้ี

1. ( )
2. ++ --
3. * / %
4. + -
5. < <= > >=
6. == !=
7. &&
8. ||
9. = += -= *= /= %=

22

ในกรณที นี่ ิพจนมตี ัวดําเนนิ การท่อี ยูใ นลาํ ดับเดยี วกันหลายตัว จะตองดําเนนิ การ
ตวั ดาํ เนนิ การท่อี ยดู านซา ยของนิพจนก อ น

ตารางที 9 ลาํ ดบั ในการดําเนนิ การ

นพิ จน์ ผลลพั ธ์ การแปลความหมาย
(5 == 4 + 1) && (18 <= 6 * 4) 1 จริง

เนื่องจากประโยคในวงเล็บทง้ั สองวงเลบ็ เปน จริง ดังน้นั ผลลพั ธทไี่ ดจ ะเปนจรงิ

-----------------------------------------------------------