ทำไม (a% 256) แตกต่างจาก (a & 0xFF)

ฉันมักจะสันนิษฐานว่าเมื่อทำเพิ่มประสิทธิภาพธรรมชาติจะใช้การดำเนินการที่มีประสิทธิภาพค่าที่เหมาะสมเช่นถ้าผมเขียน(a % 256)(a & 0xFF)

เมื่อทำการทดสอบกับคอมไพเลอร์ explorer gcc-6.2 (-O3):

// Type your code here, or load an example.
int mod(int num) {
    return num % 256;
}

mod(int):
    mov     edx, edi
    sar     edx, 31
    shr     edx, 24
    lea     eax, [rdi+rdx]
    movzx   eax, al
    sub     eax, edx
    ret

และเมื่อลองรหัสอื่น:

// Type your code here, or load an example.
int mod(int num) {
    return num & 0xFF;
}

mod(int):
    movzx   eax, dil
    ret

ดูเหมือนว่าฉันกำลังพลาดอะไรบางอย่างไปหมด ความคิดใด ๆ

มันไม่เหมือนกัน ลองnum = -79และคุณจะได้รับผลลัพธ์ที่แตกต่างจากการดำเนินการทั้งสอง (-79) % 256 = -79ในขณะที่(-79) & 0xffเป็นจำนวนบวก

การใช้unsigned intการดำเนินการเหมือนกันและรหัสอาจจะเหมือนกัน

PS- มีคนแสดงความคิดเห็น

พวกเขาไม่ควรจะเหมือนกันถูกกำหนดให้เป็นa % ba - b * floor (a / b)

นั่นไม่ใช่วิธีที่กำหนดไว้ใน C, C ++, Objective-C (เช่นทุกภาษาที่มีรหัสในคำถามรวบรวม)

คำตอบสั้น ๆ

-1 % 256อัตราผลตอบแทน-1และไม่ได้ซึ่งเป็น255 -1 & 0xFFดังนั้นการเพิ่มประสิทธิภาพจะไม่ถูกต้อง

คำตอบที่ยาว

C ++ มีการประชุมที่(a/b)*b + a%b == aดูเหมือนเป็นธรรมชาติ a/bส่งคืนผลลัพธ์เลขคณิตเสมอโดยไม่มีส่วนที่เป็นเศษส่วน (ตัดเหลือ 0) ผลที่ตามมาa%bก็คือมีสัญญาณเดียวกันกับaหรือเป็น 0

การแบ่ง-1/256ผลตอบแทน0และด้วยเหตุนี้-1%256จะต้องเป็น-1ไปตามเงื่อนไขข้างต้น ( (-1%256)*256 + -1%256 == -1) นี้จะเห็นได้ชัดจากการที่แตกต่างกันซึ่งเป็น-1&0xFF 0xFFดังนั้นคอมไพเลอร์ไม่สามารถปรับวิธีที่คุณต้องการ

ส่วนที่เกี่ยวข้องในมาตรฐาน C ++ [expr.mul §4] ณสถานะN4606 :

สำหรับโอเปอแรนด์หนึ่งตัวดำเนิน/การหาค่าผลหารพีชคณิตด้วยส่วนเศษส่วนใด ๆ หากความฉลาดทางสามารถa/bแทนได้ในประเภทของผลลัพธ์(a/b)*b + a%bจะเท่ากับa[... ]

เปิดใช้งานการเพิ่มประสิทธิภาพ

อย่างไรก็ตามการใช้unsignedประเภทการปรับให้เหมาะสมจะสมบูรณ์ถูกต้องเป็นไปตามอนุสัญญาข้างต้น:

unsigned(-1)%256 == 0xFF

ดูสิ่งนี้ด้วย

ภาษาอื่น ๆ

สิ่งนี้ได้รับการจัดการแตกต่างกันมากในภาษาการเขียนโปรแกรมต่าง ๆ เนื่องจากคุณสามารถค้นหาบนWikipediaได้

ตั้งแต่ C ++ 11 num % 256จะต้องไม่เป็นค่าบวกหากnumเป็นลบ

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

มันจะเป็นเรื่องที่แตกต่างถ้าnumในกรณีของคุณunsigned: วันนี้ฉันเกือบจะคาดหวังว่าคอมไพเลอร์เพื่อเพิ่มประสิทธิภาพที่คุณอ้างถึง

ฉันไม่มีความเข้าใจกระแสจิตเกี่ยวกับเหตุผลของคอมไพเลอร์ แต่ในกรณีที่%มีความจำเป็นในการจัดการกับค่าลบ (และหารรอบต่อศูนย์) ในขณะ&ที่ผลลัพธ์จะต่ำกว่า 8 บิตเสมอ

sarคำสั่งเสียงที่ฉันชอบ "เปลี่ยนสิทธิทางคณิตศาสตร์" เติมขึ้นบิตประดับด้วยค่าบิตเครื่องหมาย

การพูดทางคณิตศาสตร์โมดูโลถูกกำหนดให้เป็นดังต่อไปนี้:

a% b = a - b * floor (a / b)

นี่ตรงนี้ควรจะเคลียร์ให้คุณ เราสามารถกำจัด floor สำหรับจำนวนเต็มได้เนื่องจากการหารจำนวนเต็มเทียบเท่ากับ floor (a / b) อย่างไรก็ตามหากคอมไพเลอร์ใช้กลอุบายทั่วไปอย่างที่คุณแนะนำมันจะต้องใช้กับ a และ all b น่าเสียดายที่นี่ไม่ใช่กรณี การพูดทางคณิตศาสตร์กลอุบายของคุณถูกต้อง 100% สำหรับจำนวนเต็มที่ไม่ได้ลงนาม (ฉันเห็นคำตอบที่ระบุจำนวนเต็มลง แต่ฉันสามารถยืนยันหรือปฏิเสธได้ว่า -a% b ควรเป็นค่าบวก) อย่างไรก็ตามคุณสามารถทำเคล็ดลับนี้สำหรับ b ทั้งหมดได้หรือไม่? อาจจะไม่. นั่นเป็นสาเหตุที่คอมไพเลอร์ไม่ทำ ท้ายที่สุดถ้าโมดูโลถูกเขียนอย่างง่าย ๆ เป็นการดำเนินการระดับบิตหนึ่งเราก็จะเพิ่มวงจรโมดูโลเพื่อเพิ่มและดำเนินการอื่น ๆ