Signed/unsigned comparisons

by

When comparing signed with unsigned, the compiler converts the signed value to unsigned. For equality, this doesn’t matter, -1 == (unsigned) -1. For other comparisons it matters, e.g. the following is true: -1 > 2U.

EDIT: References:

5/9: (Expressions)

Many binary operators that expect
operands of arithmetic or enumeration
type cause conversions and yield
result types in a similar way. The
purpose is to yield a common type,
which is also the type of the result.
This pattern is called the usual
arithmetic conversions, which are
defined as follows:

  • If either
    operand is of type long double, the
    other shall be converted to long
    double.
  • Otherwise, if either operand
    is double, the other shall be
    converted to double.
  • Otherwise, if
    either operand is float, the other
    shall be converted to float.
  • Otherwise, the integral promotions
    (4.5) shall be performed on both
    operands.54)
  • Then, if either operand
    is unsigned long the other shall be
    converted to unsigned long.
  • Otherwise, if one operand is a long
    int and the other unsigned int, then
    if a long int can represent all the
    values of an unsigned int, the
    unsigned int shall be converted to a
    long int; otherwise both operands
    shall be converted to unsigned long
    int.
  • Otherwise, if either operand is
    long, the other shall be converted to
    long.
  • Otherwise, if either operand
    is unsigned, the other shall be
    converted to unsigned.

4.7/2: (Integral conversions)

If the destination type is unsigned,
the resulting value is the least
unsigned integer congruent to the
source integer (modulo 2n where n is
the number of bits used to represent
the unsigned type). [Note: In a two’s
complement representation, this
conversion is conceptual and there is
no change in the bit pattern (if there
is no truncation). ]

EDIT2: MSVC warning levels

What is warned about on the different warning levels of MSVC is, of course, choices made by the developers. As I see it, their choices in relation to signed/unsigned equality vs greater/less comparisons make sense, this is entirely subjective of course:

-1 == -1 means the same as -1 == (unsigned) -1 – I find that an intuitive result.

-1 < 2 does not mean the same as -1 < (unsigned) 2 – This is less intuitive at first glance, and IMO deserves an “earlier” warning.

More Related Contents:

  1. How do I deal with “signed/unsigned mismatch” warnings (C4018)?
  2. What happens if I assign a negative value to an unsigned variable?
  3. Iteration over std::vector: unsigned vs signed index variable
  4. c++ vector size. why -1 is greater than zero
  5. Why does this if condition fail for comparison of negative and positive integers [duplicate]
  6. C++ convert hex string to signed integer
  7. Comparison operation on unsigned and signed integers
  8. How do I see a C/C++ source file after preprocessing in Visual Studio?
  9. Export all symbols when creating a DLL
  10. What are some reasons a Release build would run differently than a Debug build [closed]
  11. Is floating-point == ever OK?
  12. Comparing arrays for equality in C++
  13. Automatically stop Visual C++ 2008 build at first compile error?
  14. Why is a negative int greater than unsigned int? [duplicate]
  15. performance of unsigned vs signed integers
  16. Why does -INT_MIN = INT_MIN in a signed, two’s complement representation?
  17. How to link winsock.lib?
  18. what happens when i mix signed and unsigned types ?
  19. c++ comparison of two double values not working properly [duplicate]
  20. Why put the constant before the variable in a comparison?
  21. How do I print to the debug output window in a Win32 app?
  22. Why is −1 > sizeof(int)?
  23. What is the difference between ImageMagick and GraphicsMagick?
  24. How to compare two time stamp in format “Month Date hh:mm:ss” to check +ve or -ve value
  25. Is there some meaningful statistical data to justify keeping signed integer arithmetic overflow undefined?
  26. How to use typelists
  27. pointer comparisons “>” with one before the first element of an array object
  28. What happens when I mix signed and unsigned types in C++?
  29. Checking if all elements of a vector are equal in C++
  30. “Step over” when debugging multithreaded programs in Visual Studio

Leave a Comment