İmzalı / imzasız karşılaştırmalar

Aşağıdaki kodun belirtilen yerde neden uyarı vermediğini anlamaya çalışıyorum.

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

Bunun arka plan tanıtımıyla ilgili olduğunu düşündüm, ancak son ikisi aksini söylüyor gibi görünüyor.

Bana göre, ilk ==karşılaştırma diğerleri kadar imzalı / imzasız bir uyumsuzluk mu?

İşaretli ile işaretsiz karşılaştırılırken, derleyici işaretli değeri işaretsiz olarak dönüştürür. Eşitlik için bu önemli değil -1 == (unsigned) -1. Bu konularda diğer karşılaştırmalar için aşağıdakileri örneğin doğrudur: -1 > 2U.

DÜZENLEME: Referanslar:

5/9: (İfadeler)

Aritmetik veya numaralandırma türünde işlenenler bekleyen birçok ikili işleç, dönüşümlere neden olur ve sonuç türlerini benzer şekilde verir. Amaç, aynı zamanda sonucun türü olan ortak bir tür elde etmektir. Bu model, aşağıdaki gibi tanımlanan normal aritmetik dönüşümler olarak adlandırılır:

• İşlenenlerden biri long double türündeyse, diğeri long double türüne dönüştürülür.

• Aksi takdirde, işlenenlerden biri double ise diğeri double'a dönüştürülür.

• Aksi takdirde, işlenenlerden biri float ise diğeri float'a dönüştürülür.

• Aksi takdirde, integral yükseltmeler (4.5) her iki işlenen üzerinde gerçekleştirilecektir. 54)

• Daha sonra, işlenenlerden biri uzun süre işaretsiz ise, diğeri işaretsiz uzunluğa dönüştürülür.

• Aksi takdirde, bir işlenen bir uzun int ve diğer işaretsiz int ise, o zaman bir uzun int, işaretsiz bir int'in tüm değerlerini temsil edebiliyorsa, işaretsiz int, bir long int'e dönüştürülür; aksi takdirde her iki işlenen de unsigned long int türüne dönüştürülür.

• Aksi takdirde, işlenenlerden biri uzunsa, diğeri uzuna dönüştürülür.

• Aksi takdirde, işlenenlerden biri işaretsiz ise, diğeri işaretsiz hale getirilecektir.

4.7 / 2: (İntegral dönüşümler)

Hedef tipi işaretsiz ise, sonuçta elde edilen değer kaynak tamsayı ile uyumlu en az işaretsiz tamsayıdır (modulo 2 ^n, burada n işaretsiz tipi temsil etmek için kullanılan bit sayısıdır). [Not: Bir ikinin tümleyen gösteriminde, bu dönüşüm kavramsaldır ve bit modelinde herhangi bir değişiklik olmaz (eğer kesilme yoksa). ]

EDIT2: MSVC uyarı seviyeleri

MSVC'nin farklı uyarı seviyelerinde uyarılan, elbette geliştiriciler tarafından yapılan seçimlerdir. Gördüğüm kadarıyla, imzalı / işaretsiz eşitliğe karşı büyük / az karşılaştırmalarıyla ilgili seçimleri anlamlı, bu elbette tamamen özneldir:

-1 == -1aynı anlama gelir -1 == (unsigned) -1- bunu sezgisel bir sonuç buluyorum.

-1 < 2 gelmez aynı anlama -1 < (unsigned) 2Bu ilk bakışta az sezgisel ve IMO bir "erken" uyarısı hak -.

İmzalı / imzasız uyarıların neden önemli olduğu ve programcıların bunlara dikkat etmesi gerektiği aşağıdaki örnekle gösterilmiştir.

Bu kodun çıktısını tahmin edin?

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

Çıktı:

i is greater than j

Şaşırdın mı? Çevrimiçi Demo: http://www.ideone.com/5iCxY

Bottomline: tek işlenen ise karşılaştırıldığında, unsigneddaha sonra diğer işlenen örtülü dönüştürülür unsigned eğer onun tipi imzalanmış!

== operatörü yalnızca bit düzeyinde bir karşılaştırma yapar (0 olup olmadığını görmek için basit bölme ile).

Karşılaştırmalardan daha küçük / büyük, sayının işaretine çok daha fazla bağlıdır.

4 bit Örnek:

1111 = 15? veya -1?

yani 1111 <0001'e sahipseniz ... belirsizdir ...

ama eğer 1111 == 1111'e sahipseniz ... Bunu kastetmemiş olmanıza rağmen aynı şeydir.

2-tamamlayıcı kullanan (çoğu modern işlemci) değerleri temsil eden bir sistemde, ikili biçimlerinde bile eşittirler. Derleyicinin a == b'den şikayet etmemesinin nedeni bu olabilir .

Ve bana göre tuhaf bir derleyici sizi a == ((int) b) konusunda uyarmıyor . Sanırım size tamsayı kesilme uyarısı falan vermeli.

Söz konusu kod satırı bir C4018 uyarısı oluşturmaz çünkü Microsoft bu durumu işlemek için farklı bir uyarı numarası (örneğin, C4389 ) kullanmıştır ve C4389 varsayılan olarak etkinleştirilmemiştir (yani 3. seviyede).

C4389 için Microsoft dokümanlarından :

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

Diğer yanıtlar, Microsoft'un neden eşitlik operatöründen özel bir durum oluşturmaya karar verebileceğini oldukça iyi açıkladı, ancak bu yanıtların C4389'dan veya Visual Studio'da nasıl etkinleştirileceğinden .

C4389'u etkinleştirecekseniz, C4388'i de etkinleştirmeyi düşünebileceğinizi de belirtmeliyim. Maalesef C4388 için resmi bir belge yok ancak aşağıdaki gibi ifadelerde karşımıza çıkıyor:

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