พฤติกรรม

องค์ประกอบพิเศษหรือพิเศษเฉพาะ NOR คี่และคู่คำนวณฟังก์ชันที่สอดคล้องกันของค่าอินพุตและส่งออกผลลัพธ์

ตามค่าเริ่มต้น อินพุตที่ไม่ได้เชื่อมต่อจะถูกละเว้น กล่าวคือ เว้นแต่ว่าอินพุตจะมีสิ่งใดเชื่อมต่ออยู่จริงๆ แม้กระทั่งสายไฟ ดังนั้นคุณสามารถเพิ่มองค์ประกอบ 5 อินพุตได้ แต่เชื่อมต่อเพียงสองอินพุตเท่านั้น และมันจะทำหน้าที่เป็นองค์ประกอบ 2 อินพุต ซึ่งช่วยให้คุณไม่ต้องกังวลกับการตั้งค่าจำนวนอินพุตทุกครั้งที่คุณสร้างองค์ประกอบ (หากไม่ได้เชื่อมต่ออินพุตทั้งหมด ค่าความผิดพลาดที่เอาต์พุตจะเท่ากับ เอ็กซ์.) อย่างไรก็ตาม ผู้ใช้บางรายต้องการให้ Logisim ยืนยันว่าอินพุตทั้งหมดเชื่อมต่อกัน เนื่องจากตรงกับองค์ประกอบจริง คุณสามารถเปิดใช้งานลักษณะการทำงานนี้ได้โดยเลือกโครงการ > ตัวเลือก... ไปที่แท็บการสร้างแบบจำลอง และเลือกข้อผิดพลาดสำหรับอินพุตที่ไม่ได้กำหนดสำหรับเอาต์พุตองค์ประกอบบนความไม่แน่นอน

ตารางความจริงสองอินพุตสำหรับองค์ประกอบมีดังนี้

x	ย	พิเศษหรือ	พิเศษหรือไม่	ความเท่าเทียมกันที่แปลก	ความเท่าเทียมกัน
0	0	0	1	0	1
0	1	1	0	1	0
1	0	1	0	1	0
1	1	0	1	0	1

อย่างที่คุณเห็น ประตู Odd และ XOR มีพฤติกรรมเหมือนกันในกรณีที่มีสองอินพุต ในทำนองเดียวกัน องค์ประกอบ Parity และ Exclusive NOR จะทำงานเหมือนกัน แต่หากมีอินพุตที่มีค่าที่แน่นอนมากกว่าสองรายการ องค์ประกอบ Exclusive OR จะส่งออกเป็น 1 เมื่ออินพุตหนึ่งเป็นอินพุตเดียวเท่านั้น ในขณะที่องค์ประกอบ Odd จะส่งออกเป็น 1 เมื่อมีอินพุตหนึ่งตัวในอินพุตจำนวนคี่ ประตู XOR จะสร้าง 1 ที่เอาต์พุตเมื่ออินพุตที่มีอันหนึ่งเข้มงวด ไม่หนึ่ง ในขณะที่องค์ประกอบ Parity จะให้ 1 เมื่อมีอินพุตจำนวนคู่กับหนึ่ง เกต XOR และ XNOR มีคุณลักษณะที่เรียกว่า Multi-Input Behavior ซึ่งอนุญาตให้กำหนดค่าให้ใช้พฤติกรรมของเกตคี่และคู่ได้

หากอินพุตใดมีค่าความผิดพลาด (เช่น หากค่าที่ขัดแย้งกันถูกส่งไปยังสายเดียวกัน) หรือค่าลอยตัว เอาต์พุตจะเป็นค่าความผิดพลาด

แต่ละองค์ประกอบในเวอร์ชันหลายบิตจะทำการแปลงหนึ่งบิตกับอินพุตตามระดับบิต

บันทึก:ผู้เชี่ยวชาญหลายคนแย้งว่าพฤติกรรมขององค์ประกอบหยิก XOR ควรสอดคล้องกับพฤติกรรมขององค์ประกอบคี่ แต่ไม่มีข้อตกลงในเรื่องนี้ พฤติกรรมเริ่มต้นของ Logisim สำหรับองค์ประกอบ XOR เป็นไปตามมาตรฐาน IEEE 91 ซึ่งสอดคล้องกับความเข้าใจตามสัญชาตญาณของคำนี้ด้วย พิเศษหรือ: พนักงานเสิร์ฟถามว่าคุณต้องการเครื่องเคียงที่มีมันบด แครอท ถั่วลันเตา หรือสลัดหัวกะหล่ำหรือไม่ จะยอมรับตัวเลือกเดียวเท่านั้น ไม่ใช่สามตัวเลือก ไม่ว่าผู้เชี่ยวชาญจะบอกคุณอย่างไรก็ตาม (อย่างไรก็ตามฉันต้องยอมรับว่าฉันไม่ได้ทดสอบคำสั่งนี้อย่างจริงจัง) คุณสามารถกำหนดค่าเกต XOR และ XNOR ให้ใช้ตัวแปรตัวใดตัวหนึ่งได้โดยการเปลี่ยนแอตทริบิวต์ Multi-Input Behavior

หน้าสัมผัส (สมมติว่าส่วนประกอบหันหน้าไปทางทิศตะวันออก)

ขอบทิศตะวันตก (อินพุต ความกว้างบิตสอดคล้องกับคุณลักษณะ Data Bits)

อินพุตส่วนประกอบ โดยจะมีได้มากเท่าที่ระบุไว้ในแอตทริบิวต์ Number of inputs

โปรดทราบว่าหากคุณใช้องค์ประกอบแบบหยิก ขอบด้านตะวันตกขององค์ประกอบ XOR และ XNOR จะโค้ง อย่างไรก็ตาม หมุดอินพุตนั้นแทบจะหาไม่พบ Logisim ดึงส่วนสั้นๆ เพื่อแสดงสิ่งนี้ หากคุณซ้อนทับส่วนใดส่วนหนึ่ง โปรแกรมจะถือว่าโดยไม่มีการเตือนว่าคุณไม่ได้ตั้งใจจะทับซ้อนส่วนนั้น เมื่อใช้ "มุมมองการพิมพ์" ส่วนเหล่านี้จะไม่ถูกวาดหากไม่ได้เชื่อมต่อกับสายไฟ

ขอบตะวันออก (เอาต์พุต ความกว้างบิตสอดคล้องกับแอตทริบิวต์ Data Bits)

เอาต์พุตขององค์ประกอบที่มีค่าคำนวณตามค่าปัจจุบันที่อินพุตตามที่อธิบายไว้ข้างต้น

คุณสมบัติ

เมื่อส่วนประกอบถูกเลือกหรือถูกเพิ่มแล้ว ปุ่ม 0 ถึง 9 จะเปลี่ยนคุณลักษณะ Number of Inputs, Alt-0 เป็น Alt-9 จะเปลี่ยนคุณลักษณะ Data Bits และปุ่มลูกศรจะเปลี่ยนคุณลักษณะ Direction

ทิศทาง ทิศทางของส่วนประกอบ (เอาต์พุตสัมพันธ์กับอินพุต)

Data Bits ความกว้างของอินพุตและเอาต์พุตของส่วนประกอบ	ขนาดองค์ประกอบ กำหนดว่าควรแสดงผลส่วนประกอบเวอร์ชันกว้างหรือแคบ ซึ่งจะไม่ส่งผลต่อจำนวนอินพุต ซึ่งกำหนดโดยแอ็ตทริบิวต์ Number of Inputs อย่างไรก็ตาม หากจำนวนอินพุตเกิน 3 (สำหรับส่วนประกอบแคบ) หรือ 5 (สำหรับอินพุตแบบกว้าง) องค์ประกอบจะแสดงผลด้วย "ปีก" เพื่อรองรับจำนวนอินพุตที่ร้องขอ	จำนวนอินพุต กำหนดจำนวนพินที่ขอบตะวันตกที่ส่วนประกอบจะมี
ลักษณะการทำงานของหลายอินพุต (XOR และ XNOR เท่านั้น) เมื่อมีอินพุตตั้งแต่สามอินพุตขึ้นไป เอาท์พุตของเกท XOR และ XNOR จะขึ้นอยู่กับข้อเท็จจริงที่ว่า 1 เป็นอินพุตเดียวอย่างเคร่งครัด (ค่าเริ่มต้น) หรือบนอินพุตจำนวนคี่ .	ผู้ดำเนินการ	ไวยากรณ์ คำอธิบาย
และ	เอ แอนด์ บี	การเชื่อมต่อ: ถ้า A และ B เป็นจริง แสดงว่าเป็นจริง มิฉะนั้น - เท็จ
หรือ	เอ หรือ บี	การแยกทาง: ถ้าตัวถูกดำเนินการใดๆ เป็นจริง แสดงว่าเป็นจริง มิฉะนั้น - เท็จ
ไม่	ไม่ใช่ก	การปฏิเสธ: ถ้า A เป็นเท็จ แสดงว่าเป็นจริง มิฉะนั้น - เท็จ
แฮคเกอร์	เอ เอ็กซ์ออร์ บี	ข้อยกเว้น: ถ้า A เป็นจริง หรือ B เป็นจริง ดังนั้น - จริง มิฉะนั้น - เท็จ
อีคิววี	เอ อีคิววี บี	ความเท่าเทียมกัน: ถ้า A มีค่าเท่ากับ B แสดงว่าเป็นจริง มิฉะนั้น - เท็จ

IMP

เอ อิมพีเรียล บี

ความหมาย:

ถ้า A เป็นจริง และ B เป็นเท็จ ก็แสดงว่าเป็นเท็จ มิฉะนั้น - จริง
ตัวถูกดำเนินการสำหรับตัวดำเนินการบูลีนอาจเป็นนิพจน์ที่ถูกต้องซึ่งมีผลลัพธ์แบบบูลีน เช่นเดียวกับตัวเลขที่สามารถแปลงเป็นค่าบูลีนได้

ผลลัพธ์ของการดำเนินการเชิงตรรกะคือค่าประเภทบูลีน (หรือ Null หากตัวถูกดำเนินการอย่างน้อยหนึ่งตัวเป็น Null) ตัวดำเนินการเชิงตรรกะ AND.

ไวยากรณ์:

ตัวถูกดำเนินการ_1 และ ตัวถูกดำเนินการ_2

ตัวดำเนินการ AND ดำเนินการ

การเชื่อมต่อเชิงตรรกะ

ผลลัพธ์ของการดำเนินการนี้จะเป็น True ก็ต่อเมื่อตัวถูกดำเนินการทั้งสองตัวเป็น True หรือเป็นเท็จ

ตารางความจริง

ถ้า A เป็นจริง และ B เป็นเท็จ ก็แสดงว่าเป็นเท็จ มิฉะนั้น - จริง
ตัวถูกดำเนินการ_1 หรือ ตัวถูกดำเนินการ_2

ตัวดำเนินการ OR ทำ การแยกทางตรรกะ.

ผลลัพธ์ของการดำเนินการนี้จะเป็น True หากตัวถูกดำเนินการอย่างน้อยหนึ่งตัวเป็น True หรือเป็นเท็จ

ตัวถูกดำเนินการ_1 และ ตัวถูกดำเนินการ_2

ตัวดำเนินการ OR สามารถใช้ได้กับตัวถูกดำเนินการหลายตัว:

(5 3) หรือ (5=6) ผลลัพธ์จะเป็น True

โดยไม่คำนึงถึงจำนวนตัวถูกดำเนินการ ผลลัพธ์ของการดำเนินการแบบลอจิคัล OR จะเป็น True เสมอ หากตัวถูกดำเนินการอย่างน้อยหนึ่งตัวของนิพจน์เป็น True มิฉะนั้นผลลัพธ์จะเป็นเท็จ

ตัวดำเนินการ AND และ OR สามารถรวมกันได้:

((5 3)) หรือ (5=6) ผลลัพธ์จะเป็น True

ตัวดำเนินการเชิงตรรกะไม่

ถ้า A เป็นจริง และ B เป็นเท็จ ก็แสดงว่าเป็นเท็จ มิฉะนั้น - จริง
ไม่ใช่ตัวถูกดำเนินการ

ตัวดำเนินการ NOT ทำ การปฏิเสธเชิงตรรกะ.

ตัวดำเนินการ NOT ใช้ตัวถูกดำเนินการเพียงตัวเดียวเท่านั้น

ตัวถูกดำเนินการ_1 และ ตัวถูกดำเนินการ_2

ตัวดำเนินการ AND OR NOT สามารถรวมกันได้:

((5 3)) หรือไม่ (5=6) ผลลัพธ์จะเป็น True

ตัวดำเนินการเชิงตรรกะ XOR

ถ้า A เป็นจริง และ B เป็นเท็จ ก็แสดงว่าเป็นเท็จ มิฉะนั้น - จริง
ตัวถูกดำเนินการ_1 XOR ตัวถูกดำเนินการ_2

ตัวดำเนินการ XOR ทำ ข้อยกเว้นเชิงตรรกะ.

ผลลัพธ์ของการดำเนินการนี้จะเป็น True หากตัวถูกดำเนินการมีค่าต่างกัน มิฉะนั้นจะเป็นเท็จ

ตัวถูกดำเนินการ_1 และ ตัวถูกดำเนินการ_2

((5 3)) หรือไม่ (5=6) XOR (5=5) ผลลัพธ์จะเป็นเท็จ

ตัวดำเนินการเชิงตรรกะ EQV

ถ้า A เป็นจริง และ B เป็นเท็จ ก็แสดงว่าเป็นเท็จ มิฉะนั้น - จริง
ตัวถูกดำเนินการ_1 EQV ตัวถูกดำเนินการ_2

ตัวดำเนินการ EQV คือตัวดำเนินการ ความเท่าเทียมกันทางตรรกะ.

ผลลัพธ์ของการดำเนินการนี้จะเป็น True หากตัวถูกดำเนินการมีค่าเหมือนกัน มิฉะนั้นจะเป็นเท็จ

ตัวถูกดำเนินการ_1 และ ตัวถูกดำเนินการ_2

((5 3)) หรือไม่ (5=6) EQV (5=5) ผลลัพธ์จะเป็น True

ตัวดำเนินการเชิงตรรกะ IMP

ถ้า A เป็นจริง และ B เป็นเท็จ ก็แสดงว่าเป็นเท็จ มิฉะนั้น - จริง
ตัวถูกดำเนินการ_1 IMP ตัวถูกดำเนินการ_2

ตัวดำเนินการ IMP ดำเนินการเชิงตรรกะ ความหมาย.

ตัวถูกดำเนินการ_1 และ ตัวถูกดำเนินการ_2

((5 3)) หรือไม่ (5=6) IMP (5=5) ผลลัพธ์จะเป็น True

ตัวดำเนินการเชิงตรรกะ IMP เป็นตัวดำเนินการเชิงตรรกะที่ใช้งานง่ายน้อยที่สุด โชคดีที่ความจำเป็นในการใช้มันเกิดขึ้นค่อนข้างน้อย

แท็ก: การดำเนินการบิต C, การดำเนินการบิต, การเพิ่มบิต, การคูณบิต, การเลื่อนบิตไปทางซ้าย, การเลื่อนบิตไปทางขวา

การแนะนำ

ภาษา C บางครั้งเรียกว่า Macroassembler เนื่องจากมีความเกี่ยวข้องกับฮาร์ดแวร์ หากคุณไม่ได้ใช้การปรับให้เหมาะสม คุณสามารถประเมินคร่าวๆ ว่าโค้ดโปรแกรมจะถูกแปลงเป็นโครงสร้างภาษาแอสเซมบลีใด ความเรียบง่ายและความเรียบง่ายของภาษา (ความเรียบง่ายของภาษาไม่ควรสับสนกับความเรียบง่ายของการเขียนโปรแกรมในภาษา) ได้นำไปสู่ความจริงที่ว่าในหลาย ๆ แพลตฟอร์ม C ยังคงเป็นภาษาโปรแกรมระดับสูงเพียงภาษาเดียว แน่นอนว่าหากไม่มีภาพรวมของการดำเนินการระดับบิต การเรียนรู้ภาษาจะไม่สมบูรณ์

การดำเนินการแบบ Bitwise ดังที่ชื่อบอกไว้ ช่วยให้คุณสามารถดำเนินการกับบิตได้โดยตรง ตัวอย่างการใช้การดำเนินการระดับบิตจำนวนมากสามารถพบได้ในหนังสือ “Algorithmic Tricks for Programmers” โดย Henry Warren ที่นี่เราจะพิจารณาเฉพาะการดำเนินการและอัลกอริธึมดั้งเดิมเท่านั้น

ระดับบิตและหรือไม่ใช่ XOR

ฉันขอเตือนคุณก่อนว่าการดำเนินการเชิงตรรกะ AND, OR, Exclusive OR และ NOT สามารถอธิบายได้โดยใช้ตารางความจริง

ตัวดำเนินการเชิงตรรกะไม่

เอ็กซ์	ไม่ใช่ X
0	1
1	0

ในการดำเนินการแบบบิตนั้น ค่าบิต 1 จะถือว่าเป็นตรรกะจริง และ 0 เป็นเท็จ Bitwise AND (ตัวดำเนินการ &) รับตัวเลขสองตัวและคูณบิตที่สอดคล้องกันตามตรรกะ ตัวอย่างเช่น ถ้าคุณคูณ 3 ด้วย 8 ตามตรรกะ คุณจะได้ 0

ถ่าน a = 3; ถ่านข = 8; ถ่าน c = a&b; printf("%d", c);

เนื่องจากในรูปแบบไบนารี่ 3 เป็นจำนวนเต็มไบต์เดียวแทน

บิตแรกของตัวแปร c เท่ากับผลคูณเชิงตรรกะของบิตแรกของตัวเลข a และบิตแรกของตัวเลข b และอื่นๆ สำหรับแต่ละบิต

00000011
00001000
↓↓↓↓↓↓↓↓
00000000

ดังนั้น ผลคูณระดับบิตของตัวเลข 31 และ 17 จะให้ 17 เนื่องจาก 31 คือ 00011111 และ 17 คือ 00010001

00011111
00010001
↓↓↓↓↓↓↓↓
00010001

ผลคูณระดับบิตของตัวเลข 35 และ 15 คือ 3

00100011
00001111
↓↓↓↓↓↓↓↓
00000011

การดำเนินการระดับบิตหรือ (ตัวดำเนินการ |) ทำงานในลักษณะเดียวกัน ยกเว้นว่าจะรวมบิตของตัวเลขที่สอดคล้องกันในเชิงตรรกะโดยไม่ต้องแบก

ตัวอย่างเช่น,

ถ่าน a = 15; ถ่าน ข = 11; ถ่าน c = ก | ข; printf("%d", c);

จะส่งออก 15 เนื่องจาก 15 คือ 00001111 และ 11 คือ 00001011

00001111
00001011
↓↓↓↓↓↓↓↓
00001111

Bitwise OR สำหรับตัวเลข 33 และ 11 จะส่งกลับ 43 เนื่องจาก 33 คือ 00100001 และ 11 คือ 00001011

00100001
00001011
↓↓↓↓↓↓↓↓
00101011

การปฏิเสธแบบบิต (ตัวดำเนินการ ~) ไม่ทำงานสำหรับบิตเดียว แต่สำหรับจำนวนทั้งหมด ตัวดำเนินการผกผันเปลี่ยน false เป็น true และ true เป็น false สำหรับแต่ละบิต ตัวอย่างเช่น,

ถ่าน a = 65; ถ่านข = ~ก; printf("%d", b);

มันจะส่งออก -66 เนื่องจาก 65 คือ 01000001 และการผกผันจะให้ 10111110

ซึ่งเท่ากับ -66 อย่างไรก็ตาม นี่คืออัลกอริทึมสำหรับการสร้างจำนวนลบ: หากต้องการค้นหารหัสเสริมของตัวเลข คุณต้องกลับด้านและเพิ่มรหัสหนึ่งเข้าไป

ถ่าน a = 107; ถ่าน b = ~a + 1; printf("a = %d, -a = %d", a, b);

Exclusive OR (^ โอเปอเรเตอร์) ใช้การดำเนินการ XOR ระดับบิต ตัวอย่างเช่นสำหรับตัวเลข

ถ่าน a = 12; ถ่านข = 85; ถ่าน ค = a^b; printf("%d", c);

89 จะถูกเอาต์พุตเนื่องจาก a คือ 00001100 และ b คือ 01010101 เป็นผลให้เราได้รับ 01011001

บางครั้งตัวดำเนินการเชิงตรรกะ && และ || สับสนกับตัวดำเนินการ & และ | ข้อผิดพลาดดังกล่าวอาจมีอยู่ในโค้ดเป็นเวลานาน เนื่องจากโค้ดดังกล่าวจะใช้งานได้ในบางกรณี ตัวอย่างเช่น สำหรับตัวเลข 1 และ 0 แต่เนื่องจากใน C ค่าใดๆ ที่ไม่ใช่ศูนย์จึงเป็นจริง ดังนั้นการคูณบิตไวด์ของตัวเลข 3 และ 4 จะส่งกลับค่า 0 แม้ว่าการคูณเชิงตรรกะควรคืนค่าเป็นจริงก็ตาม

อินท์เอ = 3; int ข = 4; printf("a & b = %d\n", a & b); //จะพิมพ์ 0 printf("a && b = %d\n", a && b);//จะพิมพ์ไม่ใช่ 0 (โดยเฉพาะ 1)

การดำเนินการกะบิต

มีการดำเนินการกะสองแบบ - การเลื่อนบิตไปทางซ้าย (ตัวดำเนินการ<<) и битовый сдвиг вправо (оператор >- การเลื่อนบิตไปทางขวาจะเลื่อนบิตของตัวเลขไปทางขวา โดยบวกศูนย์ทางด้านซ้าย การเลื่อนบิตไปทางซ้ายจะให้ผลตรงกันข้าม โดยจะเลื่อนบิตไปทางซ้ายและเพิ่มเลขศูนย์ไปทางขวา บิตที่เกินจำนวนจะถูกละทิ้ง

เช่น เลื่อนเลข 5 ไปทางซ้าย 2 ตำแหน่ง

00000101 << 2 == 00010100

เลื่อนหมายเลข 19 ไปทางขวา 3 ตำแหน่ง

00010011 >> 3 == 00000010

โดยไม่คำนึงถึงสถาปัตยกรรม (ปลายใหญ่ หรือปลายเล็ก หรือปลายกลาง) ตัวเลขในไบนารี่จะแสดงจากซ้ายไปขวา จากบิตที่มีนัยสำคัญที่สุดไปยังนัยสำคัญน้อยที่สุด การเปลี่ยนบิตต้องใช้ตัวถูกดำเนินการสองตัว ได้แก่ ตัวเลขที่จะเลื่อนและจำนวนบิตที่จะเลื่อน

Int = 12; printf("%d<< 1 == %d\n", a, a << 1); printf("%d << 2 == %d\n", a, a << 2); printf("%d >> 1 == %d\n", a, a >> 1); printf("%d >> 2 == %d\n", a, a >> 2);

เนื่องจากการเลื่อนไปทางขวา (>>) จะบวกศูนย์ทางด้านซ้าย สำหรับตัวเลขจำนวนเต็ม การดำเนินการจะเทียบเท่ากับการหารจำนวนเต็มครึ่งหนึ่ง และการเลื่อนไปทางซ้ายจะเท่ากับการคูณด้วย 2 เป็นไปไม่ได้ที่จะดำเนินการกะบิตสำหรับการลอยตัว หมายเลขจุดโดยไม่มีประเภทนักแสดงที่ชัดเจน นี่เป็นเพราะว่า C ไม่ได้กำหนดการแสดงจุดลอยตัวไว้ อย่างไรก็ตาม คุณสามารถย้าย float ไปที่ int จากนั้นย้ายและใส่กลับเข้าไปได้

ลอย b = 10.0f; float c = (float) (*((int*)&b) >> 2); printf("%.3f >> 2 = %.3f", b, c);

แต่แน่นอนว่าเราจะไม่ได้ 5.0f แต่เป็นตัวเลขที่แตกต่างไปจากเดิมอย่างสิ้นเชิง

สิ่งที่เกี่ยวกับตัวดำเนินการกะก็คือ พวกมันสามารถทำงานได้แตกต่างออกไปทั้งกับตัวเลขที่ลงนามและไม่ได้ลงนาม ขึ้นอยู่กับคอมไพลเลอร์ แท้จริงแล้ว จำนวนลบมักจะมีเครื่องหมายบิตหนึ่งตัว เมื่อเราเลื่อนไปทางซ้ายก็อาจจะหายไปและตัวเลขจะกลายเป็นบวก อย่างไรก็ตาม คอมไพลเลอร์สามารถทำให้การเปลี่ยนแปลงคงอยู่ในเครื่องหมายและปฏิบัติตามกฎที่แตกต่างกันได้ เช่นเดียวกับการเลื่อนไปทางขวา

int ua ที่ไม่ได้ลงนาม = 12; ลงนาม int sa = -11; printf("ua = %d, ua >> 2 = %d\n", ua, ua >> 2); printf("sa = %d, sa >> 2 = %d\n", sa, sa >> 2); printf("(ไม่ได้ลงนาม) sa = %u, sa >> 2 = %u\n", sa, sa >> 2); printf("sa = %d, ((ไม่ได้ลงนาม) sa) >> 2 = %d", sa, ((ไม่ได้ลงนาม) sa) >> 2);

ในกรณีนี้ ในระหว่างกะแรก ทุกอย่างทำงานได้ตามที่ตั้งใจไว้ เนื่องจากหมายเลขไม่ได้ลงนาม ในกรณีที่สอง คอมไพเลอร์ VSE2013 จะทิ้งเครื่องหมายไว้ อย่างไรก็ตาม หากคุณมองว่าการแสดงตัวเลขนี้ไม่ได้ลงนาม การเปลี่ยนแปลงจะเกิดขึ้นตามกฎที่ต่างกัน โดยจะคงบิตซ้ายสุดไว้ ในบรรทัดสุดท้าย ถ้าเราแปลงตัวเลขที่มีเครื่องหมายไปเป็นตัวเลขที่ไม่ได้ลงนาม การเปลี่ยนแปลงตามปกติจะเกิดขึ้น และเราจะได้รับจำนวนบวกตามผลลัพธ์

ตัวดำเนินการ Bitwise และ Shift จะไม่เปลี่ยนค่าของตัวเลข โดยส่งคืนค่าใหม่ เช่นเดียวกับตัวดำเนินการทางคณิตศาสตร์ที่สามารถเป็นส่วนหนึ่งของงานที่ซับซ้อนได้

Int = 10; int ข = 1; ก >>= 3; ก ^= (ข<< 3); и т.д.

ตัวอย่าง

1. มาเขียนฟังก์ชันที่ให้คุณกำหนดและเปลี่ยนตัวเลขจำนวนหนึ่งกันดีกว่า

เพื่อหาว่าบิตใด (1 หรือ 0) อยู่ที่ตำแหน่ง n เราใช้การคูณเชิงตรรกะ

ให้มีเลข 9 ครับ.

00001001

เราจำเป็นต้องค้นหาว่าบิตถูกตั้งค่าไว้ที่ตำแหน่ง 3 (เริ่มจากศูนย์) หรือไม่ เมื่อต้องการทำเช่นนี้ ให้คูณด้วยตัวเลขที่มีบิตทั้งหมดเป็นศูนย์ ยกเว้นบิตที่สาม:

00001001 & 00001000 = 00001000

ตอนนี้เราหาค่าของบิตที่ตำแหน่ง 6 แล้ว

00001001 & 01000000 = 00000000

ดังนั้น หากเราได้รับคำตอบเท่ากับศูนย์ ตำแหน่งที่ต้องการจะเป็นศูนย์ ไม่อย่างนั้นก็จะเป็นตำแหน่งเดียว หากต้องการรับตัวเลขที่ประกอบด้วยศูนย์โดยมีหนึ่งบิตอยู่ในตำแหน่งที่ต้องการ ให้เลื่อน 1 ตามจำนวนบิตที่ต้องการไปทางซ้าย

#รวม #รวม #รวม int checkbit (ค่า const int, ตำแหน่ง const int) ( ผลลัพธ์ int; ถ้า ((ค่า & (1<< position)) == 0) { result = 0; } else { result = 1; } return result; } void main() { int a = 3; size_t len = sizeof(int) * CHAR_BIT; size_t i; for (i = 0; i < len; i++) { printf("%d", checkbit(a, i)); } _getch(); }

โปรดสังเกตว่าในฟังก์ชันเงื่อนไขจะเขียนเช่นนี้

(ค่า & (1<< position)) == 0

เนื่องจากหากไม่มีวงเล็บ ระบบจะคำนวณความเท่ากับศูนย์ก่อน จากนั้นจึงทำการคูณเท่านั้น

ความคุ้มค่า&(1<< position) == 0

ฟังก์ชั่นสามารถทำให้ง่ายขึ้น

Int checkbit (ค่า const int, ตำแหน่ง const int) ( return ((value & (1<< position)) != 0); }

ฟังก์ชันที่ตั้งค่าบิตที่ตำแหน่งที่ n เป็นหนึ่ง

เป็นที่ทราบกันดีว่าการบวกบิตใดๆ ด้วย 1 แบบลอจิคัลจะเท่ากับ 1 ดังนั้นในการตั้งค่าบิตที่ n คุณต้องบวกตัวเลขเชิงตรรกะด้วยจำนวนหนึ่ง โดยที่บิตทั้งหมดยกเว้นบิตที่ต้องการจะเท่ากับศูนย์ ได้มีการพูดคุยกันถึงวิธีการรับหมายเลขดังกล่าวแล้ว

Int setbit (ค่า const int, ตำแหน่ง const int) ( return (ค่า | (1<< position)); }

ฟังก์ชันที่ตั้งค่าบิตในตำแหน่งที่ n ให้เป็นศูนย์

ในการทำเช่นนี้ จำเป็นที่บิตทั้งหมดของตัวเลข ยกเว้นบิตที่ n ยังคงไม่เปลี่ยนแปลง ลองคูณตัวเลขด้วย 1 ซึ่งบิตทั้งหมดจะเท่ากับ 1 ยกเว้นบิตที่มีหมายเลข n ตัวอย่างเช่น

0001011 & 1110111 = 0000011

เพื่อให้ได้มาส์กนี้ อันดับแรกเราต้องสร้างตัวเลขที่มีศูนย์และหนึ่งหนึ่ง จากนั้นจึงกลับด้าน

Int unsetbit (ค่า const int, ตำแหน่ง const int) ( return (ค่า & ~(1<< position)); }

ฟังก์ชันที่กลับค่าของบิตที่ n

ในการทำเช่นนี้เราจะใช้ฟังก์ชันพิเศษหรือ: ใช้การดำเนินการ XOR กับตัวเลขที่ประกอบด้วยศูนย์เท่านั้นและอีกหนึ่งอันแทนที่บิตที่ต้องการ

Int switchbit(ค่า const int, ตำแหน่ง const int) ( return (ค่า ^ (1<< position)); }

การตรวจสอบ

#รวม #รวม #รวม int checkbit (ค่า const int, ตำแหน่ง const int) ( return ((value & (1<< position)) != 0); } int setbit(const int value, const int position) { return (value | (1 << position)); } int unsetbit(const int value, const int position) { return (value & ~(1 << position)); } int switchbit(const int value, const int position) { return (value ^ (1 << position)); } void printbits(int n) { //CHAR_BIT опеределён в библиотеке limits.h //и хранит число бит в байте для данной платформы size_t len = sizeof(int)* CHAR_BIT; size_t i; for (i = 0; i < len; i++) { printf("%d", checkbit(n, i)); } printf("\n"); } void main() { int a = 3; size_t len = sizeof(int) * CHAR_BIT; size_t i; printbits(a); a = setbit(a, 5); printbits(a); a = unsetbit(a, 5); printbits(a); a = switchbit(a, 11); printbits(a); a = switchbit(a, 11); printbits(a); _getch(); }

ธงบิต

ลองดูตัวอย่างสังเคราะห์ ขอให้เรามีตัวแปรบูลีนสามตัว และเราต้องส่งออกค่าที่แน่นอนโดยขึ้นอยู่กับตัวแปรทั้งหมดนี้ในคราวเดียว แน่นอนว่าอาจมี 2 หรือ 3 ตัวเลือกที่เป็นไปได้ ลองเขียนเงื่อนไขนี้ในรูปแบบของสาขา:

#รวม int main() ( ถ่านที่ไม่ได้ลงนาม a, b, c; a = 1; b = 0; c = 0; if (a) ( if (b) ( if (c) ( printf("true true true"); ) อื่น ๆ ( printf("true true false"); ) ) else ( if (c) ( printf("true false true"); ) else ( printf("true false false"); ) ) ) else ( ถ้า (b) ( ถ้า (c) ( printf("false true true"); ) else ( printf("false true false"); ) ) else ( if (c) ( printf("false false true"); ) else ( printf( "เท็จเท็จเท็จ");

เรามี 8 สาขา สมมติว่าตอนนี้เราต้องเพิ่มเงื่อนไขอีกหนึ่งข้อ จากนั้นจำนวนสาขาจะเพิ่มขึ้นเป็นสองเท่า และโปรแกรมจะเข้าใจและแก้ไขจุดบกพร่องได้ยากยิ่งขึ้น ลองเขียนตัวอย่างใหม่อีกครั้ง

หากค่าลอจิคัลแต่ละค่าของเราเลื่อนไปตามจำนวนบิตไปทางซ้ายและเพิ่มอย่างลอจิคัล เราจะได้ชุดค่าผสมของบิตที่ไม่ซ้ำกันขึ้นอยู่กับค่าของ a, b และ c:

#รวม #รวม โมฆะ printbits (int n) ( int i; for (i = CHAR_BIT - 1; i >= 0; i--) ( printf("%d", (n & (1<< i)) != 0); } printf("\n"); } int main() { unsigned char a, b, c; unsigned char res; a = 1; b = 0; c = 0; res = c | b << 1 | a << 2; printbits(res); a = 0; b = 1; c = 1; res = c | b << 1 | a << 2; printbits(res); a = 1; b = 0; c = 1; res = c | b << 1 | a << 2; printbits(res); _getch(); return 0; }

ลองใช้วิธีนี้กับปัญหาของเราและแทนที่การแตกสาขาด้วยสวิตช์:

#รวม int main() ( ถ่านที่ไม่ได้ลงนาม a, b, c; ถ่านที่ไม่ได้ลงนาม; a = 1; b = 0; c = 0; res = c | b<< 1 | a << 2; switch (res) { case 0b00000000: printf("false false false"); break; case 0b00000001: printf("false false true"); break; case 0b00000010: printf("false true false"); break; case 0b00000011: printf("false true true"); break; case 0b00000100: printf("true false false"); break; case 0b00000101: printf("true false true"); break; case 0b00000110: printf("true true false"); break; case 0b00000111: printf("true true true"); break; } _getch(); return 0; }

วิธีนี้มักใช้ในการกำหนดตัวเลือกฟังก์ชันในภาษาการเขียนโปรแกรมต่างๆ แต่ละแฟล็กใช้ชื่อเฉพาะของตัวเอง และค่าที่รวมกันคือผลรวมเชิงตรรกะของแฟล็กที่ใช้ทั้งหมด ตัวอย่างเช่น ไลบรารี fcntl

ฟังก์ชั่นที่พวกเขาทำนั้นค่อนข้างซับซ้อนกว่าในกรณีขององค์ประกอบ AND หรือองค์ประกอบ OR อินพุตทั้งหมดของเกท XOR มีค่าเท่ากัน แต่ไม่มีอินพุตใดที่สามารถบล็อกอินพุตอื่นๆ ได้โดยการตั้งค่าเอาต์พุตให้เป็นหนึ่งหรือศูนย์ ตารางที่ 4.1. ตารางความจริงองค์ประกอบพิเศษหรือองค์ประกอบสองอินพุต

อินพุต 1	อินพุต 2	ออก
0	0	0
0	1	1
1	0	1
1	1	0

ข้าว. 4.1.

ฟังก์ชัน Exclusive OR หมายถึงสิ่งต่อไปนี้: จะปรากฏที่เอาต์พุตเมื่อมีอินพุตเดียวเท่านั้น หากมีอินพุตตั้งแต่สองตัวขึ้นไป หรือหากอินพุตทั้งหมดเป็นศูนย์ เอาต์พุตจะเป็นศูนย์ ตารางความจริงองค์ประกอบสองอินพุต Exclusive OR ได้รับในตาราง 4.1. การกำหนดที่ใช้ในโครงการในประเทศและต่างประเทศแสดงไว้ในรูปที่ 1 4.1.

คำจารึกเกี่ยวกับการกำหนดองค์ประกอบภายในประเทศขององค์ประกอบพิเศษหรือ "=1" หมายความว่าสถานการณ์จะถูกเน้นเมื่อมีอินพุตเพียงหน่วยเดียวเท่านั้น

มีองค์ประกอบ XOR เล็กน้อยในซีรีย์มาตรฐาน ซีรีย์ในประเทศนำเสนอไมโครวงจร LP5 (องค์ประกอบสองอินพุตสี่องค์ประกอบพร้อมเอาต์พุต 2C), LL3 และ LP12 ซึ่งแตกต่างจาก LP5 ในเอาต์พุต OK องค์ประกอบเหล่านี้มีการใช้ฟังก์ชันที่เฉพาะเจาะจงเกินไป

จากมุมมองทางคณิตศาสตร์ เกต XOR ดำเนินการสิ่งที่เรียกว่าการดำเนินการบวกแบบโมดูโล-2 ดังนั้นเกตเหล่านี้จึงถูกเรียกว่าตัวเสริมแบบโมดูโล-ทู ดังที่กล่าวไว้ในการบรรยายครั้งก่อน การรวมโมดูโล 2 จะถูกระบุด้วยเครื่องหมายบวกที่อยู่ในวงกลม แอปพลิเคชันหลักขององค์ประกอบคือ Exclusive OR ซึ่งตามมาจากโดยตรงตารางความจริง ประกอบด้วยการเปรียบเทียบสัญญาณอินพุตสองตัว ในกรณีที่มีศูนย์สองตัวมาถึงอินพุต (สัญญาณตรงกัน) จะเกิดศูนย์ที่เอาต์พุต (ดูตาราง 4.1) โดยทั่วไป ในแอปพลิเคชันนี้ ระดับคงที่จะถูกนำไปใช้กับอินพุตหนึ่งขององค์ประกอบ โดยมีการเปรียบเทียบสัญญาณที่แปรผันตามเวลาที่มาถึงที่อินพุตอื่น แต่บ่อยครั้งที่ไมโครวงจรพิเศษใช้เพื่อเปรียบเทียบสัญญาณและรหัสเครื่องมือเปรียบเทียบรหัส

ซึ่งจะกล่าวถึงในการบรรยายครั้งต่อไป

ในฐานะที่เป็นตัวบวกแบบโมดูโล 2 องค์ประกอบ XOR ยังใช้ในตัวแบ่งแบบโมดูโล 2 แบบขนานและแบบอนุกรมที่ใช้ในการคำนวณผลรวมตรวจสอบแบบวน แต่แผนการเหล่านี้จะกล่าวถึงโดยละเอียดในการบรรยายที่ 14,15 การใช้งานที่สำคัญขององค์ประกอบ XOR คืออินเวอร์เตอร์ที่มีการควบคุม (รูปที่ 4.2)ในกรณีนี้ อินพุตหนึ่งขององค์ประกอบจะถูกใช้เป็นตัวควบคุม และจะได้รับสัญญาณข้อมูลที่อินพุตอื่นขององค์ประกอบ หากอินพุตควบคุมเป็นหนึ่ง สัญญาณอินพุตจะกลับด้าน แต่ถ้าเป็นศูนย์ สัญญาณจะไม่กลับด้าน บ่อยขึ้น สัญญาณควบคุม.

ข้าว. 4.2.

ในกรณีที่มีสองสัญญาณที่มีขั้วเดียวกัน (บวกหรือลบ) และไม่รวมการมาถึงพร้อมกัน สามารถใช้องค์ประกอบพิเศษหรือเพื่อผสมสัญญาณเหล่านี้ (รูปที่ 4.3) สำหรับขั้วของสัญญาณอินพุตใดๆ สัญญาณเอาท์พุตขององค์ประกอบจะเป็นค่าบวก สำหรับสัญญาณอินพุตเชิงบวก เกต XOR จะทำหน้าที่เป็นเกต 2OR และสำหรับอินพุตเชิงลบ มันจะแทนที่เกต 2AND-NOT การเปลี่ยนดังกล่าวอาจมีประโยชน์ในกรณีที่องค์ประกอบเอกสิทธิ์หรือองค์ประกอบบางส่วนยังไม่ได้ใช้ในวงจร จริงอยู่ก็ต้องคำนึงถึงสิ่งนั้นด้วย ความล่าช้าในการขยายพันธุ์สัญญาณในองค์ประกอบ XOR มักจะใหญ่กว่าเล็กน้อย (ประมาณ 1.5 เท่า) กว่าการหน่วงเวลาในองค์ประกอบ AND, NAND, OR, NOR ที่ง่ายที่สุดเล็กน้อย

คำสั่ง XOR ในภาษาแอสเซมบลีดำเนินการพิเศษหรือการดำเนินการระหว่างบิตทั้งหมดของตัวถูกดำเนินการสองตัว ผลลัพธ์ของการดำเนินการ XOR จะถูกเขียนไปยังตัวถูกดำเนินการแรก ไวยากรณ์:

ผู้รับ XOR แหล่งที่มา

คำสั่ง XOR จะรีเซ็ต CF และ OF เสมอ และ (ขึ้นอยู่กับผลลัพธ์) จะเปลี่ยนแฟล็ก SF, ZF และ PF ค่าของธง AF อาจเป็นอะไรก็ได้ - ไม่ได้ขึ้นอยู่กับผลลัพธ์ของการดำเนินการ

ผู้รับอาจเป็นหนึ่งในสิ่งต่อไปนี้:

• พื้นที่หน่วยความจำ (MEM)

แหล่งที่มาอาจเป็นอย่างใดอย่างหนึ่งต่อไปนี้:

• พื้นที่หน่วยความจำ (MEM)
• ทะเบียนวัตถุประสงค์ทั่วไป (REG)
• ค่าทันที - ค่าคงที่ (IMM)

ภายใต้ข้อจำกัดที่อธิบายไว้ข้างต้น ชุดค่าผสมของผู้รับ-แหล่งที่มาอาจเป็นดังนี้:

REG, MEM MEM, REG REG, REG MEM, IMM REG, IMM

การดำเนินการพิเศษหรือ

เมื่อดำเนินการพิเศษหรือการดำเนินการ ค่าผลลัพธ์จะเป็น 1 หากบิตที่เปรียบเทียบแตกต่างกัน (ไม่เท่ากัน) หากบิตที่เปรียบเทียบมีค่าเท่ากัน ผลลัพธ์จะเป็น 0

นั่นคือสาเหตุที่การดำเนินการนี้เรียกว่าพิเศษ โดยไม่รวมบิตที่เหมือนกันจากการเปรียบเทียบ และดำเนินการกับบิตที่ไม่เท่ากัน

แต่เนื่องจากคู่ของบิตที่ไม่เท่ากันคือ 0 และ 1 การดำเนินการแบบลอจิคัล OR จะให้ผลลัพธ์เป็น 1

ตารางพิเศษหรือความจริง

ตารางความจริง XOR แสดงไว้ด้านล่าง:

0 เอ็กซ์โอ 0 = 0 0 เอ็กซ์โออาร์ 1 = 1 1 เอ็กซ์ออร์ 0 = 1 1 แฮคเกอร์ 1 = 0

คุณสมบัติของการดำเนินการ XOR

การดำเนินการ XOR มีคุณสมบัติในการย้อนกลับได้ หากดำเนินการสองครั้งโดยใช้ตัวถูกดำเนินการเดียวกัน ค่าผลลัพธ์จะกลับด้าน นั่นคือ ถ้าคุณดำเนินการนี้สองครั้งระหว่างบิต เอ็กซ์และ ยจากนั้นผลลัพธ์สุดท้ายเราจะได้ค่าบิตดั้งเดิม เอ็กซ์.

0 แฮคเกอร์ 0 = 0 เอ็กซ์โออาร์ 0 = 0 0 แฮคเกอร์ 1 = 1 เอ็กซ์ออร์ 1 = 0 1 แฮคเกอร์ 0 = 1 เอ็กซ์ออร์ 0 = 1 1 แฮคเกอร์ 1 = 0 เอ็กซ์โออาร์ 1 = 1

คุณสมบัตินี้สามารถนำไปใช้ได้ เช่น สำหรับการเข้ารหัสข้อมูลอย่างง่าย (เพิ่มเติมในเวลาอื่น)

การตรวจสอบแฟล็กพาริตีหลังการดำเนินการ XOR

คำสั่ง XOR ทำงานร่วมกับการดำเนินการ 8-, 16- และ 32 บิต

บางครั้ง หลังจากดำเนินการแล้ว จำเป็นต้องตรวจสอบแฟล็กพาริตี PF เพื่อดูว่ามีบิตของหน่วยจำนวนเท่าใด (คู่หรือคี่) ไบต์ต่ำผลลัพธ์ (นี่จำเป็นไม่เพียงแต่เมื่อดำเนินการ XOR เท่านั้น แต่ยังรวมถึงการดำเนินการทางคณิตศาสตร์และตรรกะอื่น ๆ ด้วย)

หากมีการตั้งค่าสถานะพาริตี ผลลัพธ์จะเป็นเลขคู่ของหนึ่งบิต มิฉะนั้นธงจะถูกรีเซ็ต

คุณยังสามารถตรวจสอบความเท่าเทียมกันของตัวเลขใดก็ได้โดยไม่ต้องเปลี่ยนค่าของผลลัพธ์ ในการดำเนินการนี้ คุณต้องดำเนินการคำสั่ง XOR ด้วยค่าศูนย์ นั่นคือ RECEIVER ต้องมีหมายเลขที่กำลังทดสอบ และ SOURCE ต้องมีศูนย์ จากนั้นคุณต้องตรวจสอบแฟล็กพาริตี ตัวอย่าง:

AL, 10110101b ;วางตัวเลขลงใน AL โดยมีเลขคี่;จำนวนหนึ่งบิต (5) XOR AL, 0 ;ในกรณีนี้ ไม่ใช่ค่าสถานะพาริตี้ PF;ตั้งค่า (PO) MOV AL, 10110111b ;วางตัวเลขใน AL ด้วยจำนวนคู่; จำนวนหนึ่งบิต (6) XOR AL, 0 ; ในกรณีนี้แฟล็กพาริตี PF ; จะถูกตั้งค่า (PE)

ในโปรแกรมดีบักเกอร์ ตัวย่อ PE (Parity Even) มักจะใช้เพื่อแสดงถึงจำนวนคู่ในผลลัพธ์ผลลัพธ์ และ PO (Parity Odd) สำหรับเลขคี่

ความเท่าเทียมกันในคำ 16 บิต

ดังที่ได้กล่าวไปแล้ว แฟล็กพาริตี้จะถูกตั้งค่าโดยขึ้นอยู่กับจำนวนแฟล็กที่อยู่ในไบต์ต่ำของผลลัพธ์ ในการตรวจสอบความเท่าเทียมกันของตัวถูกดำเนินการ 16 บิต คุณต้อง XOR ไบต์สูงและต่ำของตัวเลข:

MOV AX, 64C1h ;0110 0100 1100 0001 - 6 หนึ่งบิต XOR AH, AL ;ตั้งค่าสถานะ Parity

ด้วยวิธีง่ายๆ นี้ ตัวถูกดำเนินการ 16 บิตจะถูกแบ่งออกเป็นสองไบต์ (2 กลุ่ม กลุ่มละ 8 บิต) และเมื่อดำเนินการคำสั่ง XOR บิตหนึ่งที่อยู่ในบิตที่สอดคล้องกันของตัวถูกดำเนินการ 8 บิตสองตัวจะไม่ถูกนำมาพิจารณา บัญชี. เพราะบิตที่สอดคล้องกันของผลลัพธ์คือศูนย์

คำสั่ง XOR จะลบหนึ่งบิตของตัวถูกดำเนินการ 8 บิตสองตัวที่ทับซ้อนกันออกจากผลลัพธ์ และเพิ่มบิตที่แยกจากกันหนึ่งบิตให้กับผลลัพธ์ นั่นคือความเท่าเทียมกันของตัวเลข 8 บิตที่เราได้รับจะเหมือนกับความเท่าเทียมกันของตัวเลข 16 บิตดั้งเดิม

0110 0100 1100 0001 - หมายเลข 16 บิตดั้งเดิม 0 แฮคเกอร์ 1 = 1 1 แฮคเกอร์ 1 = 0 1 แฮคเกอร์ 0 = 1 0 แฮคเกอร์ 0 = 0 0 แฮคเกอร์ 0 = 0 1 แฮคเกอร์ 0 = 1 0 แฮคเกอร์ 0 = 0 0 แฮคเกอร์ 1 = 1

ผลลัพธ์คือ 4 หน่วย นั่นคือธง PF จะถูกตั้งค่า

ความเท่าเทียมกันในคำคู่แบบ 32 บิต

แล้วถ้าคุณต้องการกำหนดความเท่าเทียมกันของตัวเลข 32 บิตล่ะ?

จากนั้นตัวเลขจะถูกแบ่งออกเป็นสี่ไบต์ และการดำเนินการพิเศษหรือจะดำเนินการกับไบต์เหล่านี้ทีละไบต์

ตัวอย่างเช่น เราแยกตัวเลข 32 บิต บีสี่ไบต์ B0, B1, บี2, B3, ที่ไหน B0- นี่คือไบต์ต่ำ

จากนั้นเพื่อกำหนดความเท่าเทียมกันของจำนวน B เราจำเป็นต้องใช้สูตรต่อไปนี้:

B0 เอ็กซ์ออร์ B1 เอ็กซ์ออร์ B2 เอ็กซ์ออร์ B3

แต่ในแอสเซมเบลอร์ไม่อนุญาตให้ใช้สัญลักษณ์ดังกล่าว ดังนั้นคุณจะต้องคิดสักหน่อย

และสุดท้ายเกี่ยวกับที่มาของการช่วยจำ ไม่- ในภาษาอังกฤษมีคำว่า e เอ็กซ์แผนกต้อนรับ - ข้อยกเว้น คำย่อของคำนี้คือตัวอักษร เอ็กซ์(นั่นคือสิ่งที่เกิดขึ้น) คุณอาจเคยเห็นสิ่งนี้ในโฆษณาหรือในชื่อผลิตภัณฑ์ที่ผู้ผลิตอ้างว่า (หรือคิดว่าพวกเขาอ้างว่า) มีความพิเศษเฉพาะตัว ตัวอย่างเช่น Lada XRAY, Sony XPeria เป็นต้น ดังนั้น XOR จึงเป็นคำย่อที่ประกอบด้วยคำสองคำ - e เอ็กซ์แผนกต้อนรับ และ- พิเศษหรือ