Vorzeichenbehaftete / vorzeichenlose Vergleiche

Ich versuche zu verstehen, warum der folgende Code an der angegebenen Stelle keine Warnung ausgibt.

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

Ich dachte, es hätte mit Hintergrundwerbung zu tun, aber die letzten beiden scheinen etwas anderes zu sagen.

Meiner Meinung nach ist der erste ==Vergleich genauso eine signierte / nicht signierte Nichtübereinstimmung wie die anderen?

Beim Vergleich von vorzeichenbehafteten mit vorzeichenlosen Werten konvertiert der Compiler den vorzeichenbehafteten Wert in vorzeichenlosen Wert. Für die Gleichstellung spielt dies keine Rolle -1 == (unsigned) -1. Für andere Vergleiche ist es wichtig, zB gilt : -1 > 2U.

EDIT: Referenzen:

5/9: (Ausdrücke)

Viele binäre Operatoren, die Operanden vom Typ Arithmetik oder Aufzählung erwarten, verursachen Konvertierungen und ergeben auf ähnliche Weise Ergebnistypen. Der Zweck besteht darin, einen gemeinsamen Typ zu erhalten, der auch der Typ des Ergebnisses ist. Dieses Muster wird als übliche arithmetische Konvertierung bezeichnet, die wie folgt definiert ist:

• Wenn einer der Operanden vom Typ long double ist, wird der andere in long double konvertiert.

• Wenn andernfalls einer der Operanden doppelt ist, wird der andere in double konvertiert.

• Andernfalls wird, wenn einer der Operanden float ist, der andere in float konvertiert.

• Andernfalls werden die integralen Beförderungen (4.5) für beide Operanden durchgeführt.54)

• Wenn dann einer der Operanden lange ohne Vorzeichen ist, wird der andere in Long ohne Vorzeichen konvertiert.

• Wenn andernfalls ein Operand ein Long-Int und der andere ein Int ohne Vorzeichen ist, muss das Int ohne Vorzeichen in ein Long-Int konvertiert werden, wenn ein Long-Int alle Werte eines Int ohne Vorzeichen darstellen kann. Andernfalls werden beide Operanden in unsigned long int konvertiert.

• Andernfalls wird, wenn einer der Operanden lang ist, der andere in long konvertiert.

• Andernfalls wird, wenn einer der Operanden ohne Vorzeichen ist, der andere in einen Vorzeichen ohne Vorzeichen konvertiert.

4.7 / 2: (Integrale Konvertierungen)

Wenn der Zieltyp ohne Vorzeichen ist, ist der resultierende Wert die am wenigsten vorzeichenlose Ganzzahl, die mit der Quell-Ganzzahl kongruent ist (Modulo 2 ^n, wobei n die Anzahl der Bits ist, die zur Darstellung des vorzeichenlosen Typs verwendet werden). [Hinweis: In der Zweierkomplementdarstellung ist diese Konvertierung konzeptionell und das Bitmuster ändert sich nicht (wenn keine Kürzung vorliegt). ]]

EDIT2: MSVC-Warnstufen

Was bei den verschiedenen Warnstufen von MSVC gewarnt wird, sind natürlich die Entscheidungen der Entwickler. Aus meiner Sicht sind ihre Entscheidungen in Bezug auf signierte / nicht signierte Gleichheit im Vergleich zu größeren / weniger Vergleichen sinnvoll. Dies ist natürlich völlig subjektiv:

-1 == -1bedeutet das gleiche wie -1 == (unsigned) -1- ich finde das ein intuitives Ergebnis.

-1 < 2 bedeutet nicht dasselbe wie -1 < (unsigned) 2- Dies ist auf den ersten Blick weniger intuitiv und IMO verdient eine "frühere" Warnung.

Warum signierte / nicht signierte Warnungen wichtig sind und Programmierer sie beachten müssen, zeigt das folgende Beispiel.

Erraten Sie die Ausgabe dieses Codes?

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

Ausgabe:

i is greater than j

Überrascht? Online-Demo: http://www.ideone.com/5iCxY

Fazit: Wenn im Vergleich ein Operand ist unsigned, wird der andere Operand implizit in konvertiert, unsigned wenn sein Typ signiert ist!

Der Operator == führt nur einen bitweisen Vergleich durch (durch einfache Division, um festzustellen, ob er 0 ist).

Die kleineren / größeren als Vergleiche hängen viel mehr vom Vorzeichen der Zahl ab.

4 Bit Beispiel:

1111 = 15? oder -1?

Wenn Sie also 1111 <0001 haben ... ist es mehrdeutig ...

aber wenn Sie 1111 == 1111 haben ... Es ist das gleiche, obwohl Sie es nicht so gemeint haben.

In einem System, das die Werte mit 2-Komplementen darstellt (modernste Prozessoren), sind sie auch in ihrer binären Form gleich. Dies kann der Grund sein, warum sich der Compiler nicht über a == b beschwert .

Und für mich ist es ein seltsamer Compiler, der Sie nicht vor a == ((int) b) warnt . Ich denke, es sollte Ihnen eine Ganzzahl-Kürzungswarnung oder so geben.

Die betreffende Codezeile generiert keine C4018-Warnung, da Microsoft eine andere Warnnummer (z. B. C4389 ) verwendet hat, um diesen Fall zu behandeln, und C4389 standardmäßig nicht aktiviert ist (dh auf Stufe 3).

Aus den Microsoft-Dokumenten für 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;
};

Die anderen Antworten haben recht gut erklärt, warum Microsoft möglicherweise beschlossen hat, aus dem Gleichheitsoperator einen Sonderfall zu machen, aber ich finde, dass diese Antworten nicht besonders hilfreich sind, ohne C4389 zu erwähnen oder wie man es in Visual Studio aktiviert .

Ich sollte auch erwähnen, dass Sie, wenn Sie C4389 aktivieren möchten, möglicherweise auch die Aktivierung von C4388 in Betracht ziehen. Leider gibt es keine offizielle Dokumentation für C4388, aber es scheint in Ausdrücken wie den folgenden aufzutauchen:

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