เซ็นชื่อกับจำนวนเต็มที่ไม่ได้ลงนาม

ฉันถูกต้องหรือไม่ที่จะพูดถึงความแตกต่างระหว่างจำนวนเต็มที่ลงชื่อและไม่ได้ลงชื่อคือ:

1. ไม่ได้ลงนามสามารถถือเป็นค่าบวกที่ใหญ่กว่าและไม่มีค่าลบ
2. Unsigned ใช้บิตนำหน้าเป็นส่วนหนึ่งของค่าในขณะที่เวอร์ชันที่เซ็นชื่อใช้บิตซ้ายสุดเพื่อระบุว่าหมายเลขเป็นบวกหรือลบ
3. จำนวนเต็มที่ลงนามแล้วสามารถถือได้ทั้งตัวเลขบวกและลบ

ความแตกต่างอื่น ๆ

ไม่ได้ลงนามสามารถถือเป็นค่าบวกที่ใหญ่กว่าและไม่มีค่าลบ

ใช่.

Unsigned ใช้บิตนำหน้าเป็นส่วนหนึ่งของค่าในขณะที่เวอร์ชันที่เซ็นชื่อใช้บิตซ้ายสุดเพื่อระบุว่าหมายเลขเป็นบวกหรือลบ

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

จำนวนเต็มที่ลงนามแล้วสามารถถือได้ทั้งตัวเลขบวกและลบ

ใช่

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

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

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

ประการแรกตัวเลขเสริมของทั้งสองมีคุณสมบัติที่การบวกและการลบนั้นเหมือนกับตัวเลขที่ไม่ได้ลงนาม มันทำให้ไม่แตกต่างกันว่าตัวเลขเป็นบวกหรือลบ (ดังนั้นคุณเพียงแค่ไปข้างหน้าและADDและSUBหมายเลขของคุณโดยไม่ต้องกังวล.)

ความแตกต่างเริ่มแสดงเมื่อมันมาถึงการเปรียบเทียบ x86 มีวิธีง่าย ๆ ในการแยกความแตกต่าง: ด้านบน / ด้านล่างแสดงถึงการเปรียบเทียบที่ไม่ได้ลงชื่อและมากกว่า / น้อยกว่าบ่งชี้การเปรียบเทียบที่ลงชื่อ (เช่นJAEหมายถึง "กระโดดถ้าสูงกว่าหรือเท่ากับ" และไม่ได้ลงชื่อ)

นอกจากนี้ยังมีชุดคำสั่งการคูณและการหารสองชุดเพื่อจัดการกับจำนวนเต็มที่ลงชื่อและไม่ได้ลงชื่อ

สุดท้าย: หากคุณต้องการตรวจสอบพูดล้นคุณจะทำมันแตกต่างกันสำหรับการลงนามและหมายเลขที่ไม่ได้ลงนาม

เขาเพียงถามเกี่ยวกับการลงนามและไม่ได้ลงนาม ไม่ทราบว่าทำไมผู้คนจึงเพิ่มสิ่งพิเศษลงในสิ่งนี้ ให้ฉันบอกคำตอบ

1. ไม่ได้ลงนาม: ประกอบด้วยเฉพาะค่าที่ไม่เป็นลบเช่น 0 ถึง 255

2. ลงนาม: ประกอบด้วยทั้งค่าลบและค่าบวก แต่ในรูปแบบที่แตกต่างกันเช่น

   • 0 ถึง +127
   • -1 ถึง -128

และคำอธิบายนี้เป็นเรื่องเกี่ยวกับระบบตัวเลข 8 บิต

เพียงไม่กี่จุดเพื่อความสมบูรณ์:

• คำตอบนี้พูดถึงการเป็นตัวแทนจำนวนเต็มเท่านั้น อาจมีคำตอบอื่นสำหรับจุดลอยตัว

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

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

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

ตามสิ่งที่เราเรียนรู้ในชั้นเรียนจำนวนเต็มที่ลงนามสามารถแสดงทั้งจำนวนบวกและลบในขณะที่จำนวนเต็มไม่ได้ลงนามเป็นเพียงไม่ลบ

ตัวอย่างเช่นการดูตัวเลข8 บิต :

ค่าที่ไม่ได้ลงนาม0ถึง255

ช่วงของค่าที่มีการลงชื่อตั้งแต่-128ถึง127

ทุกอย่างยกเว้นจุด 2 ถูกต้อง มีสัญกรณ์ที่แตกต่างกันมากมายสำหรับ int ที่ลงนามแล้วการใช้งานบางอย่างใช้ครั้งแรกส่วนอื่น ๆ ใช้สุดท้ายและอื่น ๆ ใช้สิ่งที่แตกต่างกันโดยสิ้นเชิง ทุกอย่างขึ้นอยู่กับแพลตฟอร์มที่คุณทำงานด้วย

ข้อแตกต่างอีกอย่างคือเมื่อคุณแปลงระหว่างจำนวนเต็มที่มีขนาดต่างกัน

ตัวอย่างเช่นถ้าคุณกำลังแยกจำนวนเต็มจากกระแสข้อมูลไบต์ (พูด 16 บิตเพื่อความง่าย) โดยมีค่าที่ไม่ได้ลงนามคุณสามารถทำได้:

i = ((int) b[j]) << 8 | b[j+1]

(อาจจะโยน 2 ^{ครั้ง}ไบต์ แต่ฉันคาดเดาคอมไพเลอร์จะทำสิ่งที่ถูกต้อง)

ด้วยค่าที่ลงนามคุณจะต้องกังวลเกี่ยวกับส่วนขยายสัญญาณและทำ:

i = (((int) b[i]) & 0xFF) << 8 | ((int) b[i+1]) & 0xFF

พูดโดยทั่วไปว่าถูกต้อง โดยที่ไม่รู้อะไรเพิ่มเติมเกี่ยวกับสาเหตุที่คุณมองหาความแตกต่างฉันไม่สามารถนึกถึงความแตกต่างอื่น ๆ ระหว่างการเซ็นชื่อและไม่ได้ลงชื่อ

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

1. ใช่จำนวนเต็มไม่ได้ลงนามสามารถเก็บค่าขนาดใหญ่
2. ไม่มีวิธีต่าง ๆ ในการแสดงค่าบวกและลบ
3. ใช่จำนวนเต็มที่ลงนามสามารถมีได้ทั้งค่าบวกและค่าลบ

(เพื่อตอบคำถามที่สอง) เพียงใช้บิตสัญญาณเท่านั้น (และไม่ใช่ส่วนเติมเต็ม 2) คุณสามารถจบด้วย -0 ไม่สวยมาก

เลขจำนวนเต็มที่ลงนามใน C แทนตัวเลข หากaและbเป็นตัวแปรของประเภทจำนวนเต็มที่ลงนามมาตรฐานจะไม่ต้องการให้คอมไพเลอร์สร้างที่a+=bเก็บนิพจน์เป็นaสิ่งอื่นใดนอกจากผลรวมเลขคณิตของค่าที่เกี่ยวข้อง เพื่อให้แน่ใจว่าหากผลรวมเลขคณิตไม่พอดีaตัวประมวลผลอาจไม่สามารถใส่ได้ แต่มาตรฐานจะไม่ต้องการให้คอมไพเลอร์ตัดทอนหรือตัดค่าหรือทำสิ่งอื่นสำหรับเรื่องนั้นถ้าค่าที่เกิน ข้อ จำกัด สำหรับประเภทของพวกเขา โปรดทราบว่าแม้ว่ามาตรฐานไม่จำเป็นต้องมีการใช้งาน C จะได้รับอนุญาตให้ดักจับทางคณิตศาสตร์ล้นด้วยค่าที่ลงนามแล้ว

จำนวนเต็มที่ไม่ได้ลงนามใน C ทำหน้าที่เป็นวงแหวนพีชคณิตนามธรรมของจำนวนเต็มซึ่งสอดคล้องกันแบบโมดูโลกำลังสองบางส่วนยกเว้นในสถานการณ์ที่เกี่ยวข้องกับการแปลงหรือการดำเนินการด้วยประเภทที่มีขนาดใหญ่กว่า การแปลงจำนวนเต็มขนาดใด ๆเป็นชนิดที่ไม่ได้ลงนามแบบ 32 บิตจะทำให้สมาชิกที่สอดคล้องกับสิ่งต่าง ๆ ที่สอดคล้องกับจำนวนเต็ม mod 4,294,967,296 เหตุผลที่ลบ 3 จาก 2 ให้ผล 4,294,967,295 คือการเพิ่มบางอย่างที่สอดคล้องกันกับ 3 เข้ากับบางอย่างที่สอดคล้องกันกับ 4,294,967,295 จะให้บางสิ่งที่สอดคล้องกันกับ 2

แหวนแบบพีชคณิตนามธรรมมักเป็นสิ่งที่มีประโยชน์ แต่น่าเสียดายที่ C ใช้ความเซ็นชื่อเป็นปัจจัยในการตัดสินใจว่าประเภทควรเป็นแหวนหรือไม่ ค่าที่ไม่ได้รับการลงนามจะถือว่าเป็นตัวเลขมากกว่าสมาชิกวงแหวนเมื่อถูกแปลงเป็นประเภทที่มีขนาดใหญ่กว่าและค่าที่ไม่ได้ลงนามนั้นเล็กกว่าintรับการแปลงเป็นตัวเลขเมื่อดำเนินการทางคณิตศาสตร์ใด ๆ ก็ตาม ถ้าvเป็นuint32_tซึ่งเท่ากับ4,294,967,294แล้วควรจะทำv*=v; v=4น่าเสียดายที่ถ้าintเป็น 64 บิตก็ไม่ได้บอกว่าv*=v;จะทำอะไรได้

ให้มาตรฐานเหมือนเดิมฉันขอแนะนำให้ใช้ประเภทที่ไม่ได้ลงนามในสถานการณ์ที่ต้องการพฤติกรรมที่เกี่ยวข้องกับวงแหวนเชิงพีชคณิตและประเภทที่เซ็นชื่อเมื่อต้องการแสดงตัวเลข มันโชคร้ายที่ C ดึงความแตกต่างในแบบที่เคยทำ แต่พวกมันคือสิ่งที่พวกเขาเป็น

จำนวนเต็มที่ไม่ได้ลงนามมีแนวโน้มที่จะจับคุณในกับดักเฉพาะมากกว่าที่เป็นจำนวนเต็มที่ลงนามแล้ว กับดักมาจากความจริงที่ว่าในขณะที่ 1 & 3 ข้างต้นนั้นถูกต้องทั้งจำนวนเต็มทั้งสองประเภทสามารถกำหนดค่านอกขอบเขตของสิ่งที่มันสามารถ "ถือ" และมันจะถูกแปลงอย่างเงียบ ๆ

unsigned int ui = -1;
signed int si = -1;

if (ui < 0) {
    printf("unsigned < 0\n");
}
if (si < 0) {
    printf("signed < 0\n");
}
if (ui == si) {
    printf("%d == %d\n", ui, si);
    printf("%ud == %ud\n", ui, si);
}

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

signed < 0
-1 == -1
4294967295d == 4294967295d

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

คุณต้องใช้ Integers ที่ไม่ได้ลงชื่อเมื่อเขียนโปรแกรมบนระบบฝังตัว ในลูปเมื่อไม่จำเป็นต้องใช้จำนวนเต็มที่มีลายเซ็นการใช้จำนวนเต็มที่ไม่ได้ลงนามจะช่วยให้ปลอดภัยสำหรับการออกแบบระบบ