So sánh có dấu / không dấu

Tôi đang cố gắng hiểu tại sao đoạn mã sau không đưa ra cảnh báo ở vị trí được chỉ định.

//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;

Tôi nghĩ nó liên quan đến việc quảng bá nền, nhưng hai điều cuối cùng có vẻ nói khác.

Theo suy nghĩ của tôi, ==so sánh đầu tiên chỉ là sự không khớp có dấu / không dấu nhiều như những người khác?

Khi so sánh có dấu với chưa có dấu, trình biên dịch chuyển đổi giá trị có dấu thành không dấu. Đối với sự bình đẳng, điều này không quan trọng -1 == (unsigned) -1,. Để so sánh khác, nó quan trọng, ví dụ sau đây là đúng: -1 > 2U.

CHỈNH SỬA: Tài liệu tham khảo:

5/9: (Biểu thức)

Nhiều toán tử nhị phân mong đợi các toán hạng của kiểu số học hoặc kiểu liệt kê gây ra chuyển đổi và mang lại các kiểu kết quả theo cách tương tự. Mục đích là mang lại một kiểu chung, cũng là kiểu kết quả. Mẫu này được gọi là các chuyển đổi số học thông thường, được định nghĩa như sau:

• Nếu một trong hai toán hạng thuộc loại kép dài, toán hạng kia sẽ được chuyển thành kép dài.

• Ngược lại, nếu một trong hai toán hạng là gấp đôi, toán hạng kia sẽ được chuyển thành kép.

• Ngược lại, nếu một trong hai toán hạng là float, thì toán hạng còn lại sẽ được chuyển thành float.

• Nếu không, các thăng hạng tích hợp (4.5) sẽ được thực hiện trên cả hai toán hạng.54)

• Sau đó, nếu một trong hai toán hạng không có dấu dài thì toán hạng kia sẽ được chuyển thành dài không dấu.

• Ngược lại, nếu một toán hạng là một int dài và một int không dấu khác, thì nếu một int dài có thể đại diện cho tất cả các giá trị của một int không dấu, int unsigned sẽ được chuyển thành một int dài; nếu không thì cả hai toán hạng sẽ được chuyển đổi thành int dài không dấu.

• Ngược lại, nếu một trong hai toán hạng là dài, toán hạng kia sẽ được chuyển thành dài.

• Ngược lại, nếu một trong hai toán hạng không có dấu, toán hạng kia sẽ được chuyển thành không dấu.

4,7 / 2: (Chuyển đổi tích phân)

Nếu kiểu đích là không dấu, giá trị kết quả là số nguyên không dấu nhỏ nhất tương ứng với số nguyên nguồn (modulo 2 ⁿ trong đó n là số bit được sử dụng để biểu thị kiểu không dấu). [Lưu ý: Trong biểu diễn bổ sung của một hai, chuyển đổi này là khái niệm và không có thay đổi trong mẫu bit (nếu không có sự cắt bớt). ]

EDIT2: Mức cảnh báo MSVC

Tất nhiên, những gì được cảnh báo về các mức cảnh báo khác nhau của MSVC là do các nhà phát triển lựa chọn. Như tôi thấy, lựa chọn của họ liên quan đến bình đẳng có dấu / không dấu so với so sánh lớn hơn / ít hơn có ý nghĩa, điều này tất nhiên là hoàn toàn chủ quan:

-1 == -1có nghĩa giống như -1 == (unsigned) -1- Tôi thấy đó là một kết quả trực quan.

-1 < 2 không có nghĩa giống như -1 < (unsigned) 2- Thoạt nhìn, điều này ít trực quan hơn và IMO xứng đáng được cảnh báo "sớm hơn".

Tại sao các cảnh báo có chữ ký / không dấu lại quan trọng và các lập trình viên phải chú ý đến chúng, được minh họa bằng ví dụ sau.

Đoán đầu ra của mã này?

#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;
}

Đầu ra:

i is greater than j

Ngạc nhiên? Demo trực tuyến: http://www.ideone.com/5iCxY

Tóm tắt: so sánh, nếu một toán hạng là unsigned, thì toán hạng khác được chuyển đổi ngầm thành unsigned nếu kiểu của nó là có dấu!

Toán tử == chỉ thực hiện một phép so sánh theo từng bit (bằng phép chia đơn giản để xem nó có phải là 0 hay không).

So sánh nhỏ hơn / lớn hơn phụ thuộc nhiều hơn vào dấu hiệu của số.

4 bit Ví dụ:

1111 = 15? hoặc -1?

vì vậy nếu bạn có 1111 <0001 ... thì rất mơ hồ ...

nhưng nếu bạn có 1111 == 1111 ... Điều tương tự mặc dù bạn không cố ý.

Trong một hệ thống đại diện cho các giá trị bằng cách sử dụng 2 bổ sung (bộ xử lý hiện đại nhất), chúng bằng nhau ngay cả ở dạng nhị phân. Đây có thể là lý do tại sao trình biên dịch không phàn nàn về a == b .

Và đối với tôi, trình biên dịch kỳ lạ không cảnh báo bạn về dấu == ((int) b) . Tôi nghĩ rằng nó sẽ cung cấp cho bạn một cảnh báo cắt bớt số nguyên hoặc một cái gì đó.

Dòng mã được đề cập không tạo ra cảnh báo C4018 vì Microsoft đã sử dụng một số cảnh báo khác (tức là C4389 ) để xử lý trường hợp đó và C4389 không được bật theo mặc định (tức là ở cấp 3).

Từ tài liệu của Microsoft cho 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;
};

Các câu trả lời khác đã giải thích khá rõ tại sao Microsoft có thể quyết định tạo một trường hợp đặc biệt từ toán tử bình đẳng, nhưng tôi thấy những câu trả lời đó không thực sự hữu ích nếu không đề cập đến C4389 hoặc cách kích hoạt nó trong Visual Studio .

Tôi cũng nên đề cập rằng nếu bạn định bật C4389, bạn cũng có thể xem xét bật C4388. Thật không may là không có tài liệu chính thức cho C4388 nhưng nó dường như bật lên trong các biểu thức như sau:

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