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


Hier volgt de c # -code:

   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");
    }

en dit is c ++ code:

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

Beide geven een ander resultaat. Mis ik iets basaals? Enig idee?


38
2017-11-25 07:49


oorsprong


antwoorden:


C ++ en C # zijn verschillende talen. Ze hebben verschillende regels voor het afhandelen van type promotie in het geval van vergelijkingen.

In C ++ en C worden ze meestal vergeleken alsof ze allebei niet ondertekend zijn. Dit wordt "niet-ondertekend bewaren" genoemd. C ++ en C-compilers maken traditioneel gebruik van "unsigned preserving" en het gebruik hiervan wordt gespecificeerd in de C ++ -standaard en in K & R.

In C # worden beide geconverteerd naar gesigneerde longs en vervolgens vergeleken. Dit wordt "waardebehoud" genoemd. C # specificeert waardebehoud.

ANSI C specificeert ook waardebehoud, maar alleen als het gaat om shorts en chars. Shorts en chars (ondertekend en niet-ondertekend) worden op een waardeverminderende manier upconverted naar ints en vervolgens vergeleken. Dus als een niet-ondertekende short werd vergeleken met een ondertekende short, zou het resultaat eruit komen als het C # -voorbeeld. Telkens wanneer een conversie naar een groter formaat wordt uitgevoerd, gebeurt dit op een waardebehoudende manier, maar als de twee variabelen dezelfde grootte hebben (en geen korte broeken of tekens) en beide variabelen niet ondertekend zijn, worden ze vergeleken als niet-ondertekende hoeveelheden in ANSI C. Er is een goede discussie over de boven- en onderkant van beide benaderingen in de veelgestelde vragen over comp.lang.c.


47
2017-11-25 07:54



In C ++, wanneer u een vergelijkt unsigned int en een signed int, de signed int wordt geconverteerd naar unsigned int. Een negatief omzetten signed int aan een unsigned int wordt gedaan door toe te voegen UINT_MAX + 1, die groter is dan 12 en dus het resultaat.

Als u in C # het tegenovergestelde resultaat krijgt, betekent dit dat in C # beide uitdrukkingen worden geconverteerd naar signed int  signed long (long of System.Int64)1 en dan vergeleken.

In C ++ moet uw compiler u de waarschuwing hebben gegeven:

waarschuwing: vergelijking tussen ondertekende en niet-ondertekende integer-expressies

Regel:
Neem de waarschuwingen van de compiler altijd serieus!

1 Zoals terecht opgemerkt door svick in opmerkingen.


12
2017-11-25 07:55



Ik weet niet wat de standaard is van C #, maar in de C ++ -standaard, usual arithmetic conversions zou worden toegepast op beide operanden van relationele operatoren:

[......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.

Dus wanneer unsigned int wordt vergeleken met int, int zou worden omgezet in unsigned int, en -2 zou een heel groot aantal worden als het wordt omgezet naar unsigned int.


4
2017-11-25 08:30