bitwise Operaทอร์ใน C: AND, OR, XOR, Shift & เสริม

ต่อไปนี้คือรายการตัวดำเนินการบิตที่จัดทำโดยภาษาการเขียนโปรแกรม '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 สามารถรวมกันได้ จากนั้นจึงนำไปใช้ในการดึงข้อมูลจากนิพจน์จำนวนเต็มได้ ให้เราเขียนโปรแกรมเพื่อสาธิตการใช้ตัวดำเนินการเลื่อนตามบิต

#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

สรุป

• ตัวดำเนินการระดับบิตคือตัวดำเนินการพิเศษที่กำหนดโดย 'C.'
• ใช้ในการเขียนโปรแกรมระดับบิต
• ตัวดำเนินการเหล่านี้ใช้เพื่อจัดการบิตของนิพจน์จำนวนเต็ม
• ตัวดำเนินการเชิงบิตมี 3 ประเภท ได้แก่ ประเภทตรรกะ ประเภทการเลื่อน และประเภทการเติมเต็ม
• ตัวดำเนินการเสริมบิตใช้เพื่อย้อนกลับบิตของนิพจน์