5

I am having a problem with a program I wrote. The program is going into a if statement whereas it should not. I have two variables:

size_t len = 5;
int    tmp = -1;

When I do :

if (tmp > len)
    ft_putstr("this is crazy");

I prints out "this is crazy whereas -1 is smaller than 5 to me ! Ok, ok. So I looked on my favorite website and saw this.

When trying: 

printf("%zu", tmp)

I see a big positive number. Ok ! This might be the reason why my program goes into the if condition above, but how can I make it not to go inside the if condition ??? thanks

Community
  • 1
  • 1
ziKmouT
  • 175
  • 2
  • 2
  • 13

2 Answers2

10

The problem here is that you are trying to compare something that is unsigned with something that is signed. This means that there's an implicit conversion involved before the actual conversion is done. In this case the signed is converted to unsigned (which is normally not what one would want - therefore many compilers have options to display warning when this is done).

To do it more correct in a sloppy way you would write:

 if( (int)tmp > (int)len )

however this ignores the fact that size_t could have values that are too large for int. To be strict one would have to handle that the range of int combined with the range of size_t could be larger than any available type. This means that you would have to handle this in two cases, so you would use the fact that if tmp<0 then tmp<len (mathematically, since len>=0). So for example mathematically tmp<len would be written as tmp<0 || tmp<len. And the opposite would be tmp>=0 && tmp >= len. You should therefore write:

 if( tmp >= 0 && tmp > len )

Note that then the conversion is not a problem, tmp could after the first check be converted to unsigned without change of value, different ranges of int and size_t are not a problem either as the smaller is converted to wider range before comparison.

The only problem left is that if you have enabled warnings about signed-unsigned comparison (to detect these kind of mistakes) it would still warn. To take care of that you would need to explicitely type cast it, but we know that conversion to unsigned doesn't change tmp once we checked that tmp>=0. So to avoid warnings you would write:

if( tmp >= 0 && (unsigned)tmp > len) )

the (unsigned) is because tmp is an int, you need to respect the type when converting to unsigned if tmp were of another type.

skyking
  • 13,817
  • 1
  • 35
  • 57
0

You have to understand the difference between different variable type. variable types such as int, unsigned, size_t etc. has different behaviour and based on that you get the results.

If you truly want to compare two numbers, they all have to be on same level (variable type) else you get unexpected results.

Following will solve your problem.

if(tmp > (int)len)
    ft_putstr("this is crazy");

As @jblixr suggested (thanks for the comment), you may want to take care of sizeof these variable types and make sure that the values are not lost while converting the values from one data type to another data type.

Pawan
  • 1,537
  • 1
  • 15
  • 19
  • 3
    Do you think it is a good solution ah? What happens if `len` is like `4294967295`? Then `len` will be treated like a negative number. – jblixr Jan 29 '16 at 07:58
  • @jblixr If you are referring to sizeof `size_t` and `int`; NO. – Pawan Jan 29 '16 at 08:01
  • 1
    How likely is it that a `size_t` value is larger than `INT_MAX`? Not very. This comparison is fine in the majority of cases. – Per Johansson Jan 29 '16 at 08:25
  • @PerJohansson Under for example MS-dos that can happen when using huge memory model. With `INT_MAX` being 32767 and `size_t` being 32-bit you could be in for some trouble. Even on modern system under some 64-bit OSes you have `int` being 32-bit while `size_t` being 64-bit (and there are cases where you actually have `size_t` being larger than 2GiB). I'd say it's quite likely that `size_t` value is larger than `INT_MAX`. – skyking Jan 29 '16 at 08:28