การลบจำนวนเต็มไม่ได้ลงนามกำหนดพฤติกรรมหรือไม่

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

unsigned int To, Tf;

To = getcounter();
while (1) {
    Tf = getcounter();
    if ((Tf-To) >= TIME_LIMIT) {
        break;
    } 
}

นี่เป็นเพียงคำพูดที่เกี่ยวข้องอย่างคลุมเครือจากมาตรฐาน C ที่ฉันหาได้

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

ฉันคิดว่าอาจใช้คำพูดนั้นเพื่อหมายความว่าเมื่อตัวถูกดำเนินการด้านขวามีขนาดใหญ่ขึ้นการดำเนินการจะถูกปรับให้มีความหมายในบริบทของตัวเลขที่ถูกตัดทอนโมดูโล

กล่าวคือ

0x0000 - 0x0001 == 0x 1 0000 - 0x0001 == 0xFFFF

เมื่อเทียบกับการใช้ความหมายที่ลงนามขึ้นอยู่กับการใช้งาน:

0x0000 - 0x0001 == (ไม่ได้ลงนาม) (0 + -1) == (0xFFFF แต่ยัง 0xFFFE หรือ 0x8001)

ข้อใดหรือการตีความที่ถูกต้อง? กำหนดไว้เลยหรือไม่?

ผลลัพธ์ของการลบที่สร้างจำนวนลบในประเภทที่ไม่ได้ลงนามนั้นมีการกำหนดไว้อย่างชัดเจน:

1. [... ] การคำนวณที่เกี่ยวข้องกับตัวถูกดำเนินการที่ไม่ได้ลงชื่อจะไม่มีวันล้นเพราะผลลัพธ์ที่ไม่สามารถแสดงโดยประเภทจำนวนเต็มที่ไม่ได้ลงนามที่เป็นผลลัพธ์จะลดโมดูโลจำนวนที่มากกว่าค่าที่มากที่สุดค่าหนึ่งที่สามารถแสดงโดยประเภทผลลัพธ์ได้ (ISO / IEC 9899: 1999 (E) §6.2.5 / 9)

อย่างที่คุณเห็น(unsigned)0 - (unsigned)1เท่ากับ -1 โมดูโล UINT_MAX + 1 หรือกล่าวอีกนัยหนึ่งคือ UINT_MAX

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

เมื่อคุณทำงานกับประเภทที่ไม่ได้ลงนามจะเกิดการคำนวณทางคณิตศาสตร์แบบแยกส่วน (หรือที่เรียกว่าพฤติกรรม"ล้อมรอบ" ) หากต้องการทำความเข้าใจเกี่ยวกับการคำนวณทางคณิตศาสตร์แบบแยกส่วนเพียงแค่ดูนาฬิกาเหล่านี้:

9 + 4 = 1 ( 13 mod 12 ) ดังนั้นในทิศทางอื่นคือ: 1 - 4 = 9 ( -3 mod 12 ) ใช้หลักการเดียวกันในขณะที่ทำงานกับประเภทที่ไม่ได้ลงชื่อ ถ้าชนิดของผลลัพธ์เป็นunsignedเลขคณิตแบบแยกส่วนจะเกิดขึ้น

ตอนนี้ดูการดำเนินการต่อไปนี้ที่จัดเก็บผลลัพธ์เป็นunsigned int:

unsigned int five = 5, seven = 7;
unsigned int a = five - seven;      // a = (-2 % 2^32) = 4294967294 

int one = 1, six = 6;
unsigned int b = one - six;         // b = (-5 % 2^32) = 4294967291

เมื่อคุณต้องการเพื่อให้แน่ใจว่าผลจะsignedเก็บไว้แล้วลงในตัวแปรหรือโยนมันทิ้งไปsigned signedเมื่อคุณต้องการได้รับความแตกต่างระหว่างตัวเลขและตรวจสอบให้แน่ใจว่าจะไม่มีการใช้เลขคณิตแบบแยกส่วนคุณควรพิจารณาใช้abs()ฟังก์ชันที่กำหนดในstdlib.h:

int c = five - seven;       // c = -2
int d = abs(five - seven);  // d =  2

ระวังให้มากโดยเฉพาะอย่างยิ่งในขณะที่เขียนเงื่อนไขเนื่องจาก:

if (abs(five - seven) < seven)  // = if (2 < 7)
    // ...

if (five - seven < -1)          // = if (-2 < -1)
    // ...

if (one - six < 1)              // = if (-5 < 1)
    // ...

if ((int)(five - seven) < 1)    // = if (-2 < 1)
    // ...

แต่

if (five - seven < 1)   // = if ((unsigned int)-2 < 1) = if (4294967294 < 1)
    // ...

if (one - six < five)   // = if ((unsigned int)-5 < 5) = if (4294967291 < 5)
    // ...

การตีความครั้งแรกนั้นถูกต้อง อย่างไรก็ตามเหตุผลของคุณเกี่ยวกับ "ความหมายที่ลงนาม" ในบริบทนี้ไม่ถูกต้อง

อีกครั้งการตีความครั้งแรกของคุณถูกต้อง เลขคณิตที่ไม่ได้ลงนามเป็นไปตามกฎของเลขคณิตแบบโมดูโลซึ่งหมายความว่า0x0000 - 0x0001จะประเมินเป็น0xFFFFประเภทที่ไม่ได้ลงชื่อ 32 บิต

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

ตัวอย่างเช่นการประเมินผลนี้

signed int a = 0, b = 1;
unsigned int c = a - b;

ยังคงรับประกันว่าจะให้UINT_MAXในcแม้ว่าแพลตฟอร์มจะใช้เป็นตัวแทนที่แปลกใหม่สำหรับจำนวนเต็มลงนาม

กับตัวเลขที่ได้รับการรับรองจากประเภทunsigned intหรือขนาดใหญ่ในกรณีที่ไม่มีการแปลงชนิดa-bถูกกำหนดให้เป็นผลผลิตจำนวนไม่ได้ลงนามซึ่งเมื่อเข้ามาจะให้ผลผลิตb aการแปลงจำนวนลบเป็นไม่ได้ลงนามหมายถึงการให้จำนวนซึ่งเมื่อบวกกับจำนวนเดิมที่กลับเครื่องหมายจะให้ผลเป็นศูนย์ (ดังนั้นการแปลง -5 เป็นไม่ได้ลงนามจะให้ค่าซึ่งเมื่อเพิ่มเป็น 5 จะให้ผลเป็นศูนย์) .

หมายเหตุว่าตัวเลขที่ได้รับการรับรองมีขนาดเล็กกว่าunsigned intอาจได้รับการเลื่อนตำแหน่งให้เป็นประเภทintก่อนที่จะลบพฤติกรรมของจะขึ้นอยู่กับขนาดของa-bint