Why is this happening with the sizeof operator when comparing with a negative number? [duplicate]

by

sizeof returns size_t which is unsigned and so -1 is being converted to a very large unsigned number. Using the right warning level would have helped here, clang with the -Wconversion or -Weverything(note this is not for production use) flags warns us:

warning: implicit conversion changes signedness: 'int' to 'unsigned long' [-Wsign-conversion]
   if (sizeof(int) > -1)
                   ~ ^~

For gcc you receive a similar warning using the -Wextra flag:

warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
    if (sizeof(int) > -1)
                    ^

For reference, we know size_t is unsigned from the draft C99 standard section 7.17 Common definitions which says:

 size_t

which is the unsigned integer type of the result of the sizeof operator;[…]

Note, it does not specify anything else about the type, in my specific case it happens to be unsigned long but it does not have to be.

The conversion of -1 is due to the usual arithmetic conversion covered in section 6.3.1.8 Usual arithmetic conversions which says:

[…]

Otherwise, if the operand that has unsigned integer type has rank greater or
equal to the rank of the type of the other operand, then the operand with
signed integer type is 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, then
the operand with unsigned integer type is converted to the type of the
operand with signed integer type.

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

So the only time -1 would not be converted to an unsigned value would be if int could represent all the values of size_t, which is not the case here.

Why -1 ends up being a large unsigned value, actually it ends up being being the max value of the unsigned type is due to section 6.3.1.3 Signed and unsigned integers which says:

Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or
subtracting one more than the maximum value that can be represented in the new type
until the value is in the range of the new type.49)

So we end up with:

-1 + (UMAX + 1)

which is:

UMAX

and thus end up with:

if (sizeof(int) > UMAX )

More Related Contents:

  1. Logic behind sizeof operator [duplicate]
  2. How to find the ‘sizeof’ (a pointer pointing to an array)?
  3. What does sizeof(&array) return?
  4. Are there machines, where sizeof(char) != 1, or at least CHAR_BIT > 8?
  5. Why does a C-Array have a wrong sizeof() value when it’s passed to a function? [duplicate]
  6. newbie questions about malloc and sizeof
  7. Using sizeof with a dynamically allocated array
  8. What does ‘sizeof (function name)’ return?
  9. Checking the size of an object in Objective-C
  10. What is guaranteed about the size of a function pointer?
  11. Is dereferencing null pointer valid in sizeof operation [duplicate]
  12. Behavior of sizeof on variable length arrays (C only)
  13. How can I print the result of sizeof() at compile time in C?
  14. How can I find the number of elements in an array?
  15. Why is (sizeof(int) > -1) false? [duplicate]
  16. Getting the size of a malloc only with the returned pointer
  17. Sizeof arrays and pointers
  18. How to find the size of an array (from a pointer pointing to the first element array)?
  19. Integer conversions(narrowing, widening), undefined behaviour
  20. Using sizeof() on malloc’d memory [duplicate]
  21. Why do I get a warning every time I use malloc?
  22. sizeof single struct member in C
  23. Implementation of sizeof operator
  24. Access struct members as if they are a single array?
  25. Is there any reason not to use fixed width integer types (e.g. uint8_t)?
  26. Is the operand of `sizeof` evaluated with a VLA?
  27. why sizeof(‘a’) is 4 in C? [duplicate]
  28. Find size of array without using sizeof
  29. Why is the size of a function in C always 1 byte?
  30. size of a datatype without using sizeof

Leave a Comment