การเปรียบเทียบที่ลงชื่อ / ไม่ได้ลงนาม

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

//from limits.h
#define UINT_MAX 0xffffffff /* maximum unsigned int value */
#define INT_MAX  2147483647 /* maximum (signed) int value */
            /* = 0x7fffffff */

int a = INT_MAX;
//_int64 a = INT_MAX; // makes all warnings go away
unsigned int b = UINT_MAX;
bool c = false;

if(a < b) // warning C4018: '<' : signed/unsigned mismatch
    c = true;
if(a > b) // warning C4018: '<' : signed/unsigned mismatch
    c = true;
if(a <= b) // warning C4018: '<' : signed/unsigned mismatch
    c = true;
if(a >= b) // warning C4018: '<' : signed/unsigned mismatch
    c = true;
if(a == b) // no warning <--- warning expected here
    c = true;
if(((unsigned int)a) == b) // no warning (as expected)
    c = true;
if(a == ((int)b)) // no warning (as expected)
    c = true;

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

ในความคิดของฉันการ==เปรียบเทียบครั้งแรกเป็นเพียงการลงนาม / ไม่ได้ลงนามที่ไม่ตรงกันเท่าที่อื่น ๆ ?

เมื่อเปรียบเทียบการเซ็นชื่อกับไม่ได้ลงนามคอมไพลเลอร์จะแปลงค่าที่ลงนามเป็นไม่ได้ลงนาม -1 == (unsigned) -1เพื่อความเท่าเทียมกันนี้ไม่ได้เรื่อง สำหรับการเปรียบเทียบอื่น ๆ -1 > 2Uมันเป็นเรื่องสำคัญเช่นต่อไปนี้เป็นจริง:

แก้ไข: การอ้างอิง:

5/9: (นิพจน์)

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

• ถ้าตัวถูกดำเนินการตัวใดตัวหนึ่งเป็นประเภท long double อีกตัวจะถูกแปลงเป็น long double

• มิฉะนั้นถ้าตัวถูกดำเนินการเป็นสองเท่าอีกตัวจะถูกแปลงเป็นสองเท่า

• มิฉะนั้นถ้าตัวถูกดำเนินการตัวใดตัวหนึ่งลอยอีกตัวจะถูกแปลงเป็นลอย

• มิฉะนั้นการส่งเสริมแบบรวม (4.5) จะดำเนินการกับตัวถูกดำเนินการทั้งสอง 54)

• จากนั้นถ้าตัวถูกดำเนินการตัวใดตัวหนึ่งไม่ได้ลงชื่อยาวอีกตัวจะถูกแปลงเป็นแบบยาวที่ไม่ได้ลงนาม

• มิฉะนั้นถ้าตัวถูกดำเนินการเป็น int ยาวและ int ที่ไม่ได้ลงนามอีกตัวหาก int ยาวสามารถแทนค่าทั้งหมดของ int ที่ไม่ได้ลงนาม int ที่ไม่ได้ลงนามจะถูกแปลงเป็น int แบบยาว มิฉะนั้นตัวถูกดำเนินการทั้งสองจะถูกแปลงเป็น int ยาวที่ไม่ได้ลงนาม

• มิฉะนั้นถ้าตัวถูกดำเนินการตัวใดตัวหนึ่งยาวอีกตัวจะถูกแปลงเป็น long

• มิฉะนั้นถ้าตัวถูกดำเนินการตัวใดตัวหนึ่งไม่ได้ลงนามอีกตัวจะถูกแปลงเป็นไม่ได้ลงนาม

4.7 / 2: (การแปลงอินทิกรัล)

หากประเภทปลายทางไม่ได้ลงนามค่าที่ได้คือจำนวนเต็มที่ไม่ได้ลงชื่อน้อยที่สุดที่สอดคล้องกับจำนวนเต็มต้นทาง (โมดูโล 2 ⁿโดยที่ n คือจำนวนบิตที่ใช้แทนชนิดที่ไม่ได้ลงนาม) [หมายเหตุ: ในการแทนค่าสองส่วนการแปลงนี้เป็นไปตามแนวคิดและไม่มีการเปลี่ยนแปลงในรูปแบบบิต (หากไม่มีการตัดทอน) ]

แก้ไข 2: ระดับคำเตือน MSVC

สิ่งที่ได้รับการเตือนเกี่ยวกับระดับคำเตือนที่แตกต่างกันของ MSVC คือตัวเลือกที่นักพัฒนาสร้างขึ้น อย่างที่ฉันเห็นทางเลือกของพวกเขาเกี่ยวกับความเท่าเทียมกันที่ลงนาม / ไม่ได้ลงนามเทียบกับการเปรียบเทียบที่มากขึ้น / น้อยลงนั้นสมเหตุสมผลแน่นอนว่านี่เป็นเรื่องส่วนตัวทั้งหมด:

-1 == -1หมายความเช่นเดียวกับ-1 == (unsigned) -1- ฉันพบว่าผลลัพธ์ที่เข้าใจง่าย

-1 < 2 ไม่ได้หมายความว่าเช่นเดียวกับ-1 < (unsigned) 2- สิ่งนี้ใช้งานง่ายน้อยกว่าเมื่อมองแวบแรกและ IMO สมควรได้รับคำเตือน "ก่อนหน้านี้"

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

เดาผลลัพธ์ของรหัสนี้หรือไม่?

#include <iostream>

int main() {
        int i = -1;
        unsigned int j = 1;
        if ( i < j ) 
            std::cout << " i is less than j";
        else
            std::cout << " i is greater than j";

        return 0;
}

เอาท์พุต:

i is greater than j

แปลกใจ? การสาธิตออนไลน์: http://www.ideone.com/5iCxY

Bottomline:ในการเปรียบเทียบถ้าตัวถูกดำเนินการตัวหนึ่งเป็นตัวถูกดำเนินunsignedการอีกตัวจะถูกแปลงโดยปริยายunsigned หากประเภทของมันถูกเซ็นชื่อ!

ตัวดำเนินการ == ทำการเปรียบเทียบแบบบิต (โดยการหารอย่างง่ายเพื่อดูว่าเป็น 0 หรือไม่)

การเปรียบเทียบที่เล็ก / ใหญ่กว่านั้นขึ้นอยู่กับสัญลักษณ์ของตัวเลขมาก

ตัวอย่าง 4 บิต:

1111 = 15? หรือ -1?

ดังนั้นถ้าคุณมี 1111 <0001 ... มันคลุมเครือ ...

แต่ถ้าคุณมี 1111 == 1111 ... มันก็เหมือนกันทั้งๆที่คุณไม่ได้ตั้งใจ

ในระบบที่แสดงค่าโดยใช้ 2-complement (ตัวประมวลผลที่ทันสมัยที่สุด) จะมีค่าเท่ากันแม้ในรูปแบบไบนารี นี่อาจเป็นสาเหตุที่คอมไพเลอร์ไม่บ่นเกี่ยวกับa == bมาข

และฉันก็เป็นคอมไพเลอร์ที่แปลกไม่เตือนคุณบน== มา ((int) ข) ฉันคิดว่าควรให้คำเตือนการตัดทอนจำนวนเต็มหรืออะไรบางอย่าง

บรรทัดของรหัสที่เป็นปัญหาไม่สร้างคำเตือน C4018 เนื่องจาก Microsoft ใช้หมายเลขคำเตือนอื่น (เช่นC4389 ) เพื่อจัดการกับกรณีนั้นและ C4389 ไม่ได้เปิดใช้งานโดยค่าเริ่มต้น (เช่นที่ระดับ 3)

จากMicrosoft docsสำหรับ C4389:

// C4389.cpp
// compile with: /W4
#pragma warning(default: 4389)

int main()
{
   int a = 9;
   unsigned int b = 10;
   if (a == b)   // C4389
      return 0;
   else
      return 0;
};

คำตอบอื่น ๆ อธิบายได้ค่อนข้างดีว่าเหตุใด Microsoft จึงตัดสินใจทำกรณีพิเศษจากตัวดำเนินการความเท่าเทียมกัน แต่ฉันพบว่าคำตอบเหล่านั้นไม่เป็นประโยชน์อย่างยิ่งหากไม่กล่าวถึง C4389 หรือวิธีเปิดใช้งานใน Visual StudioStudio

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

int a = 9;
unsigned int b = 10;
bool equal = (a == b); // C4388