目次
1. บทนำ
ภาษา C ถูกนำมาใช้อย่างแพร่หลายในการเขียนโปรแกรมระบบและการพัฒนาระบบสมองกลฝังตัว โดยที่ตัวดำเนินการเป็นองค์ประกอบสำคัญสำหรับการดำเนินการขั้นพื้นฐาน บทความนี้จะอธิบายรายละเอียดเกี่ยวกับตัวดำเนินการในภาษา C ตั้งแต่การใช้งานพื้นฐานไปจนถึงการประยุกต์ใช้ การจัดการข้อผิดพลาด และวิธีการเพิ่มประสิทธิภาพ การทำความเข้าใจตัวดำเนินการให้ลึกซึ้งจะช่วยให้เขียนโปรแกรมได้อย่างมีประสิทธิภาพ ป้องกันการเกิดข้อผิดพลาด และเขียนโค้ดที่มีประสิทธิภาพดีขึ้น นอกจากนี้ ในส่วนหลัง เราจะอธิบายเทคนิคการจัดการข้อผิดพลาดและการเพิ่มประสิทธิภาพของตัวดำเนินการ พร้อมทั้งให้ความรู้ที่เป็นประโยชน์สำหรับการพัฒนาจริง ด้วยบทความนี้ คุณจะสามารถใช้งานตัวดำเนินการในภาษา C ได้อย่างมั่นใจ2. พื้นฐานและประเภทของตัวดำเนินการ
ตัวดำเนินการคืออะไร?
ตัวดำเนินการคือสัญลักษณ์ที่ใช้ในการจัดการข้อมูลในภาษา C ในภาษา C มีตัวดำเนินการทางคณิตศาสตร์ ตัวดำเนินการกำหนดค่า ตัวดำเนินการเปรียบเทียบ ตัวดำเนินการตรรกะ และอื่นๆ ซึ่งสิ่งเหล่านี้มีความจำเป็นในการสร้างตรรกะของโปรแกรมตัวดำเนินการทางคณิตศาสตร์
ตัวดำเนินการทางคณิตศาสตร์เป็นตัวดำเนินการสำหรับการคำนวณตัวเลขขั้นพื้นฐาน+(การบวก):a + b→ บวกตัวเลขสองตัว-(การลบ):a - b→ ลบตัวเลขสองตัว*(การคูณ):a * b→ คูณตัวเลขสองตัว/(การหาร):a / b→ หารตัวเลขสองตัว%(การหารเอาเศษ):a % b→ คืนค่าเศษที่ได้จากการหารaด้วยb
ตัวดำเนินการกำหนดค่า
ตัวดำเนินการกำหนดค่าใช้สำหรับกำหนดค่าให้กับตัวแปร=(การกำหนดค่า):a = 5→ กำหนดค่า 5 ให้กับตัวแปรa+=(การบวกแล้วกำหนดค่า):a += 2→ บวก 2 เข้ากับaแล้วกำหนดผลลัพธ์ให้กับa-=(การลบแล้วกำหนดค่า):a -= 1→ ลบ 1 ออกจากaแล้วกำหนดผลลัพธ์ให้กับa

ตัวดำเนินการเปรียบเทียบ
ตัวดำเนินการเปรียบเทียบใช้เปรียบเทียบค่าสองค่าและคืนค่าจริง (true) หรือเท็จ (false)==(เท่ากับ):a == b→ คืนค่าจริงถ้าaเท่ากับb!=(ไม่เท่ากับ):a != b→ คืนค่าจริงถ้าaไม่เท่ากับb>(มากกว่า):a > b→ คืนค่าจริงถ้าaมากกว่าb
ตัวดำเนินการตรรกะ
ตัวดำเนินการตรรกะใช้ในการรวมเงื่อนไขหลายๆ อย่างเพื่อตัดสินใจ&&(ตรรกะ AND):a && b→ คืนค่าจริงถ้าทั้งaและbเป็นจริง||(ตรรกะ OR):a || b→ คืนค่าจริงถ้าaหรือbอย่างใดอย่างหนึ่งเป็นจริง
ตัวดำเนินการ sizeof
ตัวดำเนินการ sizeof ใช้คำนวณขนาดที่ตัวแปรหรือชนิดข้อมูลใช้ในหน่วยความจำ มีประโยชน์อย่างยิ่งในการเพิ่มประสิทธิภาพการใช้หน่วยความจำของโครงสร้าง (struct) หรืออาเรย์int size = sizeof(int); // ชนิดข้อมูล int มักใช้ 4 ไบต์นอกจากนี้ยังมีประโยชน์ในการตรวจสอบขนาดของโครงสร้างและอาเรย์struct example {
int a;
char b;
};
int size = sizeof(struct example); // รับขนาดของโครงสร้างมาดูตัวอย่างการคำนวณจำนวนสมาชิกของอาเรย์กันint arr[10];
int num_elements = sizeof(arr) / sizeof(arr[0]); // คำนวณจำนวนสมาชิกของอาเรย์3. รายละเอียดและตัวอย่างการใช้งานตัวดำเนินการแต่ละชนิด
ตัวอย่างการใช้งานตัวดำเนินการทางคณิตศาสตร์
#include <stdio.h>
int main() {
int a = 10;
int b = 3;
printf("การบวก: %d\n", a + b);
printf("การลบ: %d\n", a - b);
printf("การคูณ: %d\n", a * b);
printf("การหาร: %d\n", a / b);
printf("เศษ: %d\n", a % b);
return 0;
}โค้ดนี้แสดงตัวอย่างการใช้งานพื้นฐานของตัวดำเนินการทางคณิตศาสตร์ ควรสังเกตว่าในการหารระหว่างจำนวนเต็ม จุดทศนิยมจะถูกตัดทิ้ง4. ลำดับความสำคัญและกฎการรวมตัวของตัวดำเนินการ
ลำดับความสำคัญของตัวดำเนินการกำหนดว่าจะทำการคำนวณตามลำดับใดเมื่อมีตัวดำเนินการหลายตัวอยู่ในนิพจน์เดียว กฎการรวมตัว (จากซ้ายไปขวา, จากขวาไปซ้าย) กำหนดว่าจะประเมินตัวดำเนินการที่มีลำดับความสำคัญเท่ากันจากทิศทางใดตัวอย่างลำดับความสำคัญ
int a = 2 + 3 * 4; // ผลลัพธ์คือ 14ในนิพจน์นี้ การคูณมีลำดับความสำคัญสูงกว่าการบวก ดังนั้นผลลัพธ์จึงเป็น 14 หากต้องการให้การบวกทำก่อน สามารถใช้วงเล็บเพื่อเปลี่ยนลำดับได้int a = (2 + 3) * 4; // ผลลัพธ์คือ 20รายการลำดับความสำคัญของตัวดำเนินการ
| ลำดับความสำคัญ | ตัวดำเนินการ |
|---|---|
| สูง | ++, -- (เพิ่มค่า, ลดค่า) |
| กลาง | *, /, % (การคูณ, การหาร, การหารเอาเศษ) |
| ต่ำ | +, - (การบวก, การลบ) |
คำอธิบายกฎการรวมตัว
ตัวดำเนินการกำหนดค่า= ในภาษา C มีกฎการรวมตัวจากขวาไปซ้าย สิ่งนี้มีประโยชน์เมื่อทำการกำหนดค่าต่อเนื่องดังนี้int a, b, c;
a = b = c = 5; // กำหนดค่า 5 ให้กับตัวแปรทั้งหมดเนื่องจากกฎการรวมตัวจากขวาไปซ้าย c = 5 จะถูกดำเนินการก่อน จากนั้น b = c และสุดท้าย a = b
5. การประยุกต์ใช้ตัวดำเนินการ: ตัวดำเนินการระดับบิตและตัวดำเนินการเลื่อนบิต
ตัวดำเนินการระดับบิต
ตัวดำเนินการระดับบิตใช้จัดการตัวเลขในระดับบิต มักใช้ในระบบระดับต่ำหรือระบบสมองกลฝังตัวint a = 5; // 0101
int b = 3; // 0011
int result = a & b; // ผลลัพธ์คือ 0001 (1)ในตัวอย่างนี้ ใช้ตัวดำเนินการระดับบิต AND (&) เพื่อคำนวณตรรกะ AND ของบิตต่อบิตของตัวเลขสองตัวตัวดำเนินการเลื่อนบิต
ตัวดำเนินการเลื่อนบิตใช้เลื่อนบิตไปทางซ้ายหรือขวาเพื่อจัดการค่า ตัวดำเนินการเลื่อนบิตมักใช้เพื่อจัดการตัวเลขได้อย่างมีประสิทธิภาพมากกว่าการคูณหรือหารint a = 5; // 0101
int result = a << 1; // 1010 (10) -> ทำให้ a เป็นสองเท่าการเลื่อนบิตไปทางซ้าย (<<) สามารถใช้เพื่อคูณตัวเลขด้วยเลขยกกำลังของ 2 ซึ่งเป็นวิธีการคำนวณที่มีประสิทธิภาพ6. การจัดการข้อผิดพลาดและการเพิ่มประสิทธิภาพของตัวดำเนินการ
การจัดการข้อผิดพลาดการหารด้วยศูนย์
การหารด้วยศูนย์ไม่ถูกต้องทางคณิตศาสตร์ และในภาษา C หากเกิดการหารด้วยศูนย์ โปรแกรมจะหยุดทำงาน ดังนั้นการตรวจสอบล่วงหน้าว่าไม่มีการหารด้วยศูนย์จึงเป็นสิ่งสำคัญ โค้ดต่อไปนี้เป็นตัวอย่างการตรวจสอบว่าไม่มีการหารด้วยศูนย์#include <stdio.h>
int main() {
int a = 10;
int b = 0;
if (b != 0) {
printf("ผลลัพธ์การหาร: %d\n", a / b);
} else {
printf("ข้อผิดพลาด: ไม่สามารถหารด้วยศูนย์ได้\n");
}
return 0;
}ในโค้ดนี้ หาก b ไม่เท่ากับศูนย์ จะทำการหาร แต่หากเท่ากับศูนย์ จะแสดงข้อความแสดงข้อผิดพลาด การทำเช่นนี้ช่วยป้องกันโปรแกรมหยุดทำงานและรับประกันการทำงานที่ปกติการจัดการข้อผิดพลาดโอเวอร์โฟลว์
โอเวอร์โฟลว์เกิดขึ้นเมื่อผลลัพธ์ของการดำเนินการเกินขอบเขตของชนิดข้อมูลของตัวแปร ในภาษา C จะไม่ตรวจจับโอเวอร์โฟลว์โดยอัตโนมัติ ดังนั้นจึงจำเป็นต้องตรวจสอบล่วงหน้า ต่อไปนี้เป็นตัวอย่างง่ายๆ เพื่อป้องกันโอเวอร์โฟลว์#include <stdio.h>
#include <limits.h> // ใช้ INT_MAX เป็นต้น
int main() {
int a = INT_MAX;
int b = 1;
if (a > INT_MAX - b) {
printf("ข้อผิดพลาด: เกิดโอเวอร์โฟลว์\n");
} else {
int result = a + b;
printf("ผลลัพธ์: %d\n", result);
}
return 0;
}ในโค้ดนี้ ตรวจสอบล่วงหน้าว่าเกิน INT_MAX (ค่าสูงสุดของชนิดข้อมูล int) หรือไม่ เพื่อป้องกันโอเวอร์โฟลว์ การตรวจจับโอเวอร์โฟลว์ล่วงหน้าช่วยป้องกันการทำงานที่ไม่คาดคิดการเพิ่มประสิทธิภาพการดำเนินการ
การเพิ่มประสิทธิภาพโดยใช้ตัวดำเนินการมีประโยชน์อย่างยิ่งในสภาพแวดล้อมที่ประสิทธิภาพมีความสำคัญ การใช้ตัวดำเนินการเลื่อนบิตช่วยให้การคูณและการหารเร็วขึ้น ตัวอย่างเช่น:int a = 5;
int result = a << 1; // ทำให้ a เป็นสองเท่าในโค้ดนี้ ใช้ตัวดำเนินการเลื่อนบิตเพื่อทำให้ a เป็นสองเท่า การเลื่อนบิตเป็นกระบวนการที่เบากว่าการคูณ โดยเฉพาะอย่างยิ่งในระบบสมองกลฝังตัวหรือการเขียนโปรแกรมระดับต่ำจะมีการใช้งานบ่อยครั้ง

