unsigned int (c++) vs uint (c#)

Question

Voici le code c# :

   static void Main(string[] args)
    {
        uint y = 12;
        int x = -2;
        if (x > y)
            Console.WriteLine("x is greater");
        else
            Console.WriteLine("y is greater");
    }

et ceci est du code c++ :

int _tmain(int argc, _TCHAR* argv[])
{
unsigned int y = 12;
int x = -2;
if(x>y)
    printf("x is greater");
else
    printf("y is greater");

return 0;
}

Les deux donnent des résultats différents. Ai-je manqué quelque chose de fondamental ? Vous avez une idée ?

Answer 1

C++ et C# sont des langages différents. Ils ont des règles différentes pour gérer la promotion de type en cas de comparaisons.

En C++ et C, ils sont généralement comparés comme s'ils étaient tous deux non signés. Cela s'appelle "unsigned preserving". Les compilateurs C++ et C utilisent traditionnellement la "préservation non signée" et son utilisation est spécifiée dans la norme C++ et dans K&R.

En C#, ils sont tous deux convertis en longs signés, puis comparés. C'est ce qu'on appelle la "préservation de la valeur". Le C# spécifie la préservation de la valeur.

L'ANSI C spécifie également la préservation des valeurs, mais uniquement lorsqu'il s'agit de courts et de caractères. Les shorts et les chars (signés et non signés) sont convertis en ints de manière à préserver la valeur, puis comparés. Ainsi, si un short non signé était comparé à un short signé, le résultat serait semblable à l'exemple du C#. Chaque fois qu'une conversion vers une taille supérieure est effectuée, elle est réalisée en préservant la valeur, mais si les deux variables sont de la même taille (et non des shorts ou des chars) et que l'une ou l'autre est non signée, elles sont comparées comme des quantités non signées en ANSI C. Il existe une bonne discussion sur les avantages et les inconvénients des deux approches. dans la FAQ comp.lang.c .

Answer 2

En C++, lorsque vous comparez un unsigned int et un signed int le signed int est converti en unsigned int . Conversion d'un négatif signed int à un unsigned int se fait en ajoutant UINT_MAX + 1 qui est plus grande que 12 et donc le résultat.

En C#, si vous obtenez le résultat inverse, cela signifie qu'en C# les deux expressions sont transformées en signed int signed long ( long o System.Int64 ) 1 et ensuite comparés.

En C++, votre compilateur a dû vous donner l'avertissement :

avertissement : comparaison entre des expressions entières signées et non signées

Règle :
Prenez toujours au sérieux les avertissements émis par le compilateur !

1 Comme l'a souligné à juste titre svick dans les commentaires.

Answer 3

Je ne connais pas la norme du C#, mais dans la norme du C++, usual arithmetic conversions s'appliquerait aux deux opérandes des opérateurs relationnels :

[......enum, floating point type involed......] 

— Otherwise, the integral promotions (4.5) shall be performed on both operands.
  Then the following rules shall be applied to the promoted operands:

    — If both operands have the same type, no further conversion is needed.

    — Otherwise, if both operands have signed integer types or both have
      unsigned integer types, the operand with the type of lesser integer
      conversion rank shall be converted to the type of the operand with
      greater rank.

    — Otherwise, if the operand that has unsigned integer type has rank
      greater than or equal to the rank of the type of the other operand, the
      operand with signed integer type shall be converted to  the type of the
      operand with unsigned integer type.

    — Otherwise, if the type of the operand with signed integer type can
      represent all of the values of the type of the operand with unsigned
      integer type, the operand with unsigned integer type shall be converted
      to the type of the operand with signed integer type.

    — Otherwise, both operands shall be converted to the unsigned integer type 
      corresponding to the type of the operand with signed integer type.

Ainsi, lorsque unsigned int est comparé à int , int serait converti en unsigned int y -2 deviendrait un très grand nombre lorsqu'il est converti en unsigned int .