bitwise Operaทอร์ใน C: AND, OR, XOR, Shift & เสริม
เบนจามิน วอล์คเกอร์
⚡ สรุปอย่างชาญฉลาด
ตัวดำเนินการบิตในภาษา C จะจัดการข้อมูลในระดับบิตแต่ละบิต โดยใช้การดำเนินการ AND, OR, XOR, การผกผัน และการเลื่อนบิตกับตัวถูกดำเนินการจำนวนเต็ม เพื่อทำการคำนวณที่รวดเร็วยิ่งขึ้น จัดเก็บแฟล็ก และควบคุมฮาร์ดแวร์ในการเขียนโปรแกรมระดับต่ำและแบบฝังตัว
Bitwise คืออะไร Operaทอร์?
bitwise Operaทอร์เรนต์ใช้สำหรับจัดการข้อมูลในระดับบิต หรือเรียกว่าการเขียนโปรแกรมระดับบิต ทอร์เรนต์จะทำงานกับรูปแบบบิตหรือตัวเลขไบนารีตั้งแต่หนึ่งรูปแบบขึ้นไปในระดับบิตแต่ละบิต โดยใช้ในการคำนวณเชิงตัวเลขเพื่อให้กระบวนการคำนวณเร็วขึ้น
ต่อไปนี้คือรายการตัวดำเนินการบิตที่จัดทำโดยภาษาการเขียนโปรแกรม 'C':
| OperaTor | ความหมาย |
|---|---|
| & | ตัวดำเนินการ AND ตามบิต |
| | | ตัวดำเนินการแบบบิตต่อบิต OR |
| ^ | ตัวดำเนินการ OR เฉพาะตามบิต |
| ~ | ส่วนเสริมของ Binary One Operator เป็นตัวดำเนินการแบบยูนารี |
| << | ผู้ควบคุมกะเกียร์ซ้าย |
| >> | ผู้ควบคุมการเลื่อนเกียร์ขวา |
ตัวดำเนินการบิตไม่สามารถนำไปใช้กับชนิดข้อมูลพื้นฐาน เช่น float, double ได้โดยตรง โปรดจำไว้เสมอว่าตัวดำเนินการบิตส่วนใหญ่ใช้กับชนิดข้อมูลพื้นฐาน... ประเภทข้อมูลจำนวนเต็ม เนื่องจากความเข้ากันได้ของมัน
ตัวดำเนินการลอจิคัลแบบบิตจะทำงานกับข้อมูลทีละบิต โดยเริ่มจากบิตที่มีนัยสำคัญน้อยที่สุด นั่นคือ บิต LSB ที่เป็นบิตทางขวาสุด และทำงานต่อไปจนถึง MSB (บิตที่สำคัญที่สุด) ซึ่งเป็นบิตทางซ้ายสุด
ผลลัพธ์ของการคำนวณของตัวดำเนินการเชิงตรรกะระดับบิตจะแสดงอยู่ในตารางด้านล่าง
| x | y | เอ็กซ์แอนด์วาย | x | ย | x ^ ย |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
Bitwise และ
นี่คือตัวดำเนินการเชิงตรรกะแบบบิตที่ใช้กันทั่วไปที่สุดตัวหนึ่ง ซึ่งแสดงด้วยเครื่องหมายแอมเปอร์แซนด์ตัวเดียว (&) โดยนิพจน์จำนวนเต็มสองตัวจะเขียนไว้ที่แต่ละด้านของตัวดำเนินการ (&)
ผลลัพธ์ของการดำเนินการ AND แบบบิตจะเป็น 1 หากทั้งสองบิตมีค่าเป็น 1 ในกรณีอื่น ผลลัพธ์จะเป็น 0 เสมอ
ลองพิจารณาว่าเรามี 2 ตัวแปร op1 และ op2 โดยมีค่าดังนี้:
Op1 = 0000 1101 Op2 = 0001 1001
ผลลัพธ์ของการดำเนินการ AND กับตัวแปร op1 และ op2 จะเป็น
Result = 0000 1001
ดังที่เราเห็น มีการเปรียบเทียบตัวแปรสองตัวทีละนิด เมื่อใดก็ตามที่ค่าของบิตในตัวแปรทั้งสองเป็น 1 ผลลัพธ์จะเป็น 1 หรือไม่ก็ 0
Bitwise หรือ
แสดงด้วยเครื่องหมายแท่งแนวตั้งตัวเดียว (|) และนิพจน์จำนวนเต็มสองตัวเขียนไว้ที่แต่ละด้านของตัวดำเนินการ (|)
ผลลัพธ์ของการดำเนินการแบบบิต OR จะเป็น 1 ถ้านิพจน์อย่างน้อยหนึ่งรายการมีค่าเป็น 1 มิฉะนั้น ผลลัพธ์จะเป็น 0 เสมอ
ลองพิจารณาว่าเรามี 2 ตัวแปร op1 และ op2 โดยมีค่าดังนี้:
Op1 = 0000 1101 Op2 = 0001 1001
ผลลัพธ์ของการดำเนินการ OR บนตัวแปร op1 และ op2 จะเป็น
Result = 0001 1101
ดังที่เราเห็น มีการเปรียบเทียบตัวแปรสองตัวทีละนิด เมื่อใดก็ตามที่ค่าของบิตในตัวแปรตัวใดตัวหนึ่งเป็น 1 ผลลัพธ์จะเป็น 1 หรือไม่ก็ 0
Bitwise พิเศษหรือ
แทนด้วยสัญลักษณ์ (^) โดยเขียนนิพจน์จำนวนเต็มสองตัวไว้ที่แต่ละด้านของตัวดำเนินการ (^)
ผลลัพธ์ของการดำเนินการ Exclusive-OR แบบบิตต่อบิตจะเป็น 1 ถ้ามีเพียงนิพจน์เดียวเท่านั้นที่มีค่าเป็น 1 มิฉะนั้น ผลลัพธ์จะเป็น 0 เสมอ
ลองพิจารณาว่าเรามี 2 ตัวแปร op1 และ op2 โดยมีค่าดังนี้:
Op1 = 0000 1101 Op2 = 0001 1001
ผลลัพธ์ของการดำเนินการ XOR บนตัวแปร op1 และ op2 จะเป็น
Result = 0001 0100
ดังที่เราเห็น มีการเปรียบเทียบตัวแปรสองตัวทีละนิด เมื่อใดก็ตามที่มีตัวแปรเพียงตัวเดียวเก็บค่า 1 ผลลัพธ์จะเป็น 0 มิฉะนั้น 0 จะเป็นผลลัพธ์
ให้เราเขียนโปรแกรมง่ายๆ ที่แสดงตัวดำเนินการเชิงตรรกะแบบบิต
#include <stdio.h> int main() { int a = 20; /* 20 = 010100 */ int b = 21; /* 21 = 010101 */ int c = 0; c = a & b; /* 20 = 010100 */ printf("AND - Value of c is %d\n", c ); c = a | b; /* 21 = 010101 */ printf("OR - Value of c is %d\n", c ); c = a ^ b; /* 1 = 0001 */ printf("Exclusive-OR - Value of c is %d\n", c ); getch(); }
Output:
AND - Value of c is 20 OR - Value of c is 21 Exclusive-OR - Value of c is 1
ตัวดำเนินการเลื่อนระดับบิต
ตัวดำเนินการเลื่อนบิตใช้สำหรับย้าย/เลื่อนรูปแบบบิตไปทางด้านซ้ายหรือด้านขวา ซ้ายและขวาเป็นตัวดำเนินการเลื่อนสองแบบที่ภาษา 'C' มีให้ ซึ่งแสดงได้ดังนี้:
Operand << n (Left Shift) Operand >> n (Right Shift)
ที่นี่
- ตัวดำเนินการคือนิพจน์จำนวนเต็มที่เราต้องดำเนินการเลื่อน
- 'n' คือจำนวนตำแหน่งบิตทั้งหมดที่ต้องเลื่อนในนิพจน์จำนวนเต็ม
การเลื่อนไปทางซ้ายจะเลื่อนบิตจำนวน n บิตไปทางด้านซ้าย บิตที่อยู่ซ้ายสุดในนิพจน์จะถูกดึงออกมา และบิต n บิตที่มีค่า 0 จะถูกเติมไว้ทางด้านขวา
การเลื่อนไปทางขวาจะเลื่อนบิตจำนวน n บิตไปทางขวา บิตจำนวน n บิตที่อยู่ขวาสุดในนิพจน์จะถูกดึงออกมา และค่า 0 จะถูกเติมไว้ทางด้านซ้าย
ตัวอย่าง: x เป็นนิพจน์จำนวนเต็มที่มีข้อมูล 1111 หลังจากดำเนินการเลื่อน ผลลัพธ์จะเป็นดังนี้:
x << 2 (left shift) = 1111<<2 = 1100 x>>2 (right shift) = 1111>>2 = 0011
Shiftตัวดำเนินการ s สามารถนำมาผสมผสานกันได้ จากนั้นจึงนำไปใช้เพื่อยกตัวอย่างtract ข้อมูลจากนิพจน์จำนวนเต็ม มาเขียนโปรแกรมเพื่อสาธิตการใช้ตัวดำเนินการเลื่อนบิตกัน
#include <stdio.h> int main() { int a = 20; /* 20 = 010100 */ int c = 0; c = a << 2; /* 80 = 101000 */ printf("Left shift - Value of c is %d\n", c ); c = a >> 2; /*05 = 000101 */ printf("Right shift - Value of c is %d\n", c ); return 0; }
Output:
Left shift - Value of c is 80 Right shift - Value of c is 5
หลังจากดำเนินการเลื่อนไปทางซ้าย ค่าจะกลายเป็น 80 ซึ่งมีค่าเทียบเท่าในไบนารีคือ 101000
หลังจากดำเนินการเลื่อนค่าไปทางขวาแล้ว ค่าจะกลายเป็น 5 ซึ่งมีค่าเทียบเท่าในไบนารีคือ 000101
ตัวดำเนินการเสริมบิต
ตัวประกอบบิตยังเรียกอีกอย่างว่าตัวดำเนินการตัวประกอบหนึ่ง เนื่องจากตัวประกอบนี้รับค่าหรือตัวดำเนินการเพียงตัวเดียวเสมอ เป็นตัวดำเนินการยูนารี
เมื่อเราดำเนินการเสริมกับบิตใดๆ 1 ทั้งหมดจะกลายเป็น 0 และในทางกลับกัน
หากเรามีนิพจน์จำนวนเต็มที่ประกอบด้วย 0000 1111 หลังจากดำเนินการเติมเต็มบิต ค่าจะกลายเป็น 1111 0000
ตัวดำเนินการเติมเต็มบิตจะถูกแสดงด้วยสัญลักษณ์ทิลดา (~)
ให้เราเขียนโปรแกรมที่สาธิตการใช้งานตัวดำเนินการเสริมบิต
#include <stdio.h> int main() { int a = 10; /* 10 = 1010 */ int c = 0; c = ~(a); printf("Complement - Value of c is %d\n", c ); return 0; }
Output:
Complement - Value of c is -11
นี่คือโปรแกรมอีกโปรแกรมหนึ่ง พร้อมตัวอย่างการใช้งานตัวดำเนินการทั้งหมดที่ได้กล่าวถึงไปแล้ว:
#include <stdio.h> main() { unsigned int x = 48; /* 48 = 0011 0000 */ unsigned int y = 13; /* 13 = 0000 1101 */ int z = 0; z =x & y; /* 0 = 0000 0000 */ printf("Bitwise AND Operator - x & y = %d\n", z ); z = x | y; /* 61 = 0011 1101 */ printf("Bitwise OR Operator - x | y = %d\n", z ); z= x^y; /* 61 = 0011 1101 */ printf("Bitwise XOR Operator- x^y= %d\n", z); z = ~x; /*-49 = 11001111 */ printf("Bitwise One's Complement Operator - ~x = %d\n", z); z = x << 2; /* 192 = 1100 0000 */ printf("Bitwise Left Shift Operator x << 2= %d\n", z ); z= x >> 2; /* 12 = 0000 1100 */ printf ("Bitwise Right Shift Operator x >> 2= %d\n", z );}
หลังจากที่เราคอมไพล์และรันโปรแกรมแล้ว จะได้ผลลัพธ์ดังต่อไปนี้:
Bitwise AND Operator - x & y = 0 Bitwise OR Operator - x | y = 61 Bitwise XOR Operator- x^y= 61 Bitwise One's Complement Operator - ~x = -49 Bitwise Left Shift Operator x << 2= 192 Bitwise Right Shift Operator x >> 2= 12
