สวัสดีและยินดีต้อนรับ. มาพูดถึงตัวดำเนินการระดับบิตกัน
เราได้แสดงให้คุณเห็นคร่าวๆ ในการบรรยายครั้งก่อนเมื่อเราพูดถึงผู้ปฏิบัติงานที่ได้รับมอบหมาย
เนื่องจากผู้ปฏิบัติงานมอบหมายมีงานมอบหมายทั้งหมดเหล่านี้
ซึ่งคุณสามารถดำเนินการได้ เช่น การเพิ่มและมอบหมาย
คุณสามารถทำสิ่งเดียวกันกับโอเปอเรเตอร์ประเภทนี้ได้
แต่ให้ไปลงรายละเอียดเพิ่มเติมเหล่านี้และบอกคุณอย่างชัดเจนว่ามันคืออะไร
ดังนั้น c ขอเสนอตัวดำเนินการเชิงตรรกะระดับบิตและตัวดำเนินการกะ
เงื่อนไขเหล่านั้นอาจไม่มีเงื่อนงำอย่างสมบูรณ์
พวกมันดูเหมือนโอเปอเรเตอร์เชิงตรรกะ แต่ต่างกันมากทีเดียว พวกเขาไม่ทำการประเมินบูลีนใดๆ
พวกเขาไม่ได้ประเมินจริงหรือเท็จ
พวกมันดูเหมือนเครื่องหมายและเครื่องหมาย 2 หรือ
แต่พวกมันไม่ได้ทำการประเมินบูลีนใดๆ
สิ่งที่พวกเขาทำคือทำงานบนบิต ภายในค่าจำนวนเต็ม
ดังนั้นคุณอาจถามตัวเองว่าทำไมคุณถึงต้องการทำสิ่งนี้? มันไม่ได้ใช้ในโปรแกรมส่วนใหญ่
เป็นเทคนิคขั้นสูงมากกว่า
แม้ว่าจะเป็นคลาสเริ่มต้นก็ตาม พวกเขาเป็นส่วนหนึ่งของโอเปอเรเตอร์ และโอเปอเรเตอร์เป็นแนวคิดสำหรับผู้เริ่มต้น
ฉันจะพูดถึงพวกเขา แต่เราไม่จำเป็นต้องเน้นไปที่พวกเขา
ฉันจะยกตัวอย่างให้คุณเห็นว่าคุณจะใช้มันอย่างไร
แต่คุณจะไม่เป็นผู้เชี่ยวชาญในเรื่องนี้หลังจากการบรรยายนี้
แต่วิธีที่มีประโยชน์และเหตุใดคุณจึงต้องการใช้จริง ๆ ก็คือเพราะคุณสามารถเก็บข้อมูลได้ค่อนข้างมาก
จึงมีตัวถูกดำเนินการระดับบิตเรียกว่า และ แอมเพอร์แซนด์ และระดับบิต
หรือซึ่งเป็นแท่งขนานหรือแท่งเดียว
พยายามอย่าสับสนกับตัวดำเนินการเชิงตรรกะอีก
ตัวดำเนินการลอจิกมี 2 ตัว คือ แอมเพอร์แซนด์ แอมเพอร์แซนด์ ซึ่งก็คือ a และ
ตัวดำเนินการระดับบิตมีตัวดำเนินการเพียงตัวเดียว ก็แค่เครื่องหมายแอมเพอร์แซนด์ หรือแค่ a หรือ
ดังนั้นสิ่งที่พวกเขาจะทำคือ พวกเขากำลังทดสอบ และพวกเขาจะตั้งค่าแต่ละบิตภายในตัวแปรจำนวนเต็ม
บิตคืออะไร?
เรารู้ว่าบิตเป็นวิธีการวัดข้อมูล
แต่บิตก็เป็นเพียงค่า 0 หรือ 1 เท่านั้น
และ 8 ในนั้นประกอบกันเป็นไบต์ บิตจึงเป็น 0 หรือ 1
และสิ่งที่คุณทำได้คือจำนวนเต็ม จำไว้ว่า
ขึ้นอยู่กับระบบที่คุณกำลังเรียกใช้ อาจเป็น 8 ไบต์
ดังนั้นคุณจึงสามารถเปิดและปิดแต่ละบิตได้
และเมื่อฉันบอกว่าเปิดหรือปิด ฉันบอกว่าคุณสามารถให้พวกมันเท่ากับ 1 หรือ 0 ได้
จากนั้นคุณสามารถใช้บิตเหล่านั้นเพื่อบอกคุณบางอย่างได้
คุณจึงสามารถเก็บข้อมูลได้จำนวนมากโดยให้บิตแสดงข้อมูลบางประเภท
นั่นเป็นสาเหตุหนึ่งที่ทำให้คอมพิวเตอร์ใช้บิตใน 1 และ 0 และเลขฐานสองเพื่อดำเนินการ
เนื่องจากคุณสามารถเก็บข้อมูลได้จำนวนมาก
ตรงนี้หมายความว่าอย่างไร
นี่คือตัวอย่าง คุณสามารถใช้ตัวแปรจำนวนเต็มตัวเดียวได้
อีกครั้ง จำนวนเต็มคือตัวเลข จำนวนเต็มแทน 4 ถึง 8 ไบต์
ขึ้นอยู่กับระบบที่คุณใช้งาน
หมายความว่าถ้ามี 4 ไบต์ แสดงว่ามี 32 บิต
มี 32 0s หรือ 1 ค่า
ดังนั้นคุณสามารถใช้บิตทั้งหมดเหล่านี้เพื่อเป็นตัวแทนของบางสิ่งได้
ตัวอย่างเช่น ถ้าคุณต้องการเก็บอักขระแต่ละตัวไว้กับบุคคล
คุณสามารถมี 1 บิต บอกคุณว่าบุคคลนั้นเป็นชายหรือหญิงโดยพูดว่า
1 เท่ากับชาย 0 เท่ากับหญิง
คุณเพียงแค่เปิดหรือปิด
จากนั้นคุณสามารถใช้ 3 บิตเพื่อระบุว่าบุคคลนั้นสามารถพูดภาษาฝรั่งเศส
เยอรมัน หรืออิตาลีได้หรือไม่
ดังนั้น 1 บิตจึงสามารถแทนภาษาฝรั่งเศสได้ ถ้าไม่ใช่ 1 0 แสดงว่าพวกเขาไม่พูดภาษาฝรั่งเศส
หากภาษาเยอรมันเป็น 0 แสดงว่าพวกเขาไม่พูดภาษาเยอรมัน
หากเป็น 1 แสดงว่าพวกเขาพูดภาษาเยอรมันได้ ดังนั้นโดยปิดและเปิดบิตเหล่านี้ โดยตั้งค่าเป็น
1 เป็น 0 คุณสามารถแสดงข้อมูลจำนวนมากได้
คุณสามารถบันทึกได้อีกเล็กน้อยว่าเงินเดือนของบุคคลนั้นคือ 50,000 หรือมากกว่า
ถ้าเป็น 1 ก็จริง ใช่ ก็คือใช่ 0 เท็จ
โดยพื้นฐานแล้วเราเพิ่งระบุที่นี่
อันที่จริงมันบอกว่า 4 แต่จริงๆ แล้วเราระบุข้อมูล 5 บิต
มีเพียง 5 เท่านั้นจากทั้งหมดที่เรามีอยู่ 32 หรือมี
64 บิต แต่เราใช้เพียง 5 บิต และเราสามารถแสดงได้ว่าบุคคลนั้นเป็นหญิงหรือชาย
ไม่ว่าพวกเขาจะพูดภาษาฝรั่งเศส เยอรมัน หรืออิตาลี หรือทั้ง 3 ภาษาหรืออย่างอื่นก็ตาม
และไม่ว่าพวกเขาจะทำเงินได้มากกว่า 50,000 ดอลลาร์หรือไม่
เราสามารถแสดงข้อมูลทั้งหมดในบิตของเรา
และนี่คือจุดที่ตัวดำเนินการระดับบิตมีประโยชน์
ตอนนี้เรารู้แล้วว่าเราจะใช้บิตเพื่อเก็บข้อมูลต่างๆ
ได้อย่างไร มาพูดถึงเลขฐานสองกัน
เรารู้ว่าเลขฐานสองเป็นเพียงตัวเลขที่มี 1 และ 0
และนั่นเป็นเหตุผลว่าทำไมจึงเป็นประโยชน์ต่อการใช้งาน ตัวดำเนินการบิตเป็นจำนวนเต็ม ตัวเลขสามารถมีความยาวเท่าใดก็ได้
ต่อไปนี้เป็นตัวอย่างของเลขฐานสอง เพียง 0 และ 1
คุณได้เห็นสิ่งนี้แล้ว 0 1 0 1 0 1 1 0 1 0 1 0
และจำไว้ว่าไบต์คือ 8 บิต
จำนวนเต็มมักจะเป็น 4 ไบต์บนแพลตฟอร์มส่วนใหญ่
ขึ้นอยู่กับสถาปัตยกรรม แต่ส่วนใหญ่เป็น 32 บิต
ดังนั้นคุณจึงมีค่า 32 ค่าที่คุณสามารถจัดเก็บด้วย 1 และ 0 เพื่อระบุว่าเปิดหรือปิด
เลขฐานสอง ทุกเลขฐานสองมีค่าทศนิยมที่สอดคล้องกัน ดังนั้นคุณต้องเข้าใจวิธีการแปลงเลขฐานสองเป็นทศนิยม
ตัวอย่างที่นี่ 1 เท่ากับ 1, 1 0 คือ 2, 1 1 คือ 3 นี่คือการแปลงอย่างง่าย
โดยปกติแล้วจะมีบิตมากกว่า 1 0 1 0 1 1 1
วิธีที่คุณต้องการแปลงเลขฐานสองเป็นเลขฐานสองคือ
คุณต้องการดูแต่ละตำแหน่งในไบต์ด้วยบิตที่สอดคล้องกัน
แล้วใช้ยกกำลัง 2
ดังนั้นสำหรับแต่ละหลัก คุณคูณตัวเลขนั้นด้วยค่าตำแหน่งโดยใช้ยกกำลัง
2 จากนั้นคุณรวมโครงการทั้งหมดเพื่อให้ได้ผลลัพธ์สุดท้าย
ดังนั้นค่าตำแหน่งและเลขฐานสองจึงเป็นกำลังของ 2
ดังนั้นตำแหน่งแรกจะเป็นค่า
2 0 ซึ่งก็คือ 1
แล้วตำแหน่งที่สองจะเป็นค่าของ 2 ยกกำลังแรก ซึ่งก็คือ
2, 2 ยกกำลัง 2 จะเป็น 4, 2 ถึง 3 จะเป็น 8, 2
ยกกำลัง 4 จะเป็น 16 และคุณทำอย่างนั้นซ้ำแล้วซ้ำอีก
ดังนั้นจึงเข้าใจได้ง่ายขึ้นหากคุณเห็นตัวอย่างที่ดี
และตรงนี้ เรามีเลขฐานสอง 0 1 1 0 1 0 0 1
ทศนิยมของสิ่งนั้นคือ 105
วิธีที่คุณแปลงคือคุณเริ่มทางด้านขวามือสำหรับแต่ละบิต
และคุณคูณกำลัง 2 ขึ้นอยู่กับว่าบิตนั้นเป็น 0 1 หรือไม่
แล้วถ้าเราเริ่มไปทางขวา เรามี 1
เราก็บอกว่า 1 คูณ 1 แล้วเก็บ 1 อันนั้นไว้ จากนั้น 1 ถัดไป ตำแหน่งที่สองคือ
0 คูณ 2 0 จากนั้น 0 คูณ 4, 1
คูณ 8, 0 คูณ 16,1 คูณ 32, 1
คูณ 64 และ 0 คูณ 28
แล้วคุณบวกทั้งหมดเข้าด้วยกัน แล้วคุณจะได้ผลลัพธ์เป็น 105
นั่นเป็น 1 วิธีในการแปลง คุณสามารถแปลงจากซ้ายไปขวาได้เช่นกันโดยการคูณด้วย
2 แล้วบวก 1 หรือเพิ่ม 0 ขึ้นอยู่กับว่าบิตถัดไปคืออะไร
ตัวอย่างเช่น
คุณยังสามารถถ้าคุณไปทางซ้ายไปขวา คุณเริ่มด้วย
1 เพราะ 0 ไม่สำคัญ
บิตที่สองจากซ้ายไปขวา คุณมี 1
บิตที่สาม, คุณมี 1 คูณ 2 บวก
1, คุณจะได้ 3
อีกครั้ง คุณคูณด้วย 2 คุณจึงบอกว่า 3 คูณ 2 บวก 0 ซึ่งก็คือ 6
6 คูณ 2 บวก 1, ซึ่งก็คือ 13
13 คูณ 2 ได้ 26
26 คูณ 2 ได้ 52 คูณ 2,
ซึ่งก็คือ 104 บวก 1
คูณด้วย 2 อีกครั้งแล้วบวก 1 อีกตัวอย่างหนึ่ง อีกครั้ง
ขวาไปซ้ายมักจะง่ายกว่าเล็กน้อย
นี่คือ 1 0 0 1 1 1 0 0
และนั่นแปลงเป็น 156 เพราะคุณพูดอีกครั้ง
0 คูณ 1, 0 คูณ 2, 1 คูณ 4, 1 คูณ 8, 1 คูณ 16 เป็นต้น
แล้วบวกทั้งหมดเข้าด้วยกัน
ซึ่งก็คือ 4 8 12 16 28 บวก 128 ได้ 156 .
และอีกอย่าง ถ้าคุณไปทางซ้าย คุณคูณด้วย 2 บวก 1
เราเลยเริ่มที่ 1 สมมติว่า
1 2 4 9 4 คูณ 2 บวก
1 9 คูณ 2 ได้ 18 บวก
1 ได้ 19 คูณ 2 38 บวก 1 ได้
39 คูณ 2 ซึ่งก็คือ 78 คูณ 2
ซึ่งก็คือ 156
ดังนั้นนี่คือการสาธิตอย่างรวดเร็วว่าคุณสามารถแปลงเลขฐานสองเป็นทศนิยมได้อย่างไร
ตอนนี้แปลงเดซิเบลเป็นเลขฐานสอง
ฉันมักจะใช้การแปลงบนเว็บหากคุณสนใจเรื่องนั้นจริงๆ
แต่คุณสามารถใช้เลขฐานสองเหล่านี้แล้วดำเนินการตัวดำเนินการระดับบิตได้
ลองมาดูตัวดำเนินการระดับบิตกัน
ดังนั้นตัวดำเนินการระดับบิตจึงสรุปไว้ที่นี่ และอีกครั้ง ตารางดีๆ อีกอันที่ฉันได้ออนไลน์มา
แต่พวกมันดูคล้ายกับตัวดำเนินการเชิงตรรกะ แต่อย่าสับสนอีกครั้ง
ดังนั้นเครื่องหมายและโดยตัวมันเองจึงเป็นเลขฐานสองและตัวดำเนินการ
และสิ่งที่กำลังทำอยู่ก็คือการคัดลอกบิตไปยังผลลัพธ์หากมีอยู่ในตัวถูกดำเนินการทั้งสอง
ดังนั้นหากทั้งสองเป็นจริงก็จะคัดลอกเล็กน้อย
ถ้า a กับ b เท่ากับ 12, คุณจะได้เลขฐานสองเป็น
0 0 0 0 1 1 0 0
a กับ b จะเป็นเลขนั้น
เราจะพูดถึงตัวอย่าง
ไบนารีหรือคัดลอกบิตหากมีอยู่ในตัวถูกดำเนินการ ดังนั้น a หรือ b จะคัดลอกบิตหากมีอยู่ในตัวถูกดำเนินการอย่างใดอย่างหนึ่ง
ดังนั้นถ้าตัวถูกดำเนินการใดเท่ากับ
1 มันจะคัดลอกบิต
แล้วไบนารี xor นี่คือเอกสิทธิ์หรือ
การดำเนินการนี้จะคัดลอกบิตหากตั้งค่าเป็น 1 ตัวถูกดำเนินการ แต่ไม่ใช่ทั้งสองอย่าง
ดังนั้นถ้าคุณมีค่าจริง แต่จริงเพียง 1
รายการเท่านั้น และคุณใช้แครอทแทนค่านี้บนแป้นพิมพ์
มันก็จะคัดลอกเล็กน้อย และจะบอกว่าเป็นจริง
ส่วนเสริมเลขฐานสอง
1
อีกครั้ง เราได้รับข้อมูลไบนารีที่นี่ เพราะเรากำลังพูดถึงบิต หวังว่า, คอมพลีเมนต์
1 ของ
โอเปอเรเตอร์เป็นเอกภาพและมีผลในการพลิกบิต
โดยทั่วไปเพียงแค่ปฏิเสธและถอดจอภาพออก
ตัวอย่างที่นี่คือถ้าคุณพูดว่า tilde a คุณกำลังใช้ตัวดำเนินการเสริม
1s
และถ้ามันเท่ากับลบ 61 มันจะเป็น 1 1 0 0 0 0 1
ดังนั้นหากคุณต้องแปลงเลขฐานสองนั้นเป็นทศนิยมซึ่งเป็นจำนวนลบและตัวเลขแรกคือเครื่องหมาย
1 บอกคุณว่าเป็นสัญญาณ
แล้วคุณบอกว่า 1 2 4 8 16 33 แล้วก็
61 นั่นเป็นวิธีที่มันแสดง
ผมจะยกตัวอย่างที่ชัดเจนกว่านี้
แต่โดยพื้นฐานแล้ว หากคุณมีเลขฐานสอง a จะเป็นเลขฐานสองที่
0 0 1 1 1 1 0 0 ซึ่งก็คือ 60 และคุณใส่การพลิกกลับโดยพื้นฐานแล้วมันจะกลายเป็นลบ
61 ซึ่งก็คือ 1 1 0 0 0 0 0 0 0 0 0 1 1.
นี่คือผลลัพธ์ของตัวแปรที่ตั้งไว้จริง อีกครั้ง ฉันถือว่า a มีการแทนค่าเลขฐานสอง
และ b มีการแทนค่าเลขฐานสองบางอย่าง
ดังนั้นหาก a เท่ากับ อีกครั้ง 60 และ b เท่ากับ 13
แล้วผลลัพธ์ของการบวกพวกมันเข้าด้วยกันโดยคิดเป็นระดับบิตและจะเท่ากับ
0000 11 00 ซึ่งเท่ากับ 12
อีกครั้ง ฉันจะพูดถึงตัวอย่างเหล่านี้ แต่เป็นการพยายามให้คำอธิบายเล็กน้อยเกี่ยวกับตัวดำเนินการไบนารีที่แตกต่างกันเหล่านี้
สัญลักษณ์น้อยกว่าจะเลื่อนบิตไปทางซ้าย
ดังนั้นค่าตัวถูกดำเนินการทางซ้ายจะถูกย้ายไปทางซ้ายตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการสีขาว
ดังนั้นหากคุณทำอะไรที่น้อยกว่า 2 และ
a เท่ากับคุณทราบเลขฐานสอง
ตัวอย่างเช่น 0 0 1 1 1 1 0 0 คุณจะเปลี่ยนไบต์เป็น
2
คุณกำลังถอด 0 และมันจะกลายเป็น 1 1 1 1 และ 0 เหล่านั้นจะไปสิ้นสุด
และเช่นเดียวกันกับตัวดำเนินการกะทางขวา คุณแค่เลื่อนมันไปทางขวาแทนที่จะเป็นทางซ้าย
ที่นี่คุณใช้สัญลักษณ์มากกว่า
ดังนั้นฉันจะผ่านสิ่งเหล่านี้ในไม่กี่วินาที
สิ่งสำคัญอีกอย่างที่ต้องทำความเข้าใจกับตัวดำเนินการระดับบิตคือวิธีประเมินค่า
a และ b เหล่านี้ แล้ว 1 กับ 1 หาค่าอะไรเป็น
1 ถ้ามันคือเครื่องหมาย
หากเป็น
a หรือ 1 และ 1 ให้ค่าเป็น 1 ด้วย
แต่ 1 กับ 1 และ 0 หากคุณใช้เครื่องหมายแอมเพอร์แซนด์และค่านั้นมีค่าเป็น
0 เท็จ ดังนั้นฉันแค่อยากจะให้ตารางความจริงเล็กๆ
น้อยๆ ที่นี่ เพื่อแสดงค่าเมื่อคุณทำมัน คุณใช้
an และ an หรือ an exclusive หรือ
ดังนั้นที่นี่ถ้าคุณมี p0 และ q0 ซึ่งหมายความว่าทั้งคู่เป็นเท็จ
และคุณใช้ a และมันจะเป็นเท็จ เพราะทั้งคู่จะต้องเป็นจริงเพื่อให้สิ่งนั้นเป็นจริง
และนั่นคือสิ่งที่คุณเห็นในแถวที่ 3
ทั้งคู่เป็นจริง จากนั้น p และ q จะแทนค่าเป็น 1 จริง
ถ้าไม่จริงทั้งคู่ มันก็เป็นเท็จเสมอ
P หรือ q มีเพียง 1 เท่านั้นที่ต้องเป็นจริง
นั่นเป็นสาเหตุที่คุณเห็นแถวที่ 1 และแถวที่ 2 เท่ากับ 1 และแถวที่ 3 เท่ากับ 1
ครั้งเดียวที่มันเป็นเท็จก็คือเมื่อทั้งคู่เป็นเท็จ
แล้วเอกสิทธิ์หรืออย่างน้อย 1 ในนั้นเป็นจริงและมีเพียง
1
ดังนั้น ถ้า p เป็นเท็จ และ q เป็นจริง มันจะคืนค่าเป็นจริง
และถ้า p เป็นจริงและ q เป็นเท็จ มันจะคืนค่า 1
ดังนั้นสิ่งนี้จะช่วยให้คุณมีแนวคิดว่าจะมีการประเมินอย่างไร
อีกครั้ง คณิตศาสตร์มากมาย แต่เมื่อเราพูดถึงเลขฐานสอง นั่นคือสิ่งที่เรากำลังพูดถึง
ลองดูตัวอย่างที่เป็นรูปธรรมและบล็อคโค้ด หวังว่านี่จะช่วยได้บ้าง
นี่คือหน้าที่ของเรา ฉันจะสร้างตัวแปรอีกสองสามตัว
ฉันจะตรวจสอบให้แน่ใจว่าพวกเขาไม่ได้ลงนามแม้ว่าจะเป็นค่าเริ่มต้นก็ตาม
ดังนั้น
ถ้าฉันบอกว่า unsigned int a และกำหนดเป็น 60 ค่านั้นจะถูกแสดงเป็นเลขฐานสองเป็น
0 0 1 1 และ 11 00
ถ้าฉันสร้างตัวแปรอื่นที่ไม่ได้ลงนาม และฉันบอกว่า
int b และฉันกำหนดค่าเป็น 13
นั้น จะถูกแสดงเป็นไบนารี่ 0 0 00 1 1 0 1
คุณสามารถทำการแปลงที่นั่น
แต่สิ่งที่ผมอยากแสดงให้เห็นคือ เมื่อคุณตั้งค่าเลขฐานสองเหล่านี้
คุณสามารถปิดบิตได้โดยใช้ตัวถูกดำเนินการระดับบิตต่างๆ
ทีนี้ ผมจะแค่สร้างผลลัพธ์ int และผมจะบอกว่ามันจะเท่ากับ
0
E จะเก็บผลลัพธ์ของการดำเนินการระดับบิต
การดำเนินการ. ทีนี้ ถ้าฉันบอกว่า c เท่ากับ a และฉันใช้ตัวถูกดำเนินการระดับบิต
กับ a กับ b ตอนนี้ สิ่งที่ควรทำคือถ้า a เท่ากับ 1 และ b เท่ากับ
1 บิตนั้นจะถูกเปิดใช้งาน
แล้วคุณคาดหวังผลลัพธ์ของ v. นี้อย่างไร
ทีนี้, คุณดูที่บิตแรกของ a และคุณดูที่บิตแรกของ b และพวกมันเป็น
0 ทั้งคู่
ผลลัพธ์จะเป็น 0 เพราะถ้าคุณเป็นจริงใน
a และ a b ทั้งคู่จะต้องเป็นจริงเพื่อที่จะเป็น 1
ตัวต่อไปจะเป็น 0 ด้วย อันถัดไปคือ 1 และ 0 บิตที่สาม
มันก็ยังคงเป็น 0, 1 และ 0 ยังคงเป็น 0 แล้วตอนนี้เรามี 1 กับ 1
ดังนั้นในที่สุดเราก็มีความจริง เรามีอีก 1 กับ 1 เรามีของจริง
แล้ว 0 กับ 0 จะเป็น 0 แล้ว 0 กับ 1 จะเป็น
0
ดังนั้นผลลัพธ์หากฉันพยายามพิมพ์ c มันจะพิมพ์ค่าในรูปแบบทศนิยม
ถ้าผมทำแบบนั้น
มันจะพิมพ์ค่าทศนิยมของเลขฐานสองนั้นออกมา ซึ่งจะเท่ากับ
0 0 0 0
และนี่คือการแปลงเลขฐานสองเป็นทศนิยม ดังนั้นคุณต้องเข้าใจวิธีการทำเช่นนั้นจึงจะเข้าใจตัวอย่างนี้
แต่
0 0 0 0 1 1 0 0 คือ 1 3 7 จริงๆ แล้วค่าคือ
12, 1 3 6 12
นี่จะพิมพ์ออกมาสิบสองถ้าฉันพิมพ์ c หรือผลลัพธ์จะดีกว่า
ถ้าผมรันนี่ คุณจะเห็นว่าค่าเป็น 12
อันที่จริงมันถูกปิดและในทุกบิตตามการเปรียบเทียบเครื่องหมายและ
ตอนนี้ฉันบอกว่า
run เราเห็นว่าค่าอยู่ใน d12 เพราะมันปิดและเปิดบิตและมันจะถูกแสดงเป็น
0 0 0 1 1 0 0 ซึ่งเป็นค่า 12 เพราะเราพิมพ์ทศนิยม
.
ถ้าฉันต้องเปลี่ยนสิ่งนี้และฉันต้องการทำ
an หรือ และฉันยังคงทำ หรือ และ the หรือ จำ คือแถบขนานที่อยู่ถัดจาก
enter ตอนนี้ ฉันจะเปิดบิตก็ต่อเมื่อ 1 อันใดอันหนึ่งเป็น
จริง. 00 ทั้งสองอันเป็นเท็จ
อีกครั้งที่ฉันกำลังเปรียบเทียบที่นี่
ฉันกำลังเปรียบเทียบบิตเหล่านี้สำหรับ 16 และ 13
16 แสดงเป็นเลขฐานสอง 0 0 1 1 1 1 1 0 0
13 แสดงเป็นเลขฐานสอง 0 0 0 0 1 1 0 คือ 1
แต่ละตัวเลขเหล่านี้แสดงถึงบิต
ดังนั้นบิตแรกใน 60 จึงเป็น 0 บิตแรกใน 13 จึงเป็น 0
และถ้าฉันสั่งมันเข้าด้วยกัน, 0 กับ 0, ฉันจะยังได้ 0 นั่นคือผลลัพธ์แรกของบิตแรก
บิตที่สอง 00 อีกครั้ง บิตที่สามคือ 1 สำหรับ 60 และมันคือ
0 สำหรับ 13
ทั้งหมดนั่นหมายความว่าผมต้องมี 1 จริง มันจะเป็น 1
เช่นเดียวกับบิตหมายเลข 4 และ 16, 13 ตอนนี้ผมมี 1 อีกครั้ง
แล้ว 1 กับ 1 ทั้งคู่ก็จริง อีกอย่าง 1, ทั้งหมดที่ฉันต้องการคือ
1 จริง, อีก 1 อัน
ทั้งเท็จเพื่อที่จะไม่เป็นความจริง 0 จำไม่จริง 1
เป็นจริง 0 11 ตอนนี้ฉันมี 0 0 1 1 1 1 0 1
และค่าของมันเป็นทศนิยมถ้าฉันจะพิมพ์ออกมา ก็คือคุณต้องเข้าใจวิธีแปลงเลขฐานสองเป็นทศนิยมอีกครั้ง
แต่โดยทั่วไปแล้วมันจะเป็น 1 3 7 15 30 61
นี่จะพิมพ์ออกมาเป็น 61
จบโปรแกรมนี้และสร้างใหม่
และเราจะได้เห็นค่า 61
นั่นคือตัวดำเนินการระดับบิต และอีกครั้ง มันเป็นโปรแกรมขั้นสูงประเภทหนึ่ง
แต่มันเป็นวิธีที่ดีในการแสดงข้อมูลจำนวนมากโดยใช้เครื่องหมายและและอื่น
ๆ โดยการเปิดและปิดบิตโดยพื้นฐานแล้ว
ดังนั้นคุณสามารถเล่นกับสิ่งนี้ได้
คุณสามารถทำแบบเอกสิทธิ์เฉพาะบุคคลหรือแบบที่เป็นแครอทก็ได้
แครอทอยู่เหนือเลข 6 เลข 6 บนแป้นพิมพ์
คุณจะเห็นผลลัพธ์ที่แตกต่างออกไป หากคุณจะเพิ่มเครื่องหมายตัวหนอน นั่นจะเป็นการปิดทุกอย่างโดยพื้นฐาน
ดังนั้นสำหรับ a และ a เท่ากับ 60, 0 0 1 1 1
1 0 0 มันจะไม่เท่ากับ 1 1 0 0 0 0 1 1
สิ่งที่ยอดเยี่ยมอีกอย่างหนึ่งที่คุณสามารถทำได้ด้วยตัวดำเนินการไบนารีคือการขยับ
ขยับไปทางซ้ายและขวา มีสิ่งสำคัญสองสามอย่างที่คุณทราบเมื่อคุณต้องการเลื่อนไปทางซ้ายหรือขวา
ก่อนอื่น เรารู้ว่า int ที่ไม่ได้ลงชื่อหมายความว่าสามารถเป็นค่าบวกได้เท่านั้น
ไม่สามารถเป็นลบได้
ดังนั้นหากคุณเก็บค่าลบไว้ที่นั่น คอมไพล์จะแปลงค่าให้นานขึ้น จะใช้ขนาดมาก
ดังนั้น จำไว้ว่า unsigned int หมายความว่าคุณสามารถมีค่าบวกได้เท่านั้น
เลขจำนวนเต็มที่มีเครื่องหมายหมายความว่าสามารถเป็นค่าลบหรือค่าบวกได้
แต่ถ้าคุณต้องการเปลี่ยน จำไว้เพื่อที่จะเลื่อนไปทางซ้าย
ดังนั้นตอนนี้ถ้าเราบอกว่าผลลัพธ์เท่ากับและสมมุติว่าเราอยากเลื่อน a
สมมุติว่าด้วย 2 สิ่งสำคัญอื่นๆ ที่คุณอยากรู้คือเมื่อคุณมี จำนวนเต็ม จำนวนเต็ม คือ 4 ไบต์บนแพลตฟอร์มส่วนใหญ่
ขึ้นอยู่กับว่าคุณสามารถรับขนาดได้ด้วยการทำขนาดของโอเปอเรเตอร์
จำนวนเต็มคือ 4 คือ
32 บิต จริงๆ แล้วตัวเลขเป็นแบบนี้
16
อะไรแบบนั้น 4 8 12 16 20 24 มันคืออะไร
ดังนั้นคุณจึงน่าจะเป็นแบบนั้นและอะไรแบบนั้น
นั่นคือตัวเลขจริงๆ ฉันแสดงเฉพาะ 8 บิตสุดท้ายเพราะส่วนที่เหลือเป็น
0 แต่ถ้าคุณมองว่านี่เป็นจำนวนเต็ม
32 บิต ซึ่งก็คือ 4 ไบต์ นี่คือสิ่งที่ดูเหมือนเป็นไบนารี
4 0s 4 0s 4 0s 4 0s 4 0s 4 0s และจากนั้น 0 0 1 1 1 1 0 0 .
ดังนั้นคุณต้องรู้ขนาดเมื่อคุณขยับซ้ายหรือขวา
เพราะถ้าคุณเปลี่ยนมากกว่า 2 จะไม่ชัดเจน
มันไม่หลุดหรืออะไรแบบนั้น
ขอผมแน่ใจอีกครั้งว่า 48 12 16
20 24 28 32 เท่ากับ 13
ดังนั้นหากคุณเลื่อนไปทางซ้ายมากกว่ามากกว่า
2, สิ่งที่คุณจะได้คือ 1 ตัวนี้ก็จะเลื่อนไปทางซ้ายด้วย
ผลลัพธ์จะยังคงเป็นเลขก่อนหน้า
0s ทั้งหมด แต่คุณจะมี 1 1 1 1 0 0 0 0 0
และนั่นจะเท่ากับ 240
และถ้าฉันแปลงอย่างรวดเร็ว ฉันคิดในใจโดยบอกว่า
1 3 7 15 30 60 122 40 แต่เราสามารถยืนยันได้โดยการสร้างและดำเนินการ
คุณจะเห็นว่าผลลัพธ์คือ 240
และเราเห็นว่าผลลัพธ์คือ 240
ดังนั้นตอนนี้ ถ้าคุณต้องการเปลี่ยนไปที่มากกว่า 2 ของฉันจริง
ๆ ว่าคุณต้องการเลื่อนด้วย 4 นี่คือตอนสำคัญที่ต้องเข้าใจว่ามันคือตัวเลข 32 บิต
ดังนั้นที่นี่คุณจะต้องใช้ 0 บางตัว
ดังนั้นถ้าคุณอยากเลื่อนเป็น 4 จริงๆ คุณจะได้อะไรแบบนั้น
แล้วถ้าคุณอยากจับกลุ่มมันด้วย
4, คุณจะได้อะไรแบบนั้น
ผลลัพธ์ที่นี่จะเป็นอีกครั้ง
ถ้าฉันคิดในใจ คุณมี 1 3 7 15 30 60
120 240 480 แล้วก็ 960
หวังว่าฉันทำถูกต้องแล้ว อีกครั้งเมื่อเรารันสิ่งนี้และเราบอกว่า
960 มันเลื่อนไปทางซ้าย
หากคุณต้องการเลื่อนไปทางขวา
ให้ใช้สัญลักษณ์มากกว่า
ดังนั้นเมื่อเปลี่ยนไปใช้โอเปอเรเตอร์ shift right
shift ด้านขวา คุณทำมากกว่า ตัวดำเนินการกะไบนารีซ้าย คุณทำน้อยกว่า
นี่ถ้าคุณจะเลื่อนไปทางขวา คุณต้องการย้ายไปทางขวา 4
และจะเกิดอะไรขึ้นถ้าคุณมีจุดสิ้นสุดที่นี่ ดังนั้นถ้าคุณมี
60 เดิม คุณก็ลองไป 4 คุณจะมีตัวเลขที่เพิ่งหลุดไป
แทนที่จะมี 4 อันหลัง ซึ่งเดิมมี
60 อัน เรามี 0
0 0 1 1 1 1 0 0 เราต้องข้าม 4
ดังนั้นเราจะจบลงด้วยการสูญเสีย 2 บิต เพราะพวกเขากำลังจะดรอป
และสิ่งที่เรากำลังจะจบลงคือแบบนี้
0 0 แล้วนี่จะเท่ากับ 3 อะไรประมาณนั้น
คุณเสียบิตเพราะคุณเลื่อนไปทางขวามากเกินไป คุณได้ผลลัพธ์เป็น
3 ดังนั้นคุณต้องระมัดระวังเมื่อคุณเลื่อนไปทางซ้ายและขวา
ตรวจสอบให้แน่ใจว่าคุณใช้ 32 บิต 4 ไบต์เหล่านั้นอีกครั้งขึ้นอยู่กับระบบของคุณ
เป็นการสรุปโดยย่อของตัวดำเนินการระดับบิต
เมื่อคุณก้าวหน้ามากขึ้น คุณต้องเข้าใจว่าคุณจะตรวจสอบได้อย่างไรว่าบิตใดเป็น
1 หรือ 0
มันค่อนข้างง่าย คุณเพียงแค่ทำและกับมัน
แต่คุณต้องเขียนโค้ดเพิ่มอีกเล็กน้อย
การบรรยายนี้ไม่ได้มีวัตถุประสงค์เพื่อให้ดูตัวดำเนินการระดับบิตอย่างละเอียดถี่ถ้วน
ฉันต้องการให้ภาพรวม
ให้คุณเริ่มต้นได้ดี แต่เพื่อให้เข้าใจโอเปอเรเตอร์เหล่านี้มากขึ้น
คุณจะต้องศึกษาเพิ่มเติมอีกเล็กน้อยและใช้พวกมันและฝึกฝน
ดังนั้นฉันหวังว่านี่จะเป็นประโยชน์ อีกครั้งอาจทำให้สับสนเล็กน้อยดังนั้นคุณจึงต้องการติดตามและต้องการเล่นด้วย
แต่อีกครั้ง
อะไรคือวิธีที่ดีที่สุดในการเรียนรู้ เขียนโค้ด เรียนรู้ตัวอย่าง ขอขอบคุณ.